重学lambda表达式2

---

前言

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

一、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表达式和流的具体使用