lambda表达式常用篇

客官°小女子只卖身不卖艺 2023-05-30 04:53 15阅读 0赞

这里介绍一下lambda表达式，主要是平时写代码常用的，也许不全面，但是常用的我会很详细的介绍的，其原理大家有兴趣可以自己探索，我看中的是它的应用价值，废话不多说，直接进入主题。

lambda表达式形式其实比较简单的，如下，基本上都这样的，更加具体的，看如下代码

() -> statement
    () -> {statement}
    (param1,param2...) -> statement
    (param1,param2...) -> {statement}

定义一个基本的实体类：

package com.chenjianwen.test;
    
    /**
     * @Description: <br>
     * @Date: Created in 2019/9/23 <br>
     * @Author: chenjianwen
     */
    public class Userz {
    
        private String phone;
        private String name;
        private Integer age;
    
        public Userz(){}
    
        public Userz(String phone, String name, Integer age){
            this.phone = phone;
            this.name = name;
            this.age = age;
        }
    
        public String getPhone() {
            return phone;
        }
    
        public void setPhone(String phone) {
            this.phone = phone;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Userz{" +
                    "phone='" + phone + '\'' +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

# 一、匿名内部类 #

### 1）创建线程的时候，为了快捷方便，经常要使用到匿名内部类，如下这样: ###

@Test
        public void test01(){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello world");
                }
            }).start();
        }

这样已经很简洁了，但是使用lambda表达式还可以更加的简洁的，如下这样：

@Test
        public void test02(){
            new Thread(() -> System.out.println("hello java")).start();
        }

### 2）在使用比较器Comparator时也可以使用lambda表达式 ###

@Test
        public void test03(){
            List<Userz> userzList = new ArrayList<>();
            userzList.add(new Userz("13023344555", "chen1", 12));
            userzList.add(new Userz("13023344555", "chen2", 14));
            userzList.add(new Userz("13023344555", "chen3", 5));
            userzList.add(new Userz("13023344555", "chen4", 67));
    
            System.out.println("排序前");
            for(Userz u : userzList){
                System.out.println(u.toString());
            }
    
            System.out.println("排序后");
            Collections.sort(userzList, new Comparator<Userz>() {
                @Override
                public int compare(Userz o1, Userz o2) {
                    return o1.getAge() - o2.getAge();
                }
            });
            for(Userz u : userzList){
                System.out.println(u.toString());
            }
        }

其中，这里使用了比较器的：

![20191107135447537.png][]

这里的比较器换成lambda表达式的话，就简便多了，如下：

Collections.sort(userzList, (x,y) -> x.getAge()-y.getAge());

或者这样也可以：

userzList.sort((x,y) -> x.getAge()-y.getAge());

或者这样：

Collections.sort(userzList, Comparator.comparing(Userz::getAge));

# 二、集合操作 #

### 1）集合的遍历 ###

平时我们集合的遍历都使用过foreach方法，如下：

@Test
        public void test04(){
            List<String> list = Arrays.asList("a","b","c","hello","girl");
            for(String s : list){
                System.out.println(s);
            }
        }

现在有了lambda，就可以使用这种方式：

@Test
        public void test04(){
            List<String> list = Arrays.asList("a","b","c","hello","girl");
            list.forEach(y -> System.out.println(y));
        }

或者这样：

@Test
        public void test04(){
            List<String> list = Arrays.asList("a","b","c","hello","girl");
            list.forEach(System.out::println);
        }

### 2）filter()的使用 ###

假如上面的list集合我想筛选出长度大于3的字符串，那该怎么办：

如果不使用lambda表达式，需要foreach遍历在判断，如下：

@Test
        public void test06(){
            List<String> list = Arrays.asList("a","b","c","hello","girl");
            List<String> res = new ArrayList<>();
            for(String s : list){
                if(s.length() > 3){
                    res.add(s);
                }
            }
            res.forEach(System.out::println);
        }

如果使用lambda表达式，就这样：

@Test
        public void test07(){
            List<String> list = Arrays.asList("a","b","c","hello","girl");
            list.stream().filter(x -> x.length() > 3).collect(Collectors.toList()).forEach(System.out::println);
        }

是不是感觉简洁许多。

### 3）map()的使用 ###

有时候已知一个对象的集合，我们需要将这个对象中的某个变量重新放在一个集合中，例如上面的list<Userz>集合中我要获取其变量name的集合list<String>，需要foreach遍历集合，如下：

@Test
        public void test08(){
            List<Userz> userzList = new ArrayList<>();
            userzList.add(new Userz("13023344555", "chen1", 12));
            userzList.add(new Userz("13023344555", "chen2", 14));
            userzList.add(new Userz("13023344555", "chen3", 5));
            userzList.add(new Userz("13023344555", "chen4", 67));
            List<String> res = new ArrayList<>();
            for(Userz u : userzList){
                res.add(u.getName());
            }
    
            for(String s : res){
                System.out.println(s);
            }
        }

如果使用lambda表达式就简洁很多：

@Test
        public void test09(){
            List<Userz> userzList = new ArrayList<>();
            userzList.add(new Userz("13023344555", "chen1", 12));
            userzList.add(new Userz("13023344555", "chen2", 14));
            userzList.add(new Userz("13023344555", "chen3", 5));
            userzList.add(new Userz("13023344555", "chen4", 67));
            userzList.stream().map(t -> t.getName()).collect(Collectors.toList()).forEach(x -> System.out.println(x));
        }

![20191107152741877.png][]

只需上述一行代码即可，

也可以这么写：

userzList.stream().map(Userz::getName).collect(Collectors.toList()).forEach(System.out::println);

### 4）Predicate的使用 ###

有时候filter()需要多重筛选条件，例如如下字符串集合，我需要筛选出以c开头，且长度大于3的字符串；一共两重筛选条件，而且有可能n多重筛选条件，就需要用到Predicate：

@Test
        public void test10(){
            List<String> list = Arrays.asList("c", "go", "java", "hello world", "python", "come on", "cnmlgb");
            Predicate<String> p1 = (x) -> x.startsWith("c");
            Predicate<String> p2 = (y) -> y.length() > 3;
            list.stream().filter(p1.and(p2)).forEach(System.out::println);
            list.stream().filter(p1.or(p2)).forEach(System.out::println);
        }

其中，and()是将两个同时满足条件的查出来，or()将两者之一查出来。

### 5）reduce()的使用 ###

reduce()共有三个重载方法，如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JveV9jaGVuOTM_size_16_color_FFFFFF_t_70][]

第一个方法，假如说Stream中的元素为a\[0\],a\[1\],..,a\[n\]，用java代码表示为

![20191108144553483.png][]

T result = a[0];
            for(int i = 1;i < n;i++){
                result = accumulator.apply(result, a[i]);
            }
            return result;

他在四则运算，求最值，或字符串拼接等又很多运用，如下演示：

/**
         * 求和
         */
        @Test
        public void test12() {
            Stream<Integer> s = Stream.of(1, 2, 3, 4);
            Integer value = s.reduce(new BinaryOperator<Integer>() {
                @Override
                public Integer apply(Integer integer, Integer integer2) {
                    return integer + integer2;
                }
            }).get();
            System.out.println(value);
        }
        @Test
        public void test13() {
            Stream<Integer> s = Stream.of(1, 2, 3, 4);
            Integer value = s.reduce((x, y) -> x + y).get();
            System.out.println(value);
        }

/**
         * 求最大值
         */
        @Test
        public void test14() {
            Stream<Integer> s = Stream.of(1, 2, 3, 4);
            Integer value = s.reduce(new BinaryOperator<Integer>() {
                @Override
                public Integer apply(Integer integer, Integer integer2) {
                    return integer > integer2 ? integer : integer2;
                }
            }).get();
            System.out.println(value);
        }
        @Test
        public void test15() {
            Stream<Integer> s = Stream.of(1, 2, 3, 4);
            Integer value = s.reduce((x, y) -> x > y ? x : y).get();
            System.out.println(value);
        }

/**
         * 字符串拼接
         */
        @Test
        public void test18(){
            Stream<String> s = Stream.of("I", " " ,"am", " ", "the" , " ", "God");
            String value = s.reduce(new BinaryOperator<String>() {
                @Override
                public String apply(String s, String s2) {
                    return s.concat(s2);
                }
            }).get();
            System.out.println(value);
        }

第二个相当于第一个方法有个初始值，算是加强版，用java代码表示如下

![20191108144638879.png][]

T result = identity;
            for(int i = 0;i < n;i++){
                result = accumulator.apply(result, a[i]);
            }
            return result;

针对于上述的四则运算，最值和字符串拼接如下

/**
         * 求和
         */
        @Test
        public void test12() {
            Stream<Integer> s = Stream.of(1, 2, 3, 4);
            Integer value = s.reduce(5, new BinaryOperator<Integer>() {
                @Override
                public Integer apply(Integer integer, Integer integer2) {
                    return integer + integer2;
                }
            });
            System.out.println(value);
        }
        @Test
        public void test13() {
            Stream<Integer> s = Stream.of(1, 2, 3, 4);
            Integer value = s.reduce(5, (x, y) -> x + y);
            System.out.println(value);
        }
    
        /**
         * 求最大值
         */
        @Test
        public void test14() {
            Stream<Integer> s = Stream.of(1, 2, 3, 4);
            Integer value = s.reduce(5 ,new BinaryOperator<Integer>() {
                @Override
                public Integer apply(Integer integer, Integer integer2) {
                    return integer > integer2 ? integer : integer2;
                }
            });
            System.out.println(value);
        }
        @Test
        public void test15() {
            Stream<Integer> s = Stream.of(1, 2, 3, 4);
            Integer value = s.reduce(5, (x, y) -> x > y ? x : y);
            System.out.println(value);
        }
    
        /**
         * 字符串拼接
         */
        @Test
        public void test18(){
            Stream<String> s = Stream.of(" " ,"am", " ", "the" , " ", "God");
            String value = s.reduce("I", new BinaryOperator<String>() {
                @Override
                public String apply(String s, String s2) {
                    return s.concat(s2);
                }
            });
            System.out.println(value);
        }

第三个很复杂的

![20191108145401669.png][]

其方法里面又三个参数：

第一个参数：identity，泛型为U，与reduce方法的返回值一致，但是此时Stream中元素的泛型为T，换言之，两者类型不一致，这样的话，操作空间就非常大了，不管Stream中存储的是什么类型，U都可以是任意类型，包括基本类型的包装类，如Integer，Long等，或者是对象类String等，或者是集合ArrayList等。

第二个参数：accumulator，其类型是BiFunction，输入的是U和T两种类型的数据，而返回的是U类型。

第三个参数：combiner，类型是BinaryOperator，支持对U类型的对象进行操作。如果Stream是非并行的，此参数不生效；只有并行时才生效。

1、非并行时，combiner不生效，其java代码表述如下：

U result = identity;  
    for (T element：a) {
    	result = accumulator.apply(result, element);  
    }
    return result;

仔细观察，result类型是U，而Element类型是T。如果U与T一致，那么就与上述一个或两个参数的reduce方法一样了。正因为可以不一样，就存在多种用法，假设U的类型是ArrayList，那么可以将Stream中所有元素添加到ArrayList中，如下：

@Test
        public void test19(){
            Stream<String> s1 = Stream.of("b", "ab", "bbc" ,"ppg");
            s1.reduce(new ArrayList<String>(), new BiFunction<ArrayList<String>, String, ArrayList<String>>() {
                @Override
                public ArrayList<String> apply(ArrayList<String> strings, String s) {
                    strings.add(s);
                    return strings;
                }
            }, new BinaryOperator<ArrayList<String>>() {
                @Override
                public ArrayList<String> apply(ArrayList<String> strings, ArrayList<String> strings2) {
                    return strings;
                }
            }).forEach(System.out::println);
        }

其lambda表达式为：

@Test
        public void test21(){
            Stream<String> s1 = Stream.of("b", "ab", "bbc" ,"ppg");
            s1.reduce(new ArrayList<String>(), (x,y) -> {x.add(y);return x;}, (a,b) -> a).forEach(System.out::println);
        }

也可以使用Predicate对元素进行过滤：

@Test
        public void test20(){
            Stream<String> s1 = Stream.of("b", "ab", "bbc" ,"ppg");
            Predicate<String> predicate = t -> t.contains("b");
            s1.reduce(new ArrayList<String>(), new BiFunction<ArrayList<String>, String, ArrayList<String>>() {
                @Override
                public ArrayList<String> apply(ArrayList<String> strings, String s) {
                    if(predicate.test(s)){
                        strings.add(s);
                    }
                    return strings;
                }
            }, new BinaryOperator<ArrayList<String>>() {
                @Override
                public ArrayList<String> apply(ArrayList<String> strings, ArrayList<String> strings2) {
                    return strings;
                }
            }).forEach(System.out::println);
        }

其lambda表达式为：

@Test
        public void test22(){
            Stream<String> s1 = Stream.of("b", "ab", "bbc" ,"ppg");
            Predicate<String> predicate = t -> t.contains("b");
            s1.reduce(new ArrayList<String>(), (x,y) -> {if(predicate.test(y)) x.add(y);return x;}, (a,b) -> a).forEach(System.out::println);
        }

2、并行时，第三个参数就有意义了，它将不同线程计算的结果调用combiner做汇总后返回，由于采用了并行计算，与非并行时计算的结果也有了差异，例如，计算1+2+3+4的值，其中4为初始值：

@Test
        public void test23(){
            System.out.println(Stream.of(1,2,3).parallel().reduce(4, new BiFunction<Integer, Integer, Integer>() {
                @Override
                public Integer apply(Integer integer, Integer integer2) {
                    return integer + integer2;
                }
            }, new BinaryOperator<Integer>() {
                @Override
                public Integer apply(Integer integer, Integer integer2) {
                    return integer + integer2;
                }
            }));
        }
    
        /**
         * lambda表达
         */
        @Test
        public void test24(){
            System.out.println(Stream.of(1,2,3).parallel().reduce(4, (x,y) -> x+y, (a,b) -> a+b));
        }

计算结果应该是10的才对，然而实际结果时18，实际计算结果是这样的：

对于第一个BiFunction重写的apply()方法，线程一：4+1=5，线程2：4+2=6，线程3：4+3=7

然后对于第二个BinaryOperator重写方法apply()方法将上述结果相加：5+6+7=18。

换个测验，将BinaryOperator重写方法apply()方法换成相乘

@Test
        public void test23(){
            System.out.println(Stream.of(1,2,3).parallel().reduce(4, new BiFunction<Integer, Integer, Integer>() {
                @Override
                public Integer apply(Integer integer, Integer integer2) {
                    return integer + integer2;
                }
            }, new BinaryOperator<Integer>() {
                @Override
                public Integer apply(Integer integer, Integer integer2) {
                    return integer * integer2;
                }
            }));
        }
    
        /**
         * lambda表达
         */
        @Test
        public void test24(){
            System.out.println(Stream.of(1,2,3).parallel().reduce(4, (x,y) -> x+y, (a,b) -> a*b));
        }

其运算过程是：(4+1)\*(4+2)\*(4+3) = 210;

其效果与下列写法一致：

@Test
        public void test25(){
            System.out.println(Stream.of(1,2,3).map(x -> x+4).reduce((y,z) -> y*z).get());
        }

暂时这么多，以后想到再继续补充。。。

[20191107135447537.png]: https://img-blog.csdnimg.cn/20191107135447537.png
[20191107152741877.png]: https://img-blog.csdnimg.cn/20191107152741877.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JveV9jaGVuOTM_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191108143234762.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JveV9jaGVuOTM=,size_16,color_FFFFFF,t_70
[20191108144553483.png]: https://img-blog.csdnimg.cn/20191108144553483.png
[20191108144638879.png]: https://img-blog.csdnimg.cn/20191108144638879.png
[20191108145401669.png]: https://img-blog.csdnimg.cn/20191108145401669.png