Java基础 -＞ Stream的中间操作(截断limit,跳过skip,不重复distinct,排序sorted)

    /**
     * 功能描述:stream的中间操作
     * 方法参数描述:无
     */
    @Test
    public void test4() {
        System.out.println('\n' + "limit方法");
        List<Integer> asList = Arrays.asList(5,4,3,2,1,0);
        Stream<Integer> stream = asList.stream();
        /**
         * public abstract Stream<T> limit(long maxSize)
         * 返回由此流的元素组成的流，截断后的长度不超过maxSize。 这是一个短路有状态的中间操作。
         */
        stream.limit(3).forEach(System.out::print);//543

        System.out.println('\n' + "map方法");
        /**
         * public abstract <R> Stream<R> map
         * (java.util.function.Function<? super T, ? extends R> mapper)
         * 返回由将给定函数应用于此流的元素的结果组成的流。 这是一个中间操作。
         */
        Stream<Integer> stream1 = asList.stream();
        stream1.map(s -> s > 1).forEach(System.out::print);//truetruetruetruefalsefalse

        System.out.println('\n' + "下面是filter方法");
        /**
         * public abstract Stream<T> filter
         * (java.util.function.Predicate<? super T> predicate)
         * 返回由与给定谓词匹配的此流的元素组成的流。 这是一个中间操作。
         */
        Stream<Integer> stream2 = asList.stream();
        Stream<Integer> Stream2 = stream2.filter(Integer -> Integer > 2);
        Stream2.forEach(System.out::print);//543

        System.out.println('\n' + "下面是skip方法");
        Stream<Integer> stream3 = asList.stream();
        /**
         * public abstract Stream<T> skip(long n)
         * 在丢弃流的前n个元素后，返回由该流的其余元素组成的流。如果此流包含少于n个元素，则将返回空流。
         * 这是一个有状态的中间操作。
         */
        stream3.skip(5).forEach(System.out::print);//0

        System.out.println('\n' + "下面是distinct方法");
        Stream<Integer> stream4 = asList.stream();
        /**
         * public abstract Stream<T> distinct()
         * 返回由不同元素组成的流（根据对象.等于（Object）这个流的。
         * 对于有序流，不同元素的选择是稳定的（对于重复的元素，保留在遇到顺序中第一个出现的元素）；
         * 对于无序流，不提供稳定性保证。 这是一个有状态的中间操作。
         */
        stream4.distinct().forEach(System.out::print);//543210

        System.out.println('\n' + "下面是flatMap方法");
        Stream<Integer> stream5 = asList.stream();
        /**
         * public abstract <R> Stream<R> flatMap
         * (java.util.function.Function<? super T, ? extendsStream<? extends R>> mapper)
         * 返回一个流，该流由将提供的映射函数应用于每个元素而生成的映射流的内容替换此流的每个元素的结果组成。
         * 在将每个映射流的内容放入此流后，将关闭每个映射流。（如果映射流为空，则使用空流。）
         * 这是一个中间操作。
         */
        stream5.flatMap(Test1006::getStream).forEach(System.out::print);//543210
    }

    public static Stream<Integer> getStream(int i) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(i);
        return arrayList.stream();
    }
    /**
     * 功能描述:Stream中间操作之排序
     * 方法参数描述:无
     */
    @Test
    public void test5() {
        List<Integer> asList = Arrays.asList(5,4,3,2,1,0);
        /** 
         * public abstract Stream<T> sorted()
         * 返回由此流的元素组成的流，按自然顺序排序。如果此流的元素不可比较，
         * 则java.lang.ClassCastException可能在执行终端操作时引发。 
         * 对于有序流，排序是稳定的。对于无序流，不提供稳定性保证。 这是一个有状态的中间操作。
         */ 
        asList.stream().sorted().forEach(System.out::print);//012345
    }