java8新特性之流式操作集合

java8新增了Stream、IntStream、LongStream、DoubleStream等流式接口，并且为这些接口提供了对应的Builder，如Stream.Builder、IntStream.Builder、LongStream.Builder、DoubleStream.Builder，我们可以通过这些Builder来创建对应的流。

可以先看一下api文档，如下图：

 Builder中有三个方法，一个是无返回值的accept方法，一个是返回当前Builder的add方法，这两个方法都是向正在创建的流中添加元素；还有一个就是build方法，用来创建流。通过源码我们可以看到，add方法其实就是调用了accept方法的。

default Builder add(int t) {
            accept(t);
            return this;
        }

 下面是一个简单的例子，创建流，然后求和：

public void testStream() {
        IntStream stream = IntStream.builder().add(2)
                .add(3)
                .add(5)
                .add(10)
                .add(15)
                .add(16)
                .build();
        System.out.println(stream.sum());
    }

当然，除了以这样的方式创建流之外，在Collection接口中提供了一个stream()，parallelStream()将集合转化成流，后者是并行的。

 这些流式 接口提供了大量的方法进行聚集操作，其中又分为中间（intermediate）方法和末端（terminal）方法。

中间方法：允许流保持打开状态，并允许直接调用后续方法。

末端方法：末端方法是对流的最终操作，当某个流调用末端方法之后，该流将不可再用。

常用的中间方法：

   public void testStream2() {
        List<String> list = new ArrayList<>();
        list.add("java1");
        list.add("java2");
        list.add("java3");
        list.add("java3");
        list.add("java2");
        System.out.println(list.toString());
        Stream<String> s = list.stream();
//去除重复元素
//        List<String> list1 = s.distinct().collect(Collectors.toList());
//过滤元素
//        List<String> list1 = s.filter(p -> p.contains("3")).collect(Collectors.toList());
//转换成对应的流
//        List<Integer> list1 = s.mapToInt(String::length).boxed().collect(Collectors.toList());
//对每个元素执行一些操作，该方法返回的流与原有流包含相同的元素，主要用于测试
//        List<String> list1 = s.peek(p -> {
//            System.out.print(p + "a ");
//        }).collect(Collectors.toList());
//        System.out.println();
//对元素进行排序
//        List<String> list1 = s.sorted().collect(Collectors.toList());
//限制后续访问中允许访问的个数
//        List<String> list1 = s.limit(2).collect(Collectors.toList());
//因为是中间方法，可以连起来调用        
        List<Integer> list1 = s.distinct()
                .sorted()
                .limit(2)
                .filter(p -> p.contains("java"))
                .mapToInt(String::length).boxed()
                .collect(Collectors.toList());
        System.out.println(list1.toString());
    }

常用的末端方法：

public void testStream3() {
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(6);
        list.add(6);
        list.add(7);
        list.add(9);
        System.out.println(list.toString());
        Stream<Integer> s = list.stream();

//        遍历元素
//        s.forEach(e -> System.out.print(e + " "));
//        流转数组
//        Integer[] array = s.toArray(Integer[]::new);
//        Arrays.asList(array).forEach(e -> System.out.print(e + " "));
//        取最小值
//        System.out.println(s.min(Integer::compareTo));
//        取最大值
//        System.out.println(s.max(Integer::compareTo));
//        返回流中元素个数
//        System.out.println(s.count());
//        返回流中第一个元素
//        System.out.println(s.findFirst());
//        串行流返回第一个满足条件的元素
//        System.out.println(s.filter(e -> e > 6).findAny());
//        并行流会返回任一个满足条件的元素（多执行几次）
//        System.out.println(s.filter(e -> e > 6).parallel().findAny());
//        存在元素满足条件返回true
//        System.out.println(s.anyMatch(e -> e > 6));
//        所有元素满足条件才返回true
//        System.out.println(s.allMatch(e -> e > 4));
//        所有元素都不满足条件返回true
//        System.out.println(s.noneMatch(e -> e > 10));
//        用于通过某种操作合并流中的元素，比如下面的求和
        System.out.println(s.reduce((a, b) -> a + b));
    }