Stream流

Stream

Stream 是 JDK 8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等
操作。使用 Stream API 对集合数据进行操作，就类似于使用 SQL执行的数据库查询，当然，也可以使用 Stream API 来并行执行操作。换言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

注意：
① Stream 自己不会存储元素。
② Stream 不会改变源对象，每次处理读会返回一个持有结果的新的 Stream 。
③ Stream 操作是延迟执行的，意味着会等到需要结果的时候才执行。

操作步骤:

① 创建 Stream ：通过一个数据源（如：集合、数组），获取一个流。
② 中间操作：中间操作是个操作链，对数据源的数据进行 n 次处理，但是在终结操作前，并不会真正的执行。
③ 终止操作：一旦执行终止操作，就执行中间操作链，最终产生结果并结束 Stream 。

创建 Stream

集合创建 Stream

E.stream()方法转;

List<Integer> list = Arrays.asList(1, 2, 3,4, 5);
// 获取顺序流
Stream<Integer> stream = list.stream();
stream.forEach(System.out::println);

数组转 Stream

Arrays.stream(srr)方法转

//把数组转成Stream流
String[] srr  ={"java","python","c++","web"};
Stream<String> stream = Arrays.stream(srr);//
System.out.println(stream);
//取出流中的数据
stream.forEach(System.out::println);//方法引用的写法

Stream.of() 方法创建 Stream

Stream<Integer> stream = Stream.of(1, 2, 3, 4);
System.out.println("stream = " + stream);
Stream<Integer> stream =Stream.of(10,20,30,40,50);
stream.forEach(System.out::println);
System.out.println("_________________");
String[] srr ={"java","puthon","c++","spring" };
Stream<String> stream2 = Stream.of(srr);
stream2.forEach(System.out::println);

无限流创建 Stream

可以使用 Stream 类的静方法 iterate 和 generate 创建无限流。

Stream<Integer> stream = Stream.iterate(1,num -> num + 1);
stream.limit(10).forEach(System.out::println);

中间操作

1.forEach:循环stream.forEach( student ->{
System.out.println(student);
});

2.filter：过滤

Stream<Integer> stream = list.stream();//集合工具
        //过滤偶数留下奇数
        Stream<Integer> stream2 = stream.filter((i)-> i%2==0);
        stream2.forEach(System.out::println);

ArrayList<students> list =new ArrayList<>();
students s1 = new students(1001,"张三",78);
Collections.addAll(list,s1,s2,s3,s4,s5,s6,s7,s8);
        Stream<students> stream = list.stream();
Stream<students> stream2 =stream.filter(s ->s.getSorce() >=70&&s.getSorce() <=90) ;
        stream2.forEach(System.out::println);

3.distinct：去重

Stream<Integer> stream =Stream.of(1,2,2,2,3,4,5);
       // stream.forEach(System.out::println);
        //去重复元素
        stream.distinct().forEach(System.out::println);

4.limit：截断限制

Stream<Integer> stream =Stream.of(1,2,2,2,3,4,5,6,66,10,666,6,6);
        //限制流保留前五位数据
        stream.limit(5).forEach(System.out::println);

Collections.addAll(list,s1,s2,s3,s4,s5,s6,s7,s8);
        Stream<students> stream = list.stream();
        //对分数进行排序，从高到低
        stream.sorted((stu1,stu2) -> (stu2.getSorce()-stu1.getSorce()) ).limit(3).forEach(System.out::println);

5.skip：跳过前 n 个元素的流

Stream<Integer> stream =Stream.of(1,2,2,2,3,4,5);
        //跳过前n个流
        stream.skip(3).forEach(System.out::println);

6.peek：对每个元素都进行 Lambda 操作

@Test
    public void test02(){
        //对每个元素进行操作，没个元素扩大两倍
        Stream<Integer> stream =Stream.of(1,2,2,2,3,4,5);
        Stream streamPeek = stream.peek(a -> {
            System.out.println(a);
        });
        System.out.println(streamPeek.count());

    }

7.sorted： 对流中的数据进行自然排序：Stream sorted();

Stream<Integer> stream =Stream.of(2,1,3,4,5,6,66,10,666);
        //对流数据进行排序
        stream.sorted().forEach(System.out::println);

● 对流中的数据进行自定义排序：Stream sorted(Comparator<? super T> comparator);

8.map：映射，接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

Stream<Integer> stream =Stream.of(1,2,3,4,5,6);
        //把stream每个元素扩大两被
        stream = stream.map(i -> i*2);
        stream.forEach(System.out::println);;

Stream<students> stream = list.stream();
        Stream<students> stream2 = stream.sorted((stu1,stu2) -> (stu2.getSorce()-stu1.getSorce()) ).limit(3);
        //stream2.forEach(System.out::println);
        //对前三名学生每人加5分
        stream2.map(stu ->stu.getSorce()+5).forEach((System.out::println));

9.collect

//把流转为集合
        List<Integer> list = Stream.of(8,2,10,4,12,6).collect(Collectors.toList());
        System.out.println(list);

终止操作：

allMatch检查流所操作的所有元素是否匹配规则：

// allMatch判断流所操作的元素是否都是偶数
    boolean allMatch = Stream.of( 2, 4, 6).allMatch(i -> i % 2 == 0);
    System.out.println("allMatch = " +allMatch); // allMatch = false

flatMap接收一个函数作为参数，
将流中的每个值都换成另
一个流，然后把所有流连
接成一个流。

Optional

Optional 实际上是个容器：它可以保存类型 T 的值，或者仅仅保存 null 。

创建一个空的

Optional<String> optional =
Optional.of("abc");
System.out.println("optional = " +
optional);

// 创建一个可能为空的，也可能是非空的Optional
Optional<String> optional =
Optional.ofNullable("abc");
System.out.println("optional = " +
optional); // optional = Optional[abc]
optional = Optional.ofNullable(null);
System.out.println("optional = " +
optional); // optional = Optional.empty