体验Java8的流式编程

介绍

JDK 8 不止新增了 Lambda 表达式，还有 Stream 流 ，程序员通过 Stream 流来简化对数据的处理。其本质就是计算。

可以这么理解：流就是数据通道，用于操作数据源所生成的元素序列。

我们来熟悉一下 Stream 流：

public class StringSorting {
    public static void main(String[] args) {
        Stream.of("Java", "Python", "C++",
                "C", "Shell", "Ruby",
                "Scala", "Groovy", "Kotlin",
                "Clojure", "Jython", "C#",
                "JavaScript", "SQL")
                .sorted()   // 自然序排序
                .forEach(s -> System.out.printf("%s ", s));  // 打印输出
    }
}

输出结果：

C C# C++ Clojure Groovy Java JavaScript Jython Kotlin Python Ruby SQL Scala Shell 

由上面的例子，我们可以得知使用 Stream 的步骤：

1. 创建流。例如上面的 Stream.of()
2. 对流的中间操作。例如上面的 sorted()，在流中对数据进行排序。
3. 最终操作。例如上面的 forEach()，将流通过该方法进行打印。

流创建

流的创建主要有以下几种方式：

以下几种方式可以创建 Stream 流：

• Arrays 数组工具类提供的 stream() 静态方法。
• Stream 类中 of()、generate()、iterate()和 empty() 静态方法。
• Stream 类中的 builder() 方法。
• Collection 集合提供的 stream() 方法与 parallelStream() 方法。

还有其它的一些产生流的方法就不一一列举了。下面讲解一下上述创建 Stream 流的方法

Arrays.stream() 静态方法

以下是 Arrays 关于产生流的方法 stream() 及重载方法：

public class Arrays {
    ...省略...
    public static  Stream stream(T[] array) {...}
    public static  Stream stream(T[] array, int startInclusive, int endExclusive) {...}
    public static IntStream stream(int[] array) {...}
    public static IntStream stream(int[] array, int startInclusive, int endExclusive) {...}
    public static LongStream stream(long[] array) {...}
    public static LongStream stream(long[] array, int startInclusive, int endExclusive) {...}
    public static DoubleStream stream(double[] array) {...}
    public static DoubleStream stream(double[] array, int startInclusive, int endExclusive) {...}
    ...省略...
}

由以上方法可知，通过重载形式，可以满足我们调用的基本类型与泛型的数组转化为 Stream 流。

下面是使用 Arrays.stream() 来将数组转换为流的例子：

public class ArraysStream {
    public static void main(String[] args) {
        Arrays.stream(new double[] {3.1415926, 9.8, 3.3333})
                .forEach(System.out::println);
    }
}

Stream 的静态方法

Stream 流中共有 of()、generate() 和 iterate() 三个静态方法。

我们先看一下 Stream.of() 静态方法的源码：

public interface Stream extends BaseStream> {
    ...省略...
    @SafeVarargs
    @SuppressWarnings("varargs") // Creating a stream from an array is safe
    public static Stream of(T... values) {
        return Arrays.stream(values);
    }
    ...省略...
}

由以上源码可知，使用 Stream.of() 静态方法，是将可变元素传递到 Arrays 数组工具类的静态方法 stream() 去转换为流，其实质还是调用 Arrays.stream() 方法。

下面我们来看一下，使用 Stream.of() 来将可变参数数组转化为流的例子：

public class StreamOf {
    public static void main(String[] args) {
        // 将一组数字转换为流
        Stream.of(9.8, 3.1415926, 3.33333)
                .forEach(System.out::println);
    }
}

Stream.of() 静态方法的源码和例子如上所述。·

Stream 还有产生无限元素的静态方法用于产生流，它就是generate() 静态方法：

public interface Stream extends BaseStream> {
    ...省略...
    public static Stream generate(Supplier s) {...}
    ...省略...
}

使用 generate() 方法创建的流，长度是无限的，它的参数是 Supplier 函数接口。

public class StreamGenerate {
    public static void main(String[] args) {
        Stream.generate(Math::random)
                .limit(10)
                .forEach(i -> System.out.printf("%f ", i));
    }
}

输出结果：

0.792192 0.625073 0.983115 0.372405 0.294238 0.790635 0.688823 0.238186 0.096708 0.434963 

我们在看另一个创建无限流的静态方法 Stream.iterate() ：

public interface Stream extends BaseStream> {
    ...省略...
    public static Stream iterate(final T seed, final UnaryOperator f) {...}
    
    public static Stream iterate(T seed, Predicate hasNext, UnaryOperator next) {}
    ...省略...
}

上述两个静态方法都是 iterate 用来创建无限流的，与 generate 方法不同的是，它是通过函数f迭代给指定的种子而产生无限连续有序的Stream。

public class StreamIterate {
    int x = 1;
    Stream numbers() {
        return Stream.iterate(0, i -> {
            int result = x + i;
            x = i;
            return result;
        });
    }
    public static void main(String[] args) {
        new StreamIterate().numbers()
                .skip(20)           // 过滤前 20 个
                .limit(10)          // 然后取 10 个
                .forEach(i -> System.out.printf("%d ", i));
    }
}

输出结果：

6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 

Stream 类中还有一个创建不含任何元素的 Stream 流：

public interface Stream extends BaseStream> {
    ...省略...
    public static Stream empty() {...}
    ...省略...
}

创建空流的例子如下：

public class StreamEmpty {
    public static void main(String[] args) {
        Stream