JAVA基础 -- java8新特性一之 Stream流以及基本操作

什么是Stream：

      是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。

注意点：

1、Stream 自己不会存储数据。

2、Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

3、Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

1、创建Stream

@Test
    public void stream01() {
        List<Integer> integers = Arrays.asList(1, 2, 3);
        //通过集合创建顺序流
        Stream<Integer> stream = integers.stream();

        //通过集合创建并行流
        Stream<Integer> integerStream = integers.parallelStream();

        //通过Arrays创建一个Stream
        IntStream arraysStream = Arrays.stream(new int[]{1, 2, 3});

        //通过Stream本身创建一个Stream
        Stream<Integer> integerStream1 = Stream.of(1, 2, 3);
    }

2、Stream中间操作

//测试stream中间操作
    @Test
    public void stream02() {
        //准备一个流
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 1);


        //1、筛选与切片
        //  filter(Predicate p) -- 接受lambda，从流中排出某些元素
        Stream<Integer> integerStream = integers.stream();
        integerStream.filter(i -> i > 4).forEach(System.out :: println);
        System.out.println("****************************");
        //  limit(n)            -- 阶段流，使其元素不超过给定数量(n)
        Stream<Integer> integerStream1 = integers.stream();
        integerStream1.limit(3).forEach(System.out :: println);
        System.out.println("****************************");
        //  skip(n)             -- 跳过元素，返回一个扔掉前n个元素的流，如果元素不足n个，返回要给空流
        Stream<Integer> integerStream2 = integers.stream();
        integerStream2.skip(5).forEach(System.out :: println);
        System.out.println("****************************");
        //  distinct()          -- 筛选，通过流所生成元素hashCode()和equals()去除重复元素
        Stream<Integer> integerStream3 = integers.stream();
        integerStream3.distinct().forEach(System.out :: println);
        System.out.println("****************************");


        //2、映射
        //map -- 接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并映射成一个新的stream。
        List<String> strings = Arrays.asList("aa", "bb", "cc");
        Stream<String> stream = strings.stream();
        stream.map(s -> s.toUpperCase()).forEach(System.out :: println);
        System.out.println("****************************");
        //flatmap -- 接受一个函数作为参数，将流中的每一个值都换成另一个流，然后把所有的流连接起来。
        Stream<String> stream1 = strings.stream();
        stream1.flatMap(StramApiTest::fromStringToStream).forEach(System.out :: println);
        System.out.println("****************************");

        //3、排序
        //sorted -- 自然排序
        List<Integer> integers1 = Arrays.asList(1, 33, 23, 342532, 22, -22);
        integers1.stream().sorted().forEach(System.out :: println);
        System.out.println("****************************");

        //sorted(Comparator c) -- 定制排序
        integers1.stream().sorted(Integer::compareTo).forEach(System.out :: println);
    }

    //通过一个字符串返回字符串流
    public static Stream<Character> fromStringToStream(String s) {
        ArrayList<Character> list = new ArrayList<>();
        for (Character c : s.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    };

3、终止操作

//终止操作
    @Test
    public void stream03() {
        //创建一个Stream
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6);
        //1、匹配与查找
        //allMatch(Predicate p) -- 所有的都满足才返回true
        boolean b = integers.stream().allMatch(i -> i > 1);
        //anyMatch(Predicate p) -- 有一个满足就返回true
        boolean b1 = integers.stream().anyMatch(i -> i > 1);
        //noneMatch(Predicate p) -- 所有的都不满足才返回true
        boolean b2 = integers.stream().noneMatch(i -> i > 1);
        //findFitst -- 返回流中第一个元素
        Optional<Integer> first = integers.stream().findFirst();
        //findAny -- 返回流中任意一个元素
        Optional<Integer> any = integers.stream().findAny();
        //count -- 返回流中所有元素的数量
        long count = integers.stream().count();
        //max -- 返回流中最大的元素
        Optional<Integer> max = integers.stream().max(Integer::compareTo);

        //2、归约
        //reduce(T identity, BinaryOperator) -- 可以将流中元素反复结合起来，得到一个值。
        Integer reduce = integers.stream().reduce(0, Integer :: sum);
        System.out.println(reduce);

        //reduce(BinaryOperator) -- 可以将流中的元素反复集合起来，得到一个值，返回Optional<T>
        Optional<Integer> reduce1 = integers.stream().reduce(Integer :: sum);
        System.out.println(reduce1.get());

        //3、收集
        List<Integer> collect = integers.stream().filter(i -> i > 2).collect(Collectors.toList());
        System.out.println(collect);
    }