java的lambda表达式、方法引用、构造器引用

代码：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174

package com.jay.ct;   import java.util.ArrayList; import java.util.Arrays; import java.util.Comparator; import java.util.Iterator; import java.util.List; import java.util.function.BiConsumer; import java.util.function.BiFunction; import java.util.function.BiPredicate; import java.util.function.BinaryOperator; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; import java.util.function.ToDoubleFunction; import java.util.function.ToIntFunction; import java.util.function.ToLongFunction; import java.util.function.UnaryOperator;   import org.junit.jupiter.api.Test;   public class LambdaTest {     public static void main(String[] args) throws Exception {           // lambda表达式的本质：作为函数式接口的实例         // 如果一个接口中只声明了一个抽象方法，则此接口为函数式接口 @FunctionInterface         // 四大核心函数式接口         // 消费型：void Consumer<T> 包含方法：accept(t)         // 供给型：T Supplier<T> 包含方法：get()         // 函数型：R Function<T,R> 包含方法：apply(t)         // 断定型：boolean Predicate<T> 包含方法：test(t)         // 其他：BiFunction<T,U,R>,UnaryOperator<T>,BinaryOperator<T>,         // BiConsumer<T, U>,BiPredicate<T, U>,         // ToIntFunction<T>,ToDoubleFunction<T>,ToLongFunction<T>         // IntFunction<R>,DoubleFunction<R>,LongFunction<R>           // 方法引用：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用         // 方法引用可以看做是Lambda表达式深层次的表达，可以认为是Lambda表达式的一个语法糖。         // 方法引用要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致         // 主要使用方式：对象::实例方法名 类::静态方法名 类::实例方法名           // 1.无参，无返回值         Runnable r1 = new Runnable() {             @Override             public void run() {                 System.out.println("a");             }         };         r1.run();           Runnable r2 = () -> System.out.println("b");         r2.run();           // 2.需要一个参数，无返回值         Consumer<String> consumer1 = new Consumer<>() {             @Override             public void accept(String t) {                 System.out.println(t);             }         };         consumer1.accept("c");           Consumer<String> consumer2 = (t) -> System.out.println(t);         consumer2.accept("d");           // 3.需要多个参数，有返回值         Comparator<Integer> comp1 = new Comparator<Integer>() {             @Override             public int compare(Integer o1, Integer o2) {                 return o1.compareTo(o2);             }         };         int res1 = comp1.compare(1, 2);         System.out.println("compare1:" + res1);           Comparator<Integer> comp2 = (o1, o2) -> o1.compareTo(o2);         var res2 = comp2.compare(50, 20);         System.out.println("compare2:" + res2);           // 4.boolean Predicate<T> test(t)         List<String> listCity = Arrays.asList("北京", "上海", "南京");         List<String> list1 = filterStrings(listCity, (t) -> t.contains("京")); //      list1.forEach((t) -> System.out.println(t));         list1.forEach(System.out::println);// 方法引用           // 5.方法引用，getJuice的参数和返回值，正好匹配Function<String, String>         Function<String, String> func1 = new Function<String, String>() {             @Override             public String apply(String t) {                 return t + "被榨成了汁";             }         };         String resJuice1 = func1.apply("西瓜");         System.out.println(resJuice1);           Function<String, String> func2 = (t) -> t + "被榨成了汁";         String resJuice2 = func2.apply("黄瓜");         System.out.println(resJuice2);           // 方法引用 类::静态方法         Function<String, String> func3 = LambdaTest::getJuice;         // apply传参给getJuice,得到返回值         String resJuice3 = func3.apply("苹果");         System.out.println(resJuice3);     }       @Test     public void test1() {         // 构造器引用         Supplier<LambdaTest> lt = LambdaTest::new;         // 对象::非静态方法         Function<String, String> func1 = lt.get()::getJuice2;         // apply传参给getJuice,得到返回值         String resJuice1 = func1.apply("苹果");         System.out.println(resJuice1);           // 类::非静态方法，符合 h1.beFriend(a1) 或者 h1.getName() 这样的。         Boy h1 = new Boy("jay");         Gril a1 = new Gril("luna");         BiFunction<Boy, Gril, String> func3 = Boy::beFriend;         String res3 = func3.apply(h1, a1);         System.out.println(res3);           Boy h2 = new Boy("jay");         Function<Boy, String> func4 = Boy::getName;         String res4 = func4.apply(h2);         System.out.println(res4);     }       public static List<String> filterStrings(List<String> list, Predicate<String> pre) {         ArrayList<String> filterList = new ArrayList();         for (var s : list) {             if (pre.test(s)) {                 filterList.add(s);             }         }         return filterList;     }       public static String getJuice(String fruitName) {         return fruitName + "被榨成了汁";     }       public String getJuice2(String fruitName) {         return fruitName + "被榨成了汁";     } }   class Boy {     public Boy(String name) {         super();         this.name = name;     }       public String name;       public String beFriend(Gril p) {         return this.name + "和" + p.name + "成为了好朋友";     }       public String getName() {         return this.name;     } }   class Gril {     public Gril(String name) {         super();         this.name = name;     }       public String name; }