Java 8 中的 Stream 俗称为流，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念
Stream 用于对集合对象进行各种非常便利、高效的聚合操作，或者大批量数据操作
Stream API 借助于 Lambda 表达式，极大的提高编程效率和程序可读性
同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势
通过下面的例子我们可以初步体会到使用 Stream 处理集合的便利性

初探Stream

有如下一个 List 集合，现要从中筛选出以 J 开头的元素，然后转换为大写，最后输出结果
Java 8之前我们是这样做的：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift");
        List<String> filterList = new ArrayList<>();
        for (String str : list) {
            if (str.startsWith("J")) {
                filterList.add(str.toUpperCase());
            }
        }
        for (String str : filterList) {
            System.out.println(str);
        }
    }
}

为了筛选集合我们进行了两次外部迭代，并且还创建了一个用来临时存放筛选元素的集合对象
借助Java 8中的Stream我们可以极大的简化这个处理过程：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift");
        list.stream()
                .filter(s -> s.startsWith("J"))
                .map(String::toUpperCase)
                .forEach(System.out::println);
    }
}

是不是很方便？上面的例子中，集合使用 stream 方法创建了一个流，然后使用 filter 和 map 方法来处理这个集合，它们统称为 中间操作。中间操作都会返回另一个流，以便于将各种对集合的操作连接起来形成一条流水线。最后我们使用了 forEach 方法迭代筛选结果，这种位于流的末端，对流进行处理并且生成结果的方法称为 终端操作。

总而言之，流的使用一般包括三件事情：

一个 数据源（如集合）来执行一个查询
一个 中间操作 链，形成一条流的流水线
一个 终端操作，执行流水线，并能生成结果

下表列出了流中常见的中间操作和终端操作：

操作	类型	返回类型	使用的类型 / 函数式接口	函数描述符
filter	中间	Stream<T>	Predicate<T>	T -> boolean
distinct	中间	Stream<T>
skip	中间	Stream<T>	long
limit	中间	Stream<T>	long
map	中间	Stream<R>	Function<T, R>	T -> R
flatMap	中间	Stream<R>	Function<T, Stream<R>>	T -> Stream<R>
sorted	中间	Stream<T>	Comparator<T>	(T, T) -> int
anyMatch	终端	boolean	Predicate<T>	T -> boolean
noneMatch	终端	boolean	Predicate<T>	T -> boolean
allMatch	终端	boolean	Predicate<T>	T -> boolean
findAny	终端	Optional<T>
findFirst	终端	Optional<T>
forEach	终端	void	Consumer<T>	T -> void
collect	终端	R	Collector<T, A, R>
reduce	终端	Optional<T>	BinaryOperator<T>	(T, T) -> T
count	终端	long

下面详细介绍这些操作的使用
除了特殊说明，使用下面这个集合作为演示：

List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");

中间操作

filter

Streams 接口支持 filter 方法，该方法接收一个 Predicate，函数描述符为 T -> boolean，用于对集合进行筛选，返回所有满足的元素：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        list.stream()
                .filter(s -> s.contains("#"))
                .forEach(System.out::println);
    }
}

结果输出 C#

distinct

distinct 方法用于 排除 流中重复的元素，类似于 SQL 中的 distinct 操作
比如筛选中集合中所有的偶数，并排除重复的结果：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
        numbers.stream()
                .filter(i -> i % 2 == 0)
                .distinct()
                .forEach(System.out::println);
    }
}

结果输出 2 4

skip

skip(n) 方法用于跳过流中的 前n个元素，如果集合元素小于n，则返回空流
比如筛选出以 J 开头的元素，并排除第一个：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        list.stream()
                .filter(s -> s.startsWith("J"))
                .skip(1)
                .forEach(System.out::println);
    }
}

结果输出 JavaScript

limit

limit(n) 方法返回一个长度不超过 n 的流，比如下面的例子将输出 Java JavaScript python：
例如你输入的 3，返回的就是3，不会超过3

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        list.stream()
                .limit(3)
                .forEach(System.out::println);
    }
}

map

map 方法接收一个函数作为参数

这个函数会被应用到每个元素上，并将其映射成一个新的元素

如：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        list.stream()
                .map(String::length)
                .forEach(System.out::println);
    }
}

结果输出 4 10 6 3 2 6 5 3 4

map 还支持将流特化为指定的原始类型的流，如通过 mapToInt，mapToDouble 和 mapToLong 方法，可以将流转换为 IntStream，DoubleStream 和 LongStream
特化后的流支持 sum，min 和 max 方法来对流中的元素进行计算
比如：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
        IntStream intStream = numbers.stream().mapToInt(a -> a);
        System.out.println(intStream.sum());
    }
}

也可以通过下面的方法，将 IntStream 转换为 Stream：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
        IntStream intStream = numbers.stream().mapToInt(a -> a);
        Stream<Integer> s = intStream.boxed();
    }
}

flatMap

flatMap 用于将多个流合并成一个流，俗称流的扁平化
这么说有点抽象，举个例子，比如现在需要将 list 中的各个元素拆分为一个个字母，并过滤掉重复的结果，你可能会这样做：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        list.stream()
                .map(s -> s.split(""))
                .distinct()
                .forEach(System.out::println);
    }
}

输出结果如下：

[Ljava.lang.String;@58372a00
[Ljava.lang.String;@4dd8dc3
[Ljava.lang.String;@6d03e736
[Ljava.lang.String;@568db2f2
[Ljava.lang.String;@378bf509
[Ljava.lang.String;@5fd0d5ae
[Ljava.lang.String;@2d98a335
[Ljava.lang.String;@16b98e56
[Ljava.lang.String;@7ef20235

这明显不符合我们的预期
实际上在 map(s -> s.split("")) 操作后，返回了一个 Stream 类型的流，所以输出结果为每个数组对象的句柄，而我们真正想要的结果是 Stream！
在 Stream 中，可以使用 Arrays.stream() 方法来将数组转换为流，改造上面的方法：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        list.stream()
                .map(s -> s.split(""))
                .map(Arrays::stream)
                .distinct()
                .forEach(System.out::println);
    }
}

输出结果如下：

java.util.stream.ReferencePipeline$Head@568db2f2
java.util.stream.ReferencePipeline$Head@378bf509
java.util.stream.ReferencePipeline$Head@5fd0d5ae
java.util.stream.ReferencePipeline$Head@2d98a335
java.util.stream.ReferencePipeline$Head@16b98e56
java.util.stream.ReferencePipeline$Head@7ef20235
java.util.stream.ReferencePipeline$Head@27d6c5e0
java.util.stream.ReferencePipeline$Head@4f3f5b24
java.util.stream.ReferencePipeline$Head@15aeb7ab

因为上面的流经过 map(Arrays::stream) 处理后，将每个数组变成了一个新的流，返回结果为流的数组 Stream[]，所以输出是各个流的句柄
我们还需将这些新的流连接成一个流，使用 flatMap 来改写上面的例子：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        list.stream()
                .map(s -> s.split(""))
                .flatMap(Arrays::stream)
                .distinct()
                .forEach(s -> System.out.print(s + " "));
    }
}

输出结果如下：

J a v S c r i p t y h o n P H C # G l g w f + R u b

和 map 类似，flatMap 方法也有相应的原始类型特化方法，如 flatMapToInt 等

终端操作

anyMatch

anyMatch 方法用于判断流中是否有符合判断条件的元素，返回值为 boolean类型
比如判断 list 中是否含有 SQL 元素：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        System.out.println(list.stream()
                .anyMatch(s -> "SQL".equals(s)));
    }
}

allMatch

allMatch 方法用于判断流中是否所有元素都满足给定的判断条件，返回值为 boolean类型
比如判断 list 中是否所有元素长度都不大于10：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        System.out.println(list.stream()
                .allMatch(s -> s.length() <= 10));
    }
}

注意点：java8 stream接口终端操作allMatch 当list为空集合的一些思考

noneMatch

noneMatch 方法用于判断流中是否所有元素都不满足给定的判断条件，返回值为 boolean类型
比如判断 list 中不存在长度大于10的元素：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        System.out.println(list.stream()
                .noneMatch(s -> s.length() > 10));
    }
}

findAny

findAny 方法用于返回流中的任意元素的 Optional 类型
例如筛选出 list 中任意一个以 J 开头的元素，如果存在，则输出它：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        list.stream()
                .filter(s -> s.startsWith("J"))
                .findAny()
                .ifPresent(System.out::println);
    }
}

findFirst

findFirst 方法用于返回流中的第一个元素的 Optional 类型
例如筛选出 list 中长度大于 5 的元素，如果存在，则输出第一个：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        list.stream()
                .filter(s -> s.length() > 5)
                .findFirst()
                .ifPresent(System.out::println);
    }
}

reduce

reduce函数从字面上来看就是压缩，缩减的意思，它可以用于数字类型的流的求和，求最大值和最小值。如对numbers中的元素求和：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
        System.out.println(numbers.stream().reduce(0, Integer::sum));
    }
}

reduce 函数也可以不指定初始值，但这时候将返回一个 Optional 对象，比如求最大值和最小值：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
        numbers.stream()
                .reduce(Integer::max)
                .ifPresent(System.out::println);
        numbers.stream()
                .reduce(Integer::min)
                .ifPresent(System.out::println);
    }
}

forEach

forEach 用于迭代流中的每个元素，最为常见的就是迭代输出，如：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        list.stream().forEach(System.out::println);
    }
}

count

count 方法用于统计流中的元素的个数，比如：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        System.out.println(list.stream().count());
    }
}

collect

collect 方法用于收集流中的元素，并放到不同类型的结果中，比如 List、Set 或者 Map

举个例子：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "JavaScript", "python", "PHP", "C#", "Golang", "Swift", "C++", "Ruby");
        List<String> filterList = list.stream().filter(s -> s.startsWith("J")).collect(Collectors.toList());
        System.out.println(filterList);
    }
}

如果需要以 Set 来替代 List，只需要使用 Collectors.toSet() 就好了

流的构建

除了使用集合对象的 stream 方法构建流之外，我们可以手动构建一些流

数值范围构建

IntStream 和 LongStream 对象支持 range 和 rangeClosed 方法来构建数值流
这两个方法都是第一个参数接受起始值，第二个参数接受结束值
但 range 是不包含结束值的，而 rangeClosed 则包含结束值
比如对 1 到 100 的整数求和：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        System.out.println(IntStream.rangeClosed(1, 100).sum());
    }
}

由值构建

静态方法 Stream.of 可以显式值创建一个流
它可以接受任意数量的参数
例如，以下代码直接使用 Stream.of 创建了一个字符串流:

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        Stream<String> s = Stream.of("Java", "JavaScript", "C++", "Ruby");
    }
}

也可以使用 Stream.empty() 构建一个空流：

Stream<Object> emptyStream = Stream.empty();

由数组构建

静态方法 Arrays.stream 可以通过数组创建一个流
它接受一个数组作为参数
例如：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        IntStream intStream = Arrays.stream(arr);
    }
}

由文件生成流

java.nio.file.Files 中的很多静态方法都会返回一个流
例如 Files.lines 方法会返回一个由指定文件中的各行构成的字符串流
比如统计一个文件中共有多少个字：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        long wordCout = 0L;
        try (Stream<String> lines = Files.lines(Paths.get("file.txt"), Charset.defaultCharset())) {
            wordCout = lines.map(l -> l.split(""))
                    .flatMap(Arrays::stream)
                    .count();
        } catch (Exception ignore) {
        }
        System.out.println(wordCout);
    }
}

由函数构造

Stream API 提供了两个静态方法来从函数生成流：Stream.iterate 和 Stream.generate
这两个操作可以创建所谓的无限流
比如下面的例子构建了 10 个偶数：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        Stream.iterate(0, n -> n + 2)
                .limit(10).forEach(System.out::println);
    }
}

iterate 方法接受一个初始值（在这里是0）还有一个依次应用在每个产生的新值上的 Lambda（UnaryOperator类型）
这里，我们使用 Lambda n -> n + 2，返回的是前一个元素加上 2
因此，iterate 方法生成了一个所有正偶数的流：流的第一个元素是初始值0
然后加上 2 来生成新的值 2，再加上 2 来得到新的值 4，以此类推

与 iterate 方法类似，generate 方法也可让你按需生成一个无限流
但 generate 不是依次对每个新生成的值应用函数，比如下面的例子生成了 5 个 0 到 1 之间的随机双精度数：

/**
 * @author BNTang
 **/
public class Demo {
    public static void main(String[] args) {
        Stream.generate(Math::random)
                .limit(5)
                .forEach(System.out::println);
    }
}

输出结果如下：

0.4477477019693912
0.8866972547736678
0.6893219838296453
0.3768607796229386
0.9647978867306028

开始使用流

初探Stream

中间操作

filter

distinct

skip

limit

map

flatMap

终端操作

anyMatch

allMatch

noneMatch

findAny

findFirst

reduce

forEach

count

collect

流的构建

数值范围构建

由值构建

由数组构建

由文件生成流

由函数构造

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

开始使用流

初探Stream

中间操作

filter

distinct

skip

limit

map

flatMap

终端操作

anyMatch

allMatch

noneMatch

findAny

findFirst

reduce

forEach

count

collect

流的构建

数值范围构建

由值构建

由数组构建

由文件生成流

由函数构造

热门文章

最新文章

相关电子书