重学lambda表达式2

傷城~ 2023-10-02 11:51 34阅读 0赞

#### 文章目录 ####

*  前言
 *  一、Stream（）是什么？
 *  二、什么是Stream()
 *  三、stream操作的三大步骤
 *   *  1.创建stream
     *  2.中间操作
     *  3.终止操作
 *  四、stream的使用
 *   *  1. 筛选及切片
     *  2.映射：map(),将其装换成其他参数进行提取和收集
     *  3排序：将流中的元素进行排序
     *  4.终止流操作
     *  5. 终止流操作max，min，count等
     *  6. 规约.
     *  7.将流转换成其他形式
     *  8.流的其它操作
 *  总结

--------------------

## 前言 ##

提示：以下是本篇文章正文内容，下面案例可供参考

## 一、Stream（）是什么？ ##

示例：stream()是java8以后引入的新特性，真正的将函数式编程引入java，能更快更方便的操作对象，stream()是处理集合的关键抽象概念

## 二、什么是Stream() ##

1. Stream是数据渠道，用于操作数据源所产生的元素序列，集合讲的是数据而Stream将的操作

2. 注意点：stream自身不存储元素，不会改变源对象，操作是延迟的，也就是说需要的时候才会执行stream

## 三、stream操作的三大步骤 ##

### 1.创建stream ###

主要是顺序流和并行流，类似多线程，

### 2.中间操作 ###

过滤filter，截断limit，跳过skip，筛选distinct

### 3.终止操作 ###

终止操作，主要是排序sorted，包括自然排序和定制排序等，count，max，min  
等等

## 四、stream的使用 ##

代码如下（示例）：  
自定义一个pojo,

public class Employee {
        
    
        private  Integer id;
        private  String name;
        private  Integer age;
        }

提供set和get方法，无参构造器和全参构造器，这里不再赘述

提供数据，为了简便，这里直接new，

public class EmployeeDate {
        
    
        public  static List<Employee> getEmployees(){
        
            ArrayList<Employee> employees = new ArrayList<>();
    
            employees.add(new Employee(1,"马化腾1",31));
            employees.add(new Employee(2,"马化腾2",32));
            employees.add(new Employee(3,"马化腾3",38));
            employees.add(new Employee(4,"马化腾4",34));
            employees.add(new Employee(5,"马化腾",35));
            employees.add(new Employee(6,"马化腾244",35));
            employees.add(new Employee(7,"马化1",50));
            employees.add(new Employee(8,"马化2",41));
            employees.add(new Employee(9,"马化3",35));
    
    
            return employees;
        }
    
    }

我们来看看具体的操作：

### 1. 筛选及切片 ###

年龄大于40岁的员工有哪些？

@Test
        public  void test1(){
        
            List<Employee> employees = EmployeeDate.getEmployees();
    
    
            Stream<Employee> stream = employees.stream();
    //        stream.filter(e -> e.getAge()>32).forEach(System.out::println);
    
            stream.filter(employee -> employee.getAge()>40).forEach(employee -> System.out.println(employee) );
    
            System.out.println("---------------------------------");
    
            Stream<Employee> stream2 = employees.stream();
            stream2.limit(3).forEach(employee -> System.out.println(employee));
    
            System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxx");
    
    
            //跳过前面的三个
            employees.stream().skip(2).forEach(employee -> System.out.println(employee));
    
            //去重
            employees.stream().distinct().forEach(employee -> System.out.println(employee));
    
            System.out.println("ccccccccccccccccccccccccccccccccccccc");
        }

### 2.映射：map(),将其装换成其他参数进行提取和收集 ###

@Test
        public void test2(){
        
            List<Employee> employees = EmployeeDate.getEmployees();
    
    
            //小写装换成大写
            List<String> list = Arrays.asList("aa", "nn", "cc", "dd");
            list.stream().map(s -> s.toUpperCase(Locale.ROOT)).forEach(s -> System.out.println(s));
    
    
            System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxx");
    
    
            //获取员工姓名大于4的员工
            Stream<String> nameStream = employees.stream().map(employee -> employee.getName());
            nameStream.filter(s ->s.length()>4).forEach(s -> System.out.println(s));
    
            System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxx");
    
        }

### 3排序：将流中的元素进行排序 ###

//排序
        @Test
        public  void  test4(){
        
    
            List<Integer> list = Arrays.asList(12, 15, 8, 32);
    //        list.stream().sorted().forEach(l-> System.out.println(l));
            list.stream().sorted().forEach(System.out::println);
    
            /*类型转换异常，要实现cpmparable接口*/
           List<Employee> employees = EmployeeDate.getEmployees();
    //        employees.stream().sorted().forEach(employee -> System.out.println(employee));
    //        EmployeeDate.getEmployees().stream().forEach(employee -> System.out.println(employee));
    
            //按照年龄进行排序
           // employees.stream().sorted((e1,e2)->Integer.compare(e1.getAge(), e2.getAge())).forEach(System.out::println);
            Stream<Integer> sorted = employees.stream().map(Employee::getAge).sorted();
            System.out.println(sorted);
    
    
        }

### 4.终止流操作 ###

* */
        @Test
        public  void test5(){
        
    
    /*
    * 匹配与查找
    * allMatch(predicate p)  检查匹配所有元素
    * anyMatch(predicate p)
    * noneMatch(predicate p)
    * findFirst
    * count
    * max(Comparable c)
    * min(Comparable c)
    * forEach
    * */
    
            List<Employee> employees1 = EmployeeDate.getEmployees();
            //检查员工所有年龄是否大于18
            boolean b = employees1.stream().anyMatch(employee -> employee.getAge() > 40);
    
    //        boolean emp1 = employees.stream().allMatch(employee -> employee.getAge() > 60);
              System.out.println(b);
           System.out.println("xxxxxxxxxxxxxxxxx");
    
    
            //是否存在年龄大于40，有一个成立就行
    //
    //        boolean b1 = this.employees.stream().anyMatch(employee -> employee.getAge() > 20);
    //        System.out.println(b1);
    //        System.out.println("xxxxxxxxxxxxxxxxxxxx");
    
    
        }

@Test
        public void test6(){
        
            //是否存在员工年龄是30岁
    
            List<Employee> employees = EmployeeDate.getEmployees();
    
    //        employees.stream().forEach(employee -> System.out.println(employee));
    
    
    //        boolean b = employees.stream().noneMatch(employee -> employee.getName().contains("马化3"));
    //       System.out.println(b);
    
    
           //查找第一个元素 findFirst()
    
    //        Optional<Employee> first = employees.stream().findFirst();
    //        System.out.println(first);
    
    
            //findAny 找任意一个
    
            Optional<Employee> any = employees.stream().findAny();
            System.out.println(any);
    
    
        }

### 5. 终止流操作max，min，count等 ###

@Test
        public void test1(){
        
    
            //count  当前流中的个数
            List<Employee> employees = EmployeeDate.getEmployees();
    
            long count = employees.stream().count();
            System.out.println(count);
    
    
        }
    
        @Test
        public  void test2(){
        
    
            //max
            List<Employee> employees = EmployeeDate.getEmployees();
            Stream<Integer> stream = employees.stream().map(employee -> employee.getAge());
    //        Optional<Integer> max = stream.max((e1, e2) -> Integer.compare(e1, e2));
            Optional<Integer> max1 = stream.max(Integer::compare);   //方法引用
            System.out.println(max1);
    
        }
    
        @Test
        public void test3(){
        
    
            //forEach  流内部遍历
    
            EmployeeDate.getEmployees().forEach(employee -> System.out.println(employee));
        }
    }

### 6. 规约. ###

@Test
        public  void  test1(){
        
    
            //规约  reduce  以下三种写法都是正确
            List<Employee> employees = EmployeeDate.getEmployees();
    //        Integer reduce = employees.stream().map(employee -> employee.getAge()).reduce(0, Integer::sum);
    
            Integer reduce1 = employees.stream().map(Employee::getAge).reduce(0, Integer::sum);
    
    //        Integer reduce1 = employees.stream().map(employee -> employee.getAge()).reduce(0, (a, b) -> a + b);
    
    
            System.out.println(reduce1);
        }
    }

### 7.将流转换成其他形式 ###

@Test
        public void test1(){
        
            List<Employee> employees = EmployeeDate.getEmployees();
            List<Employee> collect = employees.stream().filter(employee -> employee.getAge() > 33).collect(Collectors.toList());
    
            collect.forEach(employee -> System.out.println(employee));
    
    
        }

@Test
        public void  test2(){
        
    
            List<Employee> employees = EmployeeDate.getEmployees();
            Set<Employee> collect = employees.stream().filter(employee
                    -> employee.getAge() > 40).collect(Collectors.toSet());
    
            collect.stream().sorted((e1,e2)-> Integer.compare(e1.getAge(),e2.getAge())).forEach(System.out::println);
    
        }

@Test
        public  void  test3(){
        
            ArrayList<Integer> integers = new ArrayList<>();
            ArrayList<Integer> integers1 = new ArrayList<>();
            integers.add(1);
            integers.add(2);
            integers.add(3);
    //        System.out.println(integers);
            System.out.println("xxxxxxxxxxxxxxxxxx");
    
            ArrayList<Integer> collect = integers.stream().collect(Collectors.toCollection(ArrayList::new));
    //        ArrayList<Integer> collect = integers.stream().collect(Collectors.toCollection());
            TreeSet<Integer> collect1 = integers.stream().collect(Collectors.toCollection(TreeSet::new));
    //        System.out.println(collect1);
    
    
    //        collect.stream().forEach(System.out::println);
    
            //计算流中的个数
    
            Long collect2 = integers.stream().collect(Collectors.counting());
            System.out.println(collect2);
    
    
    
        }
        @Test
        public void  test4(){
        
    
            //流中元素的个数
            List<Employee> employees = EmployeeDate.getEmployees();
            Long collect = employees.stream().collect(Collectors.counting());
            System.out.println(collect);
            System.out.println("xxxxxxxxxxxxxxxxx");
    
            //流中的元素求和
           Integer collect1 = employees.stream().collect(Collectors.summingInt(e1 -> e1.getAge()));
    //        Integer collect1 = employees.stream().collect(Collectors.summingInt(Employee::getAge));
            System.out.println(collect1);
            System.out.println("xxxxxxxxxxxxxxx");
    
    
            //流中某个元素求平均值
            Double collect2 = employees.stream().collect(Collectors.averagingDouble(Employee::getAge));
            System.out.println(collect2);
            System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
    
            //流中元素的统计值  包含个数，最大值，最小值，平均值，和
            IntSummaryStatistics collect3 = employees.stream().collect(Collectors.summarizingInt(Employee::getAge));
            System.out.println(collect3);
    
    
            //根据属性对流进行分组
            Map<Integer, List<Employee>> collect4 = employees.stream().collect(Collectors.groupingBy(Employee::getAge));
            System.out.println(collect4);
    
            //{32=[Employee{id=2, name='马化腾2', age=32}], 50=[Employee{id=7, name='马化1', age=50}],
            // 34=[Employee{id=4, name='马化腾4', age=34}],
            // 35=[Employee{id=5, name='马化腾', age=35}, Employee{id=6, name='马化腾244', age=35}, Employee{id=9, name='马化3', age=35}],
            // 38=[Employee{id=3, name='马化腾3', age=38}],
            // 41=[Employee{id=8, name='马化2', age=41}],
            // 31=[Employee{id=1, name='马化腾1', age=31}]}
    
            //根据true or false 进行分组
    
    
             //employees.stream().collect(Collectors.partitioningBy(Employee::getAge))
        }

### 8.流的其它操作 ###

//连接流中的字符串
            List<Employee> employees = EmployeeDate.getEmployees();
            String collect = employees.stream().map(Employee::getName).collect(Collectors.joining());
            System.out.println(collect);
    
            //马化腾1马化腾2马化腾3马化腾4马化腾马化腾244马化1马化2马化3
    
    
            //根据比较器选择较大值
    
            Optional<Employee> collect1 = employees.stream().collect(Collectors.maxBy(Comparator.comparingInt(Employee::getAge)));
            System.out.println(collect1);
    
    
            ///Optional[Employee{id=7, name='马化1', age=50}]
    
            Stream<Integer> integerStream = employees.stream().map(employee -> employee.getAge());
            Optional<Integer> max = integerStream.max(Integer::compare);
            System.out.println(max);
            //Optional[50]
    
    
            Integer collect2 = employees.stream().collect(Collectors.reducing(0, Employee::getAge, Integer::sum));
            System.out.println(collect2);
    
            //331

--------------------

## 总结 ##

提示：这里对文章进行总结：  
例如：以上就是今天要讲的内容，本文仅仅简单介绍了stream的使用，具体使用还要在实际代码中体现，下一篇将具体理解lambda表达式和流的具体使用