-
R apply(T t)： 输入T类型的参数，运行相关逻辑后，返回R类型的结果。
使用示例：
/**
* R apply(T t): 输入T类型的参数，运行相关逻辑后，返回R类型的结果。
*/
@Test
public void test1() {
Function<String, Staff> function = x -> {
Staff s = new Staff();
s.setName(x + ", 咿呀咿呀哟!");
return s;
};
Staff staff = function.apply("邓某");
// 输出: 邓某, 咿呀咿呀哟!
System.out.println(staff.getName());
}
-
Function<V, R> compose(Function<? super V, ? extends T> before)： 由两个旧的Function得到一个新的Function。
假设： 现有式子functionC = functionB.compose(functionA)，functionA 泛型为<P1, R1>， functionB泛型为<R1, R2>。
那么， 上述式子的逻辑是：先运行functionA<P1, R1>的apply方法，然后将其返回值作为functionB<R1, R2>的apply方法的入参，执行functionB<R1, R2>的apply方法，返回一个泛型为<P1, R2>的functionC<P1, R2>。
使用示例：
/**
* <V> Function<V, R> compose(Function<? super V, ? extends T> before):由两个旧的Function得到一个新的Function。
*
* 假设：现有式子functionC = functionB.compose(functionA)，
* functionA泛型为<P1, R1>， functionB泛型为<R1, R2>。
*
* 那么，上述式子的逻辑是:先运行functionA<P1, R1>的apply方法，然后将其返回值
* 作为functionB<R1, R2>的apply方法的入参，执行
* functionB<R1, R2>的apply方法，返回一个泛型为
* <P1, R2>的functionC<P1, R2>。
*/
@Test
public void test2() {
Function<String, Integer> functionA = x -> {
Objects.requireNonNull(x, "参数不能为空");
x = x.replace(" ", "");
return x.length();
};
Function<Integer, Staff> functionB = x -> {
Objects.requireNonNull(x, "参数不能为空");
Staff s = new Staff();
s.setAge(x);
return s;
};
Function<String, Staff> functionC = functionB.compose(functionA);
Staff staff = functionC.apply(" 我 是 参 数 ！ ");
// 输出: Staff(name=null, age=5, staffNo=null)
System.out.println(staff);
}
-
Function<T, V> andThen(Function<? super R, ? extends V> after： 由两个旧的Function得到一个新的Function。
假设： 现有式子functionC = functionA.andThen(functionB),functionA泛型为<P1, R1>， functionB泛型为<R1, R2>。
那么， 上述式子的逻辑是：先运行functionA<P1, R1>的apply方法，然后将其返回值作为functionB<R1, R2>的apply方法的入参，执行functionB<R1, R2>的apply方法，返回一个泛型为<P1, R2>的functionC<P1, R2>。
注： functionA.andThen(functionB)是先执行functionA，再执行functionB；而functionA.compose(functionB)是先执行functionB，再执行functionA。
使用示例：
/**
* <V> Function<T, V> andThen(Function<? super R, ? extends V> after):由两个旧的Function得到一个新的Function。
*
* 假设：现有式子functionC = functionA.andThen(functionB),
* functionA泛型为<P1, R1>， functionB泛型为<R1, R2>。
*
* 那么，上述式子的逻辑是:先运行functionA<P1, R1>的apply方法，然后将其返回值
* 作为functionB<R1, R2>的apply方法的入参，执行
* functionB<R1, R2>的apply方法，返回一个泛型为
* <P1, R2>的functionC<P1, R2>。
*
* 注: functionA.andThen(functionB)是先执行functionA，再执行functionB；
* 而functionA.compose(functionB)是先执行functionB，再执行functionA。
*/
@Test
public void test3() {
Function<String, Integer> functionA = x -> {
Objects.requireNonNull(x, "参数不能为空");
x = x.replace(" ", "");
return x.length();
};
Function<Integer, Staff> functionB = x -> {
Objects.requireNonNull(x, "参数不能为空");
Staff s = new Staff();
s.setAge(x);
return s;
};
Function<String, Staff> functionC = functionA.andThen(functionB);
Staff staff = functionC.apply(" 我 是 参 数 ！ ");
// 输出: Staff(name=null, age=5, staffNo=null)
System.out.println(staff);
}
-
static Function<T, T> identity()： 将输入的参数进行返回，即: return t -> t。
注： 在某些情景下，使用Function.identity()，会让代码更优雅。
使用示例：
/**
* static <T> Function<T, T> identity(): 将输入的参数进行返回，即: return t -> t。
*
* 说明: 在某些情景下，使用Function.identity()，会让代码更优雅。
*/
@Test
public void test4() {
/*
* 使用普通的lambda表达式
*/
Map<Integer, String> mapOne = Stream.of("a", "ab", "abc", "abcd", "abcde").collect(
Collectors.toMap(String::length, param -> param)
);
// 输出: {1=a, 2=ab, 3=abc, 4=abcd, 5=abcde}
System.out.println(mapOne);
/*
* 使用Function.identity()无疑更优雅
*/
Map<Integer, String> mapTwo = Stream.of("a", "ab", "abc", "abcd", "abcde").collect(
Collectors.toMap(String::length, Function.identity())
);
// 输出: {1=a, 2=ab, 3=abc, 4=abcd, 5=abcde}
System.out.println(mapTwo);
}
-
R apply(T t, U u)： 输入T类型、U类型的参数，运行相关逻辑后，返回R类型的结果。
使用示例：
/**
* R apply(T t, U u): 输入T类型、U类型的参数，运行相关逻辑后，返回R类型的结果。
*/
@Test
public void test17() {
BiFunction<Integer, String, Staff> biFunction = (x, y) -> {
Staff s = new Staff();
s.setAge(x);
s.setName(y);
return s;
};
Staff staff = biFunction.apply(25, "单身邓");
// 输出: 单身邓, 25岁！
System.out.println(staff.getName() + ", " + staff.getAge() + "岁！");
}
-
BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after)： 由一个旧的BiFunction以及一个旧的Function得到一个新的BiFunction<T, U, V>。
假设： 现有式子biFunctionC = biFunctionA.andThen(functionB),biFunctionA泛型为<P1, T1, R1>， functionB泛型为<R1, R2>。
那么， 上述式子的逻辑是：先运行biFunctionA<P1, T1, R1>的apply方法，然后将其返回值作为functionB<R1, R2>的apply方法的入参，执行functionB<R1, R2>的apply方法，返回一个泛型为<P1, T1, R2>的biFunctionC<P1, T1, R2>。
使用示例：
/**
* <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after):
* 由一个旧的BiFunction以及一个旧的Function得到一个新的BiFunction<T, U, V>。
*
* 假设：现有式子biFunctionC = biFunctionA.andThen(functionB),
* biFunctionA泛型为<P1, T1, R1>， functionB泛型为<R1, R2>。
*
* 那么，上述式子的逻辑是:先运行biFunctionA<P1, T1, R1>的apply方法，然后将其返回值
* 作为functionB<R1, R2>的apply方法的入参，执行
* functionB<R1, R2>的apply方法，返回一个泛型为
* <P1, T1, R2>的biFunctionC<P1, T1, R2>。
*/
@Test
public void test18() {
BiFunction<Integer, String, Staff> biFunctionA = (x, y) -> {
Staff s = new Staff();
s.setAge(x);
s.setName(y);
return s;
};
Function<Staff, Map<String, Staff>> functionB = x -> {
Map<String, Staff> map = new HashMap<>(4);
map.put(x.getName(), x);
return map;
};
BiFunction<Integer, String, Map<String, Staff>> biFunctionC = biFunctionA.andThen(functionB);
Map<String, Staff> map = biFunctionC.apply(25, "单身邓");
// 输出: {单身邓=Staff(name=单身邓, age=25, staffNo=null)}
System.out.println(map);
}
