java8 lambda表达式和函数型接口

时间:2022-05-30 19:00:13
  1 /**
  2  * @author gc
  3  * Lambda  表达式的基础语法:java8中引入一个新的操作符 "->" ,该操作符称为箭头操作符或lambda操作符
  4  *      箭头操作符将lambda拆分成两部分:
  5  *      左侧:lambda表达式的参数列表
  6  *      右侧:lambda表达式中所需执行的功能,即lambda体
  7  *  语法格式一:无参数,无返回值
  8  *      () -> System.out.println("xxxxxx");
  9  *  语法格式二:有一个参数,无返回值
 10  *      (x) -> System.out.println(xxxxxx);
 11  *  语法格式三:若只有一个参数,小括号可以省略不写
 12  *      x -> System.out.println(x);
 13  *  语法格式四:有两个以上的参数,有返回值,并且lambda体中有多条语句    test4
 14  *      Comparator<Integer> comparator = (x,y) -> {
 15  *            System.out.println("函数式接口");
 16  *            return Integer.compare(x, y);
 17  *        };
 18  *    语法格式五:若lambda体中只有一条语句,则return和大括号都可以省略不写
 19  *        Comparator<Integer> comparator = (x,y) -> Integer.compare(x, y);
 20  *    语法格式六:lambda表达式的参数列表的数据类型可以省略不写,因为jvm编译器可以根据上下文推断出数据类型,即“类型推断”
 21  *        (Integer x,Integer y) -> Integer.compare(x, y);  == (x,y) -> Integer.compare(x, y);
 22  *    
 23  *    左右遇一括号省(左边是一个参数或者右边只有一条语句), 左侧推断类型省(左边不需要显示指定类型)
 24  *
 25  *    二、lambda表达式需要函数式接口的支持
 26  *        函数式接口:接口中只有一个抽象方法的接口(这样才知道要动态替换哪个方法),可以使用 @FunctionalInterface 检查一下
 27  *        反而言之:jdk接口上有@FunctionalInterface注解的都是函数式接口
 28  */
 29 public class TestLambda {
 30     
 31     @Test
 32     public void test1() {
 33         new Thread(new Runnable() {
 34             @Override
 35             public void run() {
 36                 Runnable r1 = () -> System.out.println("hello lambda1");
 37             }
 38         }).start();
 39         
 40         //相当于实现接口Runable无参方法run的匿名实现类.这里的实现同上面的匿名类效果一样
 41         Runnable r1 = () -> System.out.println("hello lambda2");
 42         new Thread(r1).start();
 43     }
 44     @Test
 45     public void test2() {
 46         //这里因为是一个参数,所以左边的括号省略,右边是一个表达式,所以右边的大括号省略
 47         //Consumer是一个消费者型的函数式接口,其accept方法可以对接收到的数据进行处理。这里相当于实现其抽象方法accept
 48         Consumer<String> consumer = x -> System.out.println(x);
 49         consumer.accept("我很帅");
 50     }
 51     
 52     @Test
 53     public void test4() {
 54         //这里左边是两个参数,所以使用括号,右边是两条语句,使用大括号。这里是实现了Comparator接口的compare方法,用于collection排序操作
 55         Comparator<Integer> comparator = (x,y) -> {
 56             System.out.println("函数式接口");
 57             return Integer.compare(x, y);
 58         };
 59         //这里是简写,效果同上
 60         Comparator<Integer> comparator2 = (x,y) -> Integer.compare(x, y);
 61     }
 62     
 63     //通过这里的两个lambda实现,可以发现函数式接口的方法是动态改变的,而且不用继续接口,不用匿名类,实现起来方便快捷
 64     @Test
 65     public void test5() {
 66         //(x) -> (x + 1)是一个lambda表达式,功能是自增。
 67         //其相当于一个入参和返回值类型相同的函数,这里将其传给MyFun<Integer>,可以作为函数式接口MyFun内方法getValue的实现。
 68         //可以理解为MyFun内方法getValue的实现变成了整数值自增然后返回
 69         Integer result = operation(100, (x) -> (x + 1));
 70         //这里输出101
 71         System.out.println(result);
 72         //这里同理,只是getValue的实现变成了自减,所以输出结果为99
 73         System.out.println(operation(100, (x) -> (x - 1)));
 74     }
 75     public Integer operation(Integer num, MyFun<Integer> mf) {
 76         return mf.getValue(num);
 77     }
 78 
 79     List<User> users = Arrays.asList(
 80             new User("gc", 24, 7500),
 81             new User("gc", 25, 13000),
 82             new User("gc", 26, 20000));
 83     
 84     @Test
 85     public void test6() {
 86         //这里第二个参数是lambda表达式,其实现了函数表达式式Comparator的compare方法
 87         Collections.sort(users, (u1, u2) -> {
 88             return u1.getAge() - u2.getAge();
 89         });
 90         System.out.println(users);
 91     }
 92     @Test
 93     //对两个long型进行处理
 94     public void test7() {
 95         //参数3是lambda,用于实现函数式接口。相当于MyFun2的getValue(a,b)功能变成了a+b
 96         op(100L, 200L, (x,y) -> x + y);
 97     }
 98     public void op(Long t1, Long t2, MyFun2<Long, Long> mf2) {
 99         System.out.println(mf2.getValue(t1, t2));
100     }
101     @Test
102     public void test() {
103         //这里是stream配合lambda表达式一起使用。stream这里简单理解为遍历list
104         //(e) -> e.getSalary() >= 10000是函数式接口Predicate内方法test的实现,其功能是判断是否正确
105         //下面这里就是判断list中的元素的salary是否大于10000,大于的继续往下处理
106         //forEach就是遍历打印。这里总体的功能就是遍历list,打印salary大于10000的User
107         users.stream().
108             filter((e) -> e.getSalary() >= 10000).forEach(System.out::println);
109         users.stream().
110             map((e) -> e.getName()).forEach(System.out::println);
111     }
112 }

 

1 @FunctionalInterface
2 public interface MyFun<T> {
3     
4     public T getValue(T value);
5 }

 

1 @FunctionalInterface
2 public interface MyFun2<T, R> {
3     
4     public R getValue(T t1, T t2);
5 }

 

 1 public class User {
 2     private String name;
 3     private int age;
 4     private int salary;
 5     private Status status;
 6     
 7     @Override
 8     public String toString() {
 9         return "User [name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status + "]";
10     }
11 
12     public User(String name, int age, int salary) {
13         super();
14         this.name = name;
15         this.age = age;
16         this.salary = salary;
17     }
18 }    

 

 1 /**
 2  * @author gc、
 3  * java8 内置的四大核心函数式接口
 4  * 
 5  * Consumer<T>: 消费型接口,接收数据并处理
 6  *         void accept(T t);
 7  * Supplier<T>: 供给型接口,对外提供数据
 8  *         T get()
 9  * Function<T, R>: 函数型接口,接收参数,返回结果
10  *         R apply(T t);
11  * Predicate<T>: 断言型接口,检测入参是否符合条件(符合则返回true)
12  *         boolean test(T t);
13  *
14  */
15 public class TestLambdaFunc {
16 
17     @Test
18     //Consumer<T> 消费型接口
19     public void testConsumer() {
20         //Consumer是消费型接口,其可定义对接收到的数据进行不同的处理。这里的处理方式就是打印详细信息。
21         //m -> System.out.println("大保健,消费:"+m+" 元") 可以理解为Consumer中accept(T t)方法的实现
22         happy(10000L, m -> System.out.println("大保健,消费:"+m+" 元"));
23     }
24     public void happy(double money, Consumer<Double> con) {
25         con.accept(money);
26     }
27     
28     //Supplier<T> 供给型接口
29     @Test
30     public void testSupplier() {
31         //Supplier是供给型接口。其内部定义对外输出的数据。而且不需要入参
32         //() -> (int)(Math.random() * 100) 为这里的供给行为,即返回一个随机数
33         List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
34         System.out.println(numList);
35     }
36     
37     public List<Integer> getNumList(int num, Supplier<Integer> sup) {
38         List<Integer> list = new ArrayList<>();
39         
40         for (int i = 0; i < num; i++) {
41             Integer n = sup.get();
42             list.add(n);
43         }
44         return list;
45     }
46     
47     //Function<T,R> 函数型接口
48     @Test
49     public void testFunction() {
50         //函数型接口功能相对强大,可以对接收到的数据进行进一步处理,返回类型可以和入参类型不一致(泛型接口,二元组)
51         //(x) -> (x + ", 哈哈哈") 这里作为Function接口中apply的实现
52         String str = strHandler("我最帅", (x) -> (x + ", 哈哈哈"));
53         System.out.println(str);
54     }
55     private String strHandler(String str, Function<String, String> fun) {
56         return fun.apply(str);
57     }
58     
59     //Predicate<T> 断言型接口
60     @Test
61     public void testPredicate() {
62         List<String> list = Arrays.asList("Hello", "World", "www.exact.com");
63         //函数式接口Predicate主要用于判断,x -> (x.length() > 5) 这里是判断入参的长度是否大于5
64         List<String> filterStr = filterStr(list, x -> (x.length() > 5));
65         System.out.println(filterStr);
66     }
67     
68     public List<String> filterStr(List<String> list, Predicate<String> pre) {
69         List<String> strList = new ArrayList<>();
70         
71         for (String str : list) {
72             if(pre.test(str)) {
73                 strList.add(str);
74             }
75         }
76         return strList;
77     }
78 }

 

 1 /**
 2  * @author gc
 3  * 方法引用:若lambda体中的内容有方法已经实现了,我们可以使用“方法引用”
 4  *         (可以理解为方法引用是lambda表达式的另外一种表达形式)
 5  * 主要有三种语法格式:
 6  *         对象::实例方法名
 7  *         类::静态方法名
 8  *         类::实例方法名
 9  * 注意:
10  *     1.lambda体中调用方法的参数列表与返回值类型,要与函数式接口中抽象方法的参数列表和返回值类型一致
11  *  2.若lambda参数列表 中的第一个参数是实例方法的调用者,而第二个参数是实例方法的参数时,可以使用className::method
12  *  
13  *  二、构造器引用
14  *  格式:
15  *      ClassName::new
16  */
17 public class TestMethodRef {
18 
19     
20     //对象::实例方法名
21     @Test
22     public void test() {
23         Consumer<String> consuemr = (x) -> System.out.println(x);
24         consuemr.accept("aaaa");
25         
26         PrintStream ps = System.out;
27         Consumer<String> consumer2 = ps::println;
28         consumer2.accept("asdf");
29     }
30     
31     @Test
32     public void test2() {
33         User user= new User("gc",20,200000);
34         //这里是无参,所以左边使用了()
35         Supplier<String> sup = () -> user.getName();
36         System.out.println(sup.get());
37         
38         //这里对lambda表达式进行了省略。() -> user.getAge() == user::getAge
39         Supplier<Integer> sup2 = user::getAge;
40         System.out.println(sup2.get());
41     }
42     
43     //类::静态方法名
44     public void test3() {
45         Comparator<Integer> com = (x,y) -> Integer.compare(x, y);
46         
47         //这里因为入参和lambda实现方法要调用的入参一样。所以两边都省略了
48         Comparator<Integer> com1 = Integer::compare;
49     }
50     
51     //类::实例方法名
52     public void test4() {
53         BiPredicate<String, String> bp = (x,y) -> x.equals(y);
54         
55         //这里是两个入参,而且满足第一个参数是新方法调用者,第二个参数是入参的情况
56         //理论而言都用上面的表达式即可,看起来比较简单,但是不能避免别人不会使用简写方式,看不懂岂不是很尴尬
57         BiPredicate<String, String> bp2 = String::equals;
58     }
59     
60     @Test
61     public void test5() {
62         //函数式接口生产数据的方式是new User();
63         Supplier<User> sup = () -> new User();
64         //这里功能同上,简写方式
65         Supplier<User> sup2 = User::new;
66         System.out.println(sup2.get());
67     }
68 }

 

相关文章