Java语言10之Stream

1 Stream流式编程

可以用工厂的流水线生产来比喻Stream流编程，一般一个产品需要多步加工操作，通过流水线可以大大提高生产效率。同理，使用Stream流进行编程，可以大大简化我们的开发难度。Stream流编程可以总结出三个特点：

• Stream自己不会存储元素。
• Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream。
• Stream操作是延迟执行的，这意味着他们会等到需要结果的时候才执行。

2 Stream流常用API

2.1 开始操作

开始操作，也就是获取Stream流的操作，Stream流的获取有四种方法：

• 第一种方法是单列集合均有一个stream()或者是一个parallelStream()，二者的区别是前者返回一个串行流，后者返回一个并行流。
• 第二种方法是使用数组工具类Arrays的steam()，如果是基本数据类型的数组则会产生一个xxxStream对象，如果是引用数据类型的话则会产生一个Stream对象。
• 第三种方法是使用Stream类的静态方法of()创建流对象。
• 第四种方法是使用Stream类的静态方法iterate()创建一个无限流。

public class CreateOperation {
    public static void main(String[] args) {
        getStream4().limit(5)
                .forEach(System.out::println);
    }

    // 方式1
    public static Stream<Integer> getStream1() {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);

        return list.stream();
    }

    // 方式2
    public static Stream<Integer> getStream2() {
        Integer[] array = {1, 2};
        return Arrays.stream(array);
    }

    // 方式3
    public static Stream<Integer> getStream3() {
        Integer[] array = {1, 2};
        return Stream.of(array);
    }

    // 方式4
    public static Stream<Integer> getStream4() {
        return Stream.iterate(0, num -> num + 2);
    }
}

2.2 中间操作

2.2.1 映射方法

映射方法，主要有map()，peek()，flatMap()。

public class MapOperation {

    private static List<Integer> testMap() {
        List<Integer> list = Arrays.asList(1, 2);
        return list.stream().map(num -> num * 2)
                .collect(Collectors.toList());
    }

    private static List<Integer> testPeek() {
        List<Integer> list = Arrays.asList(1, 2);
        list.stream().map(num -> {
            System.out.println(num * 2);
            return num;
        });
        // 可以简化为
        return list.stream().peek(num -> System.out.println(num * 2))
                .collect(Collectors.toList());
    }

    private static List<Integer> testFlatMap() {
        List<Integer> list1 = Arrays.asList(1, 2);
        List<Integer> list2 = Arrays.asList(3, 4);
        List<List<Integer>> bigList = Arrays.asList(list1, list2);

        // 先map再flat
        return bigList.stream().flatMap(Collection::stream)
                .collect(Collectors.toList());
    }
}

2.3.2 筛选方法

筛选方法，主要有filter()，distinct()，limit()，skip()。

public class SelectOperation {
    public static void main(String[] args) {
        testSkip().forEach(System.out::println);
    }

    private static List<Integer> testFilter() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        return list.stream().filter(num -> num % 2 == 0)
                .collect(Collectors.toList());
    }

    private static List<Integer> testDistinct() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 4, 3);
        return list.stream().distinct()
                .collect(Collectors.toList());
    }

    private static List<Integer> testLimit() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        return list.stream().limit(3)
                .collect(Collectors.toList());
    }

    private static List<Integer> testSkip() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        return list.stream().skip(3)
                .collect(Collectors.toList());
    }
}

2.3.3 排序方法

public class SortOperation {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 6, 7, 3, 4, 5, 8, 9);
        list.stream()
                .sorted((num1, num2) -> (num1 - num2))
                .forEach(System.out::println);
    }
}

2.3 终止操作

只要执行了终止操作，该Stream对象就不能再使用了！

2.3.1 匹配方法

public class MatchOperation {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 6, 7, 3, 4, 5, 8, 9);

        // 是否所有数字都大于0
        System.out.println(list.stream().allMatch(num -> num > 0));
        // 是否存在数字都大于0
        System.out.println(list.stream().anyMatch(num -> num > 10));
        // 是否没有数字都大于0
        System.out.println(list.stream().noneMatch(num -> num > 10));
    }
}

2.3.2 收集方法

public class CollectOperation {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 6, 7, 3, 4, 5, 8, 9);

        System.out.println(list.stream().collect(Collectors.toList()));
        System.out.println(list.stream().findFirst().get());
        System.out.println(list.parallelStream()
                .filter(num -> num > 5)
                .findAny().get());
    }
}

2.3.3 规约方法

public class ReduceOperation {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 6, 7, 3, 4, 5, 8, 9);

        System.out.println(list.stream().reduce((num1, num2) -> (num1 * num2)).get());
    }
}

2.3.4 统计方法

public class StatOperation {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 6, 7, 3, 4, 5, 8, 9);

        System.out.println(list.stream().min((num1, num2) -> (num1 - num2)).get());
        System.out.println(list.stream().max((num1, num2) -> (num1 - num2)).get());
        System.out.println(list.stream().count());
    }
}

3 并行流

在Java 7之前，并行处理数据集合非常麻烦。第一，你得明确地把包含数据的数据结构分成若干子部分。第二，你要给每个子部分分配一个独立的线程。第三，你需要在恰当的时候对它们进行同步来避免不希望出现的竞争条件，等待所有线程完成，最后把这些部分结果合并起来。

Java 7引入了一个叫作分支/合并（Fork/Join）的框架，让这些操作更稳定、更不易出错。分支/合并框架的目的是以递归方式将可以并行的任务拆分成更小的任务，然后将每个子任务的结果合并起来生成整体结果。它是ExecutorService接口的一个实现，它把子任务分配给线程池（称为ForkJoinPool）中的工作线程。

Java8使用stream()可以得到一个串行流，而使用parallelStream()可以得到一个并行流，并行流可以通过开启多个线程并行计算从而提到计算效率。