JDK1.8新特性 Stream 和 Collectors

java.util.Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样就可以将多个操作依次串起来。Stream 的创建需要指定一个数据源，比如 java.util.Collection的子类，List或者Set， Map不支持。Stream的操作可以串行stream()执行或者并行parallelStream()执行。

流支持的操作：

1.过滤 filter

public static void testFilter() {
        List<User> users = Arrays.asList(
                new User(1L, "mengday", 28),
                new User(2L, "guoguo", 18),
                new User(3L, "liangliang", 17)
        );
        users.stream().filter(user -> user.getAge() > 18).forEach(System.out::println);
    }

    static class User {
        private Long id;
        private String phone;
        private Integer age;

        public User(Long id, String phone, Integer age) {
            this.id = id;
            this.phone = phone;
            this.age = age;
        }

        public Long getId() {
            return id;
        }

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

        public String getPhone() {
            return phone;
        }

        public void setPhone(String phone) {
            this.phone = phone;
        }

        public Integer getAge() {
            return age;
        }

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

        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", phone='" + phone + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

 2.映射map:用于映射每个元素到对应的结果

 public static void testMap(){
        List<String> list = Arrays.asList("how", "are", "you", "how", "old", "are", "you", "?");
        list.stream().map(item->item.toUpperCase()).forEach(System.out::println);
    }

3.扁平化flatMap：对每个元素执行mapper指定的操作，并用所有mapper返回的Stream中的元素组成一个新的Stream作为最终返回结果，通俗易懂就是将原来的stream中的所有元素都展开组成一个新的stream

 public static void testFlatMap(){
        List<Integer> a = Arrays.asList(1, 2, 3);
        List<Integer> b = Arrays.asList(4, 5, 6);
        // 将多个集合中的元素合并成一个集合
        List<Integer> mergeList = Stream.of(a, b).flatMap(list -> list.stream()).collect(Collectors.toList());
        // [1, 2, 3, 4, 5, 6]
        System.out.println(mergeList);
    }

4.遍历peek：peek用来修改数据,map用来转换数据类型

peek 操作 一般用于不想改变流中元素本身的类型或者只想元素的内部状态时；而 map 则用于改变流中元素本身类型，即从元素中派生出另一种类型的操作。这是他们之间的最大区别。
那么 peek 实际中我们会用于哪些场景呢？比如对 Collection<T> 中的 T 的某些属性进行批处理的时候用 peek 操作就比较合适。 如果我们要从 Collection<T> 中获取 T 的某个属性的集合时用 map 也就最好不过了。

 public static void testPeek(){
        List<String> list = Arrays.asList("you", "don't", "bird", "me", ",", "I", "don't", "bird", "you");
        list.stream().peek(System.out::println).collect(Collectors.toList());
    }

5.去重 distinct

 static void testDistinct(){
        List<String> list = Arrays.asList("AA", "BB", "CC", "BB", "CC", "AA", "AA");
        list.stream().distinct().forEach(System.out::println);
    }

6.跳过 skip

    public static void skip(){
        List<String> list = Arrays.asList("a", "b", "c", "d", "e");
        list.stream().skip(2).forEach(System.out::println); // c、d、e
    }

7.截断 limit

public void limit(){
 List<String> list = Arrays.asList("a", "b", "c", "d", "e");
 list.stream().skip(2).limit(2).forEach(System.out::println); // c、d
}

8.排序 sorted

public void sort(){
 List<String> list = Arrays.asList("c", "e", "a", "d", "b");
 // Stream<T> sorted(Comparator<? super T> comparator);
 // int compare(T o1, T o2);
 list.stream().sorted((s1, s2) -> s1.compareTo(s2)).forEach(System.out::println);
}

9.匹配anyMatch、allMatch、noneMatch

    public void match() {
        List<String> list = Arrays.asList("you", "give", "me", "stop");
        // anyMatch 任意一个元素成功，返回true
        boolean result = list.stream().anyMatch(item -> item.equals("me"));
        System.out.println(result);
        //allMatch 判断条件里的元素，所有的都是，返回true
        boolean match = list.stream().allMatch(item -> item.contains("a"));
        System.out.println(match);
        // noneMatch 判断条件里的元素，所有的都不是，返回true
        match = list.stream().noneMatch(item -> item.contains("a"));
        System.out.println(match);
    }

10.查找findFirst、findAny

    public void findFirst() {
        Stream<String> stream = Stream.of("you", "give", "me", "stop");
        //返回列表中的第一个元素
        String value = stream.findFirst().get();
        System.out.println(value);
        //返回的元素是不确定的，对于同一个列表多次调用findAny()有可能会返回不同的值。
        // 使用findAny()是为了更高效的性能。
        // 如果是数据较少，串行地情况下，一般会返回第一个结果，如果是并行的情况，那就不能确保是第一个。
        String value2 = stream.findAny().get();
        System.out.println(value2);
    }

11.reduce 将Stream中的值计算得到一个最终结果

public void reduce(){
 Stream<String> stream = Stream.of("you", "give", "me", "stop");
 // Optional<T> reduce(BinaryOperator<T> accumulator);
 Optional<String> optional = stream.reduce((before, after) -> before + "," + after);
 optional.ifPresent(System.out::println); // you,give,me,stop
}

12.统计 min max count

    public static void testStatistics(){
        List<String> list = Arrays.asList("1", "2", "3", "4", "5");
        // min max
        Optional<String> optional = list.stream().min((a, b) -> a.compareTo(b));
        // count
        long count = list.stream().count();
        System.out.println(count);
    }

13.collect

public void collect(){
 List<String> list = Arrays.asList("a", "b", "c", "d", "e");
 // Stream -> Collection
 List<String> collect = list.stream().collect(Collectors.toList());
 // Stream -> Object[]
 Object[] objects = list.stream().toArray();
}