Stream（一）初识Stream

1.什么是Stream

Stream，用于操作数据源（集合、数组等）所生成的元素序列。Stream主要是为了增强集合操作而生的。Stream关注的是对数据的运算，与CPU打交道
集合关注的是数据的存储，与内存打交道。

2.Stream的基本使用

Stream的基本使用分为三步，即创建Stream->中间操作->终止操作

2.1 Stream 的特点

① Stream 自己不会存储元素。
② Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
③ Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
④ 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

2.1 创建Stream

 	@Test
    public void test(){
        //创建 Stream方式一：通过集合
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        //default Stream<E> stream() : 顺序流
        Stream<Integer> stream = list.stream();
        // default Stream<E> parallelStream() : 并行流
        Stream<Integer> stream1 = list.parallelStream();

        //创建 Stream方式二：通过数组
        int[] arr = new int[]{1,2,3,4,5,6};
        IntStream stream2 = Arrays.stream(arr);

        //创建 Stream方式三：通过Stream的of()
        Stream<Integer> stream3 = Stream.of(1, 2, 3, 4, 5);
    }

2.2 中间操作与终止操作

中间操作：
① filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。
② limit(n)——截断流，使其元素不超过给定数量。
③ skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
④ distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
⑤ map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。

@Test
    public void test2(){
        List<String> list = Arrays.asList("JAVA","C++","C#","PHP","SQL","JS","JAVA");
        //filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。
        /*list.stream():创建stream 创建的stream在终止操作后就销毁了
        filter(str->str.length()>3)：中间操作
        forEach(str->System.out.println(str))：终止操作

        */
        System.out.println("中间操作filter测试结果");
        list.stream().filter(str->str.length()>=3).forEach(str->System.out.println(str));
        //limit(n)——截断流，使其元素不超过给定数量。
        System.out.println("中间操作limit测试结果");
        list.stream().limit(3).forEach(System.out::println);
        //skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
        System.out.println("中间操作skip测试结果");
        list.stream().skip(3).forEach(System.out::println);
        //distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
        System.out.println("中间操作distinct测试结果");
        list.stream().distinct().forEach(System.out::println);
        // map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。
        System.out.println("中间操作map测试结果");
        list.stream().map(str->str.length()).forEach(System.out::println);
		// 过滤后得到新集合
        System.out.println("***********过滤后得到新集合***********");
        List<String> newList = list.stream().filter(str -> str.contains("A"))
                .collect(Collectors.toList());
        newList.forEach(System.out::println);

        // list转成新list
        System.out.println("***********list转成新list***********");
        List<Map<String, Object>> list1 = list.stream().map(str -> {
            Map<String, Object> map = new HashMap<>();
            map.put(str, str + "value");
            return map;
        }).collect(Collectors.toList());
        list1.forEach(System.out::println);    
}

执行效果


终止操作
① allMatch(Predicate p)——检查是否匹配所有元素。
② anyMatch(Predicate p)——检查是否至少匹配一个元素。
③ noneMatch(Predicate p)——检查是否没有匹配的元素。
④ findFirst——返回第一个元素
⑤ findAny——返回当前流中的任意元素
⑥ count——返回流中元素的总个数
⑦ max(Comparator c)——返回流中最大值
⑧ min(Comparator c)——返回流中最小值
⑨ forEach(Consumer c)——内部迭代

@Test
    public void test3(){
        List<String> list = Arrays.asList("JAVA","C++","C#","PHP","SQL","JS","JAVA");
        //allMatch(Predicate p)——检查是否匹配所有元素。
        //没有中间操作可省略，直接进行终止操作
        System.out.println("终止操作allMatch测试结果");
        boolean allMatch = list.stream().allMatch(str -> str.contains("J"));
        System.out.println(allMatch);

        //anyMatch(Predicate p)——检查是否至少匹配一个元素。
        System.out.println("终止操作anyMatch测试结果");
        boolean anyMatch = list.stream().anyMatch(str -> str.contains("C"));
        System.out.println(anyMatch);

        //noneMatch(Predicate p)——检查是否没有匹配的元素。
        System.out.println("终止操作noneMatch测试结果");
        boolean noneMatch = list.stream().noneMatch(str -> str.contains("Z"));
        System.out.println(anyMatch);

        //findFirst——返回第一个元素
        System.out.println("终止操作findFirst测试结果");
        System.out.println(list.stream().findFirst());
        //findAny——返回当前流中的任意元素
        System.out.println("终止操作findAny测试结果");
        System.out.println(list.stream().findAny());
        System.out.println(list.parallelStream().findAny());
    }

@Test
    public void test4(){
        List<String> list = Arrays.asList("JAVA","C++","C#","PHP","SQL","JS","JAVA");
        //count——返回流中元素的总个数
        System.out.println("终止操作-count-测试结果");
        System.out.println(list.stream().filter(str->str.contains("J")).count());

        //max(Comparator c)——返回流中最大值
        System.out.println("终止操作-max-测试结果");
        //Stream.of(0,2,6,0,5,6,-5,-1).max((i1,i2)->i1.compareTo(i2));
        //Arrays.stream(arr)这里的arr数组要设置成Integer 因为Arrays.stream 没法自动装箱
        Integer[] arr = new Integer[]{1,2,3,4,5,6};
        System.out.println(Arrays.stream(arr).max((i1,i2)->i1.compareTo(i2)));

        //min(Comparator c)——返回流中最小值
        System.out.println("终止操作-min-测试结果");
        System.out.println(Arrays.stream(arr).min((i1,i2)->i1.compareTo(i2)));
        //forEach(Consumer c)——内部迭代
        System.out.println("终止操作-forEach-测试结果");
        list.stream().forEach(System.out::println);
    }