Java 8 引入了流式操作（Stream），通过该操作可以实现对集合（Collection）的并行处理和函数式操作。根据操作返回的结果不同，流式操作分为中间操作和最终操作两种。最终操作返回一特定类型的结果，而中间操作返回流本身，这样就可以将多个操作依次串联起来。根据流的并发性，流又可以分为串行和并行两种。流式操作实现了集合的过滤、排序、映射等功能。

Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算。
除了使用Stream 外，还可以使用parallelStream()并发流，我一般都使用并发来处理，速度快上很多，但是要注意返回顺序。

Stream 操作种类分类两类：流的中间操作，流的终端操作。

常见的操作有：

filter()：对元素进行过滤；

List list=new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add("6");
list.add("1");
list.add("2");
//Filter 过滤
list.stream().filter(e->e.equals("1")).forEach(e-> System.out.println("Filter过滤结果---e));

sorted()：对元素排序；

//Sorted 排序
list.stream().sorted().forEach(e-> System.out.println("Sorted过滤结果---------"+e));
list.stream().sorted(Comparator.comparing(String::new)).forEach(e-> System.out.println("Sorted过滤结果---------"+e));

map()：元素的映射；

 static class TestEntity {
        private String key;
        private String value;
        public TestEntity(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public String getKey() {
            return key;
        }

        public void setKey(String key) {
            this.key = key;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }
    }
  //map()元素的映射；
           List<TestEntity> listMap=new ArrayList<TestEntity>();
           listMap.add(new TestEntity("1","a1"));
           listMap.add(new TestEntity("2","a2"));
           listMap.add(new TestEntity("3","a3"));
  //实际映射到LIST<String>中
           listMap.stream().map(e->e.getKey()).collect(Collectors.toList()).forEach(e->System.out.println("map()元素的映射结果---------"+e));

distinct()：去除重复元素；

//Distinct去除重复元素
        list.stream().distinct().collect(Collectors.toList()).forEach(e-> System.out.println("Distinct去除重复元素结果---------"+e));

findFirst()：返回第一个匹配的元素；

//findFirst(): 返回第一个匹配的元素
        Optional<String> s=list.stream().filter(e->e.equals("1")).findFirst();

forEach()：对每个元素做处理；

这个上面已经又很多案例了

toArray()：把元素导出到数组；

  //toArray
        String[] strings= list.stream().toArray(String[]::new);

anyMatch()：是否有匹配的元素；

       //anyMatch() 是否存在 allMatch 是否匹配所有元素 noneMatch 是否未匹配所有元素
        boolean exits=list.stream().anyMatch(e->e.equals("1"));

collect(）：转集合（一般配合map使用）

           //.collect收集器 将流中的元素累积到集合中
           //toList
          List<String> stringList= listMap.stream().map(e->e.getKey()).collect(Collectors.toList());
          //收集到String中
           String s= listMap.stream().map(e->e.getKey()).collect(Collectors.joining(", "));
           //toSet
           Set<String> stringSet=listMap.stream().map(e->e.getKey()).collect(Collectors.toSet());
           //toCollection 指定到给定的集合
           Collection<String> stringArray=listMap.stream().map(e->e.getKey()).collect(Collectors.toCollection(ArrayList::new));
           //Counting 计数
           Long count=listMap.stream().map(e->e.getKey()).collect(Collectors.counting());
           //SummingInt 求和
           Long countSum=listMap.stream().map(e->e.getKey()).collect(Collectors.summingLong(Long::parseLong));
           //groupingBy 根据流中元素的某个值对流中的元素进行分组,并将属性值做为结果map的键
           Map<String,List<TestEntity>>  map=listMap.stream().collect(Collectors.groupingBy(TestEntity::getKey));
           //averagingInt 算平均
           Double   countAve = listMap.stream().map(e->Double.parseDouble(e.getKey())).collect(Collectors.averagingLong(Double::longValue));

flatMap 扁平化

 //flatMap 扁平化
        List<String> collect1 = Arrays.stream(strings).map(str->str.split("")).flatMap(Arrays::stream).collect(Collectors.toList());

partitioningBy 收集器

  Map<Boolean, List<TestEntity>> map1 = listMap.stream().collect(Collectors.partitioningBy(t->{
                int key = Integer.parseInt(t.getKey());
                return key>2;
            }));

collectingAndThen 转换函数返回的类型（个人常用于对象去重）

 //collectingAndThen 转换函数返回的类型
            listMap = listMap.stream().collect(
                    Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(TestEntity::getKey, (t1, t2) -> {
                        return t2.compareTo(t1);
                    }))), ArrayList::new));
            listMap.stream().forEach(e -> {
                System.out.println("排序后结果：---" + e.getKey());
            });

limit(): 限流操作；

    //Limit(): 限流操作 ,返回前N条
        list.stream().limit(3).collect(Collectors.toList()).forEach(e-> System.out.println("Limit去限流元素结果---------"+e));

《未完待续》