Stream流

通过Stream跟容器（集合、数组）关联起来，通过一些中间操作（过滤、去重、截断），不改变原容器的任何东西，返回一个持有新结果的流，遍历新结果的流来获取想要的东西。

创建Stream

package org.westos.test;

import java.util.Arrays;
import java.util.List;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;

public class test {
   
    public static void main(String[] args) {
   
// Stream 的操作三个步骤
        // 1. 创建 Stream
        // 一个数据源（如：集合、数组），获取一个流
        // 2. 中间操作
        // 一个中间操作链，对数据源的数据进行处理
        // 3. 终止操作(终端操作)
        // 一个终止操作，执行中间操作链，并产生结果

        //创建方式1: 通过集合中的stream();就可以创建一个流
        List<Integer> list = Arrays.asList(20, 30, 40);
        Stream<Integer> stream = list.stream();

        //方式2：操作数组的工具类Arrays.stream(arr);
        Integer[] arr={
   10,20,30};
        Stream<Integer> stream1 = Arrays.stream(arr);

        //方式3： Stream.of(20, 30, 40, 50, 60);
        Stream<Integer> integerStream = Stream.of(10, 20, 30);

        //方式4：获取无限流

        /*UnaryOperator<Integer> integerUnaryOperator = new UnaryOperator<Integer>(){

            @Override
            public Integer apply(Integer num) {
                return num+1;
            }
        };*/

        UnaryOperator<Integer> integerUnaryOperator = num->num+1;
        Stream<Integer> iterate = Stream.iterate(0, integerUnaryOperator);
        iterate.limit(10).forEach(System.out::println);//需要一个参数返回为void
       /* iterate.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });*/

       /* 0
        1
        2
        3
        4
        5
        6
        7
        8
        9*/
        System.out.println("=============================================");
        //方式5：获取无限流
        Stream<Double> generate = Stream.generate(new Supplier<Double>() {
   
            @Override
            public Double get() {
   
                double random = Math.random();
                return random;
            }
        });
        generate.limit(20).forEach(System.out::println);

    }
}

中间操作

中间操作是延迟执行的，如果没有终止操作，中间操作不执行

筛选与切片

• filter(Predicate p) 过滤 接收 Lambda ，从流中排除某些元素。
• distinct() 去重，你要 重写hashCode()和equals()方法，你对比成员变量的值是否一样，如果一样就去重。否则比较的是地址值。new对象地址值都不同。无法区分。
• limit
• skip

package org.westos.test;

import org.westos.demo.Employee;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;

//1.创建Stream流
//2.中间操作。中间操作是延迟执行的，如果没有终止操作，中间操作不执行
// filter(Predicate p) 过滤 接收 Lambda ，从流中排除某些元素。
public class test2 {
   
    public static void main(String[] args) {
   
        //1.容器有了
        List<Employee> list = Arrays.asList(
                new Employee(102, "李四", 59, 6666.66),
                new Employee(101, "张三", 18, 9999.99),
                new Employee(103, "王五", 28, 3333.33),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(105, "田七", 38, 5555.55)
        );

        //2.创建 流
        Stream<Employee> stream = list.stream();

        //3.中间操作：过滤姓名赵开头的
        Stream<Employee> stream1 = stream.filter(new Predicate<Employee>() {
   
            @Override
            public boolean test(Employee employee) {
   
                return employee.getName().startsWith("赵");
                // return 返回值的意思就true符合要求，false不符合要求
            }
        });

        //终止操作
        stream1.forEach(System.out::println);
   /*
        Employee [id=104, name=赵六, age=8, salary=7777.77, status=null]
        Employee [id=104, name=赵六, age=8, salary=7777.77, status=null]
        Employee [id=104, name=赵六, age=8, salary=7777.77, status=null] */

        System.out.println("==========================================");
        //过滤出工资大于5000的员工
        Stream<Employee> stream3 = list.stream();
        //链式编程：先过滤返回一个新流，再执行终止操作输出
        stream3.filter(employee -> employee.getSalary()>7000).forEach(System.out::println);
/*Employee [id=101, name=张三, age=18, salary=9999.99, status=null]
Employee [id=104, name=赵六, age=8, salary=7777.77, status=null]
Employee [id=104, name=赵六, age=8, salary=7777.77, status=null]
Employee [id=104, name=赵六, age=8, salary=7777.77, status=null]*/

        System.out.println("===============================");
        //distinct() 去重，你要 重写hashCode()和equals()方法，你对比成员变量的值是否一样，如果一样就去重。否则比较的是地址值。new对象地址值都不同。无法区分。
        //skip(2) 跳过前两个取剩下的
        //limit(2) 要前2个，不要剩下的。
        list.stream().distinct().limit(2).forEach(System.out::println);
        
        
/*Employee [id=102, name=李四, age=59, salary=6666.66, status=null]
Employee [id=101, name=张三, age=18, salary=9999.99, status=null]*/


    }
}

• 映射 map :提取元素应用到一个函数上
• 排序 sorted

package org.westos.test;

import org.westos.demo.Employee;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class test3 {
   
    public static void main(String[] args) {
   
        List<org.westos.demo.Employee> list = Arrays.asList(
                new org.westos.demo.Employee(102, "李四", 59, 6666.66),
                new org.westos.demo.Employee(101, "张三", 18, 9999.99),
                new org.westos.demo.Employee(103, "王五", 28, 3333.33),
                new org.westos.demo.Employee(104, "赵六", 8, 7777.77),
                new org.westos.demo.Employee(104,