JDK1.8特性： Stream 流对象

转载：（https://blog.csdn.net/a1165117473/article/details/75007311）

package test;


import com.google.common.collect.Lists;
import org.junit.Test;

import java.util.List;
import java.util.stream.Collectors;

public class test {

    @Test
    public void streamTest() {
        /**
         * java.util.Stream表示某一种元素的序列，在这些元素上可以进行各种操作。
         * Stream操作可以是中间操作，也可以是完结操作。
         * 完结操作：返回某种类型的值
         * 中间操作：返回流对象本身
         * 并且你可以通过多次调用同一个流操作方法来将操作结果串起来。
         * Stream是在一个源的基础上创建出来的，例如java.util.Collection中的list或者set（map不
         * 能作为Stream的源）
         * Stream操作往往可以通过顺序或者并行两种方式来执行。
         */
        List<People> peopleList = Lists.newArrayList();
        peopleList.add(new People(1, 1L));
        peopleList.add(new People(2, 1L));
        peopleList.add(new People(1, 3L));
        peopleList.add(new People(4, 4L));

        /**
         * peopleList.stream()：得到一个流对象
         * .map： map方法参数为Function函数式接口
         *  map：是一个对于流对象的中间操作，通过给定的方法，它能够把流对象中的每个元素对应到另外一个对象上。
         * 整体解释：得到people的age值，并输出list
         */
        peopleList.stream().map(People::getAge);
        List<Integer> age = peopleList.stream().map(People::getAge).collect(Collectors.toList());


        System.out.println(age);//[1, 2, 1, 4]
        /**
         * 得到去重复distinct的list
         */
        age = peopleList.stream().map(People::getAge).distinct().collect(Collectors.toList());
        System.out.println(age);//[1, 2, 4]

        /**
         * Filter是一个中间操作，因此允许我们在返回的基础之上再进行其他流的操作。
         * Filter接受一个Predicate接口类型的变量，并将所有流对象中的元素进行过滤。
         * forEach：接受一个function接口类型的变量，用来执行对每一个元素的操作。
         * forEach是一个中止操作。它不返回流，所以哦我们不能再调用其他的流操作。
         * 解释：得到peoplea对象age是1的，并在控制台打印出来。
         */
        peopleList.stream().filter((s) -> s.getAge() == 1).forEach(System.out::println ());
    }

    /**
     * Sorted是一个中间操作，能够返回一个排过序的流对象的视图。流对象中的元素会默认按照自然顺序进行排序，
     * 除非你自己指定一个Comparator接口来改变排序规则.
     *
     * <p>
     * 一定要记住，sorted只是创建一个流对象排序的视图，而不会改变原来集合中元素的顺序。原来string集合中的元素顺序是没有改变的
     */
    @Test
    public void useStreamSort() {
        // Stream<T> sorted();返回Stream接口
        // 另外还有一个 Stream<T> sorted(Comparator<? super T>
        // comparator);带Comparator接口的参数
        stringList.stream().sorted().filter((s) -> s.startsWith("a")).forEach(System.out::println);

        // 输出原始集合元素，sorted只是创建排序视图，不影响原来集合顺序
        stringList.stream().forEach(System.out::println);
    }

    /**
     * 使用并行流
     * 流操作可以是顺序的，也可以是并行的。顺序操作通过单线程执行，而并行操作则通过多线程执行. 可使用并行流进行操作来提高运行效率
     */
    @Test
    public void parallelStreams() {
        // 初始化一个字符串集合
        int max = 1000000;
        List<String> values = new ArrayList<>();

        for (int i = 0; i < max; i++) {
            UUID uuid = UUID.randomUUID();
            values.add(uuid.toString());
        }

        // 使用顺序流排序

        long sequenceT0 = System.nanoTime();
        values.stream().sorted();
        long sequenceT1 = System.nanoTime();

        // 输出:sequential sort took: 51921 ms.
        System.out.format("sequential sort took: %d ms.", sequenceT1 - sequenceT0).println();

        // 使用并行流排序
        long parallelT0 = System.nanoTime();
        // default Stream<E> parallelStream() {
        // parallelStream为Collection接口的一个默认方法
        values.parallelStream().sorted();
        long parallelT1 = System.nanoTime();

        // 输出:parallel sort took: 21432 ms.
        System.out.format("parallel sort took: %d ms.", parallelT1 - parallelT0).println();

        // 从输出可以看出：并行排序快了一倍多
    }

    class People {

        private Integer age;

        private Long id;

        public People(Integer age, Long id) {
            this.age = age;
            this.id = id;
        }

        public Integer getAge() {
            return age;
        }

        public void setAge(Integer age) {
            this.age = age;
        }

        public Long getId() {
            return id;
        }

        public void setId(Long id) {
            this.id = id;
        }
    }
}