java8中list流--stream

在日常的开发工作中经常需要用到list的相关操作，例如遍历，排序，筛选，替换等操作，今日也学习并认识到了list流的一些基础操作，在这里总结一下常用的操作。

Stream

首先来认识一下stream
在java8中stream提供了很多Api，通过这些Api以及Lamda表达式可以进行许多高效并且遍历的操作

创建stream流

创建流有四种方式，具体使用如下：

	 @Test
    /**
     * 通过Collection集合创建流
     */
    public void create1(){
        Stream<Person> stream = personList.stream();//创建顺序流
        Stream<Person> personStream = personList.parallelStream();//创建并行流
    }

    @Test
    /**
     * 通过数组创建流
     */
    public void create2(){
        Stream<Person> stream = Arrays.stream(personArr);
    }

    @Test
    /**
     * 通过stream中的of()方法创建流
     */
    public void create3(){
        Stream<Person> stream = Stream.of(new Person("emp1", "1"), new Person("emp2", "2"));
    }

    @Test
    /**
     * 无限流创建，流中的元素无限多
     * 1.iterate():该方法需要传入一个初始值
     * 2.generate()：该方法不需要初始值
     */
    public void create4(){
        Stream.iterate(0,n -> n+1);//生成初始值为0，后续元素依次加一的流
        Stream.generate(Math::random);//生成一个随机元素的流
    }

中间操作

筛选操作

	@Test
    /**
     *筛选操作  filter(Predicate p)
     * 需要传入一个接口，接口的返回值为boolean类型
     */
    public void operate1(){
        //通过filter()方法筛选列表中性别为“1”的数据
        Stream<Person> stream = personList.stream().filter(e -> e.getSex().equals("1"));
    }

    @Test
    /**
     * 截断操作 limit(long maxSize)
     * 需要传入一个值，截断流，使其元素不会超过给定的数量
     */
    public void operate2(){
        //筛选第一个元素
        Stream<Person> stream = personList.stream().limit(1);
    }

    @Test
    /**
     * 跳过元素 skip(long n)
     * 跳过元素，返回一个扔掉了前 n 个元素的流
     * 当列表中的元素不足 n 个的时候，则返回一个空流
     */
    public void operate3(){
        Stream<Person> stream = personList.stream().skip(1);
    }

    @Test
    /**
     * 去重筛选 distinct()
     * 通过流中元素的hashcode()和equals()方法进行去重
     */
    public void operate4(){
        Stream<Person> stream = personList.stream().distinct();
    }

映射操作

  	@Test
    /**
     * 映射操作 map(function f)
     * 接收一个函数作为参数，将元素转换为其他形式或是提取信息
     * 该函数会应用到每一个元素上，并将其映射成一个新的元素
     */
    public void operate5(){
        //筛选列表中姓名包含“2”的元素并得到他们的姓名
        //先筛选，筛选后提取姓名得到新的String类型的流
        Stream<String> stream = personList.stream()
                .filter(e -> e.getName().contains("2"))
                .map(Person::getName);
    }

排序操作

	@Test
    /**
     * 排序操作 sorted()  sorted(Comparator com)
     * 第一种是自然排序方式
     * 第二种是需要制定排序的方式
     */
    public void operate6(){
        //首先演示一个普通的整形列表的自然排序
        List<Integer> intList = Arrays.asList(1, 2, 5, 4, 3);
        intList.stream().sorted().forEach(System.out::println);
        //输出结果为由小到大排序   1,2,3,4,5

        //接下来演示一个针对自定义类列表的指定排序
        List<Employee> employees = Arrays.asList(new Employee("员工一", 35, 5000.31),
                new Employee("员工二", 30, 8000.31),
                new Employee("员工三", 30, 5000.00));
        //对员工列表进行排序，排序规则：根据年龄由小到大排序，再根据工资由小到大排序
        employees.stream().sorted((e1,e2) ->{
                    int ageCompare = Integer.compare(e1.getAge(),e2.getAge());
                    if(ageCompare != 0){
                        return ageCompare;
                    }else{
                        return Double.compare(e1.getSalary(),e2.getSalary());
                    }
                }).forEach(System.out::println);
        //查询结果：
        //Employee{name='员工三', age=30, salary=5000.0}
        //Employee{name='员工二', age=30, salary=8000.31}
        //Employee{name='员工一', age=35, salary=5000.31}
    }

终止操作

为什么需要终止操作呢？
因为stream是惰性的，我们前面所用到的中间操作实际上是没有进行的，只有我们进行了终止操作也就是意味着我们需要最终结果的时候，才会去执行相关的中间操作，因此，我们通过stream流操作数据时，终止操作时必不可少的。

匹配、查找

	@Test
    /**
     * allMatch(Predicate p)
     * 检查是否匹配所有元素
     */
    public void end1(){
        //如果所有员工的年龄都大于30则返回true，否则返回false
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 30);
    }

    @Test
    /**
     * anyMatch(Predicate p)
     * 检查是否至少匹配一个元素
     */
    public void end2(){
        //如果有一个员工的年龄为30岁则返回true,否则返回false
        boolean anyMatch = employees.stream().anyMatch(e -> e.getAge() == 30);
    }

    @Test
    /**
     * noneMatch(Predicate p)
     * 检查是否没有匹配的元素
     */
    public void end3(){
        //如果没有员工的年龄小于18岁则返回true，否则返回false
        boolean noneMatch = employees.stream().noneMatch(e -> e.getAge() < 18);
    }

    @Test
    /**
     * findFirst --- 返回第一个元素
     * findAny --- 返回当前流中的任意一个元素
     */
    public void end4(){
        Optional<Employee> first = employees.stream().findFirst();
        Optional<Employee> any = employees.stream().findAny();
    }

    @Test
    /**
     * count() --- 返回流中元素的数量
     * max(Comparator c) --- 返回流中的最大值
     * min(Comparator c) --- 返回流中的最小值
     */
    public void end5(){
        //返回流中元素的数量
        long count = employees.stream().count();
        //返回年龄最大的员工
        Optional<Employee> max = employees.stream()
                .max((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));

        //返回年龄最小的员工
        Optional<Employee> min = employees.stream()
                .min((e1,e2) -> Integer.compare(e1.getAge(),e2.getAge()));
    }

    @Test
    /**
     * foreach(Consumer c)内部迭代操作
     */
    public void end6(){
        employees.stream().forEach(System.out :: println);
    }

规约

 	@Test
    /**
     * 规约：可以将流中元素反复结合，得到一个值
     * reduce(T identity,BinaryOperator)
     * 需要传入一个初始值和计算方式
     * reduce(BinaryOperator)
     * 需要传入计算方式
     */
    public void reduce1(){
        //计算一个整形列表的元素相加之和
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Integer reduce = list.stream().reduce(5, Integer::sum);

        //计算员工列表中所有员工工资累加之和
        Optional<Double> optional = employees.stream().map(e -> e.getSalary()).reduce(Double::sum);
    }

收集

 	 @Test
    /**
     * 收集：将流转换为其他形式，接收一个Collector接口的实现
     * Collect(Collector c)
     * Collector接口中方法的实现决定了如何对流执行收集操作（例如收集到list，map等）
     */
    public void collect1(){
        //收集为list
        List<Employee> list = employees.stream().collect(Collectors.toList());
        //收集为set
        Set<Employee> set = employees.stream().collect(Collectors.toSet());
    }