翻开optional 类,发现都是函数式接口,所以函数式接口Function你必须了解;
代码
@Test
public void test2() {
/* @FunctionalInterface
public interface Function<T, R> {
// 输入T,返回 R ,这里T和R 谁是输入谁是输出,这样理解记忆只有先输入才有输出,
//所以第一是输入类型,第二个是输出类型
R apply(T t);
//compose 组合,源码 before先执行apply,然后将得到的值,代入当前表达式
default <V> java.util.function.Function<V, R> compose(java.util.function.Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
//andThen 跟javaScirpt命名一样,先执行当前表达式,然后将得到的值代入第二个表达式
default <V> java.util.function.Function<T, V> andThen(java.util.function.Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
//其实就是将本身返回
static <T> java.util.function.Function<T, T> identity() {
return t -> t;
}
}
*/
System.out.println("-------------Function-------------");
Function<Integer,Integer> count=i->i+2;
Function<Integer,Integer> count2=i->i*2;
System.out.println(count.apply(5)); //7
//count2.compose(count) 等同于 count3
Function<Integer,Integer> count3=i->(i+2)*2;
System.out.println(count2.compose(count).apply(5)); // (5+2)*2 =14
List<String> languages = Arrays.asList("C++", "java", "python");
Map<String, Integer> map = languages.stream().collect(Collectors.toMap(key -> key, String::length));
System.out.println(map); //{python=6, C++=3, java=4}
Map<String, Integer> map2 = languages.stream().collect(Collectors.toMap(Function.identity(), String::length));
System.out.println(map2);{python=6, C++=3, java=4}
/* @FunctionalInterface
public interface Predicate<T> {
//将t 代入lamda布尔表达式,返回一个boolean值
boolean test(T t);
//输入一个Predicate,返回一个Predicate,并且有短路功能,当前先执行,然后other再执行
default java.util.function.Predicate<T> and(java.util.function.Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
//取非
default java.util.function.Predicate<T> negate() {
return (t) -> !test(t);
}
//逻辑或
default java.util.function.Predicate<T> or(java.util.function.Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> java.util.function.Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}*/
//
System.out.println("--------------Pridicate------------");
Predicate<String> p1=x->x.equals("123");
System.out.println(p1.test("123"));
Predicate<String> p2=x->x.contains("12");
System.out.println(p1.and(p2).test("1234"));
System.out.println(p1.or(p2).test("1234"));
System.out.println(p1.negate().test("1234"));
/* @FunctionalInterface
public interface Consumer<T> {
//消费者,顾名思义,接收一个参数做业务操作,不产生返回值
void accept(T t);
//顺序执行 lamda表达式,先执行当前表达式,再执行after表达式
default java.util.function.Consumer<T> andThen(java.util.function.Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}*/
System.out.println("------------Consumer--------------");
Consumer<String> consumer1=x-> System.out.println(x+"dsjklfjklsad");
Consumer<String> consumer2=x-> System.out.println(x.toUpperCase());
consumer1.accept("1232"); //1232dsjklfjklsad
consumer2.accept("abc"); //ABC
consumer2.andThen(consumer1).accept("999abc"); //
//结果
//1232dsjklfjklsad
//ABC
//999ABC
//999abcdsjklfjklsad
/* @FunctionalInterface
public interface Supplier<T> {
//生产者,不接受参数,生厂一个对象
T get();
}*/
System.out.println("------------Supplier--------------");
Supplier<String> supplier=()->"123";
System.out.println(supplier.get()); //123
}