一块儿来学Java8（七）——Stream（上）

从Java8开始，新增了一个java.util.stream包，这个包下的类和接口用来处理集合中的元素，在这个包下面有一个Stream接口，咱们主要使用这个接口来对集合进行操做。

建立Stream

首先来看下建立Stream有哪几种方式。

使用Stream自带的静态方法生成Stream对象，常见的静态方法有如下几个：

• Stream.of(T)
• Stream.of(T... values)
• Stream.generate(Supplier)
• Stream.iterate(T, UnaryOperator)
• Stream.empty()

如今来看下每一个静态方法的做用

Stream.of(T) & Stream.of(T... values)

Stream.of是由两个重载方法组成，一个传入单值，一个传入数组

String[] arr = {"hello", "world"};
Stream streamArr = Stream.of(arr);

String str = "hello world";
Stream streamSingle = Stream.of(str);

Stream.generate & Stream.iterate

Stream.generate和Stream.iterate能够用来生成具备多个元素的Stream，若是不加控制会一直生成下去，通常配合limit(n)使用

先来看下Stream.iterate

Stream<Integer> stream5 = Stream.iterate(0,  n-> n+1)
			.limit(5);
stream5.forEach(System.out::println);

打印

0
1
2
3
4

Stream.iterate方法第一参数设定一个初始值，第二个参数表示基于这个初始值，每次循环后返回一个新的值替换这个初始值。limit(5)表示循环5次结束，最后Stream中包含了5个元素。

再来看下Stream.generate

Stream.generate方法只有一个Supplier参数，意思是每次循环执行Supplier接口方法返回一个新的值，放入到Stream中，因为Supplier是一个函数式接口，所以能够直接写成Lambda表达式

AtomicInteger i = new AtomicInteger();
Stream.generate(()-> {
	return i.getAndIncrement();
})
.limit(5)
.forEach(System.out::println);

上面的代码一样打印0~4。

除了Stream静态方法以外，还可使用Collection接口中的stream()方法来生成Stream对象。

Collection<String> list = Arrays.asList("hello", "world");
Stream streamList = list.stream();

同理，只要是Collection接口的子类或实现类均可以使用stream()方法。

操做Stream

Stream中的方法有不少，大体概括以下表格所示：

方法	方法参数	返回类型	描述
filer	Predicate<T>	Stream<T>	过滤数据
distinct	无	Stream<T>	去重
map	Function<T, R>	Stream<R>	返回新的数据
flatMap	Function<T, R>	Stream<T, Stream<R>>	返回新的数据，并作扁平化处理
sort	Comparator<T>	Stream<T>	对数据进行排序操做
limit	long	Stream<T>	截取前几条数据
skip	long	Stream<T>	跳过几条数据
anyMatch	Predicate<T>	boolean	匹配任意一条数据，若是匹配到返回true
noneMatch	Predicate<T>	boolean	若是没有匹配到数据，返回true
allMatch	Predicate<T>	boolean	若是全部数据所有匹配到，返回true
findAny	无	Optional<T>	返回任意一条数据
findFirst	无	Optional<T>	返回第一条数据
count	无	long	返回元素个数
forEach	Consumer<T>	void	遍历元素，执行Consumer
collect	Collector<T, A, R>	R	元素收集
reduce	BinaryOperator<T>	Optional<T>	数据汇总

从方法的返回结果能够看出，这些方法能够分为两大类，一类是返回Stream对象，能够继续对Stream操做，这类方法也被称之为中间操做（Intermediate operations），另外一类是返回非Stream，结束操做，这类方法也被称之为中端操做（Terminal operations），这两类方法每每一块儿配合操做。

下面咱们挑选其中的几个方法来演示它们的做用。

filter

filter方法用来筛选出咱们想要的数据，方法参数是一个Predicate接口，由于Predicate是一个函数式接口，咱们可使用Lambda表达式来写。

Integer[] arr = { 1, 2, 3, 4, 5 };
long count = Stream.of(arr)
		.filter(i -> i % 2 == 0)
		.count();
System.out.println("偶数数量：" + count);

在这个例子中，咱们筛选出了偶数数字，而且统计出偶数的数量。若是要打印每一个偶数，可使用forEach方法

Stream.of(arr)
		.filter(i -> i % 2 == 0)
		.forEach(System.out::println);

打印：

2
4

若是要查找任意一个元素，可使用findAny

int num = Stream.of(arr)
		.filter(i -> i % 2 == 0)
		.findAny()
		.orElse(0);
System.out.println("findAny:" + num);

注意，findAny()返回的是一个Optional对象，由于有可能没有找到数据，所以须要开发者本身处理没有找到数据的状况。同理findFirst也是返回一个Optional对象。

distinct

distinct方法会对元素进行去重操做，相似于SQL中的SELECT distinct xx

Stream.of(1,1,2,3,3,4)
	.distinct()
	.forEach(System.out::println)

打印

1
2
3
4

sorted

使用sorted方法能够对元素进行排序操做

Stream.of(6,1,7,2,8,5)
	.sorted()
	.forEach(System.out::println);

打印

1
2
5
6
7
8

sorted()默认是从小到大排列，若是要从大到小降序，可使用.sorted(Comparator.reverseOrder())

Stream.of(6,1,7,2,8,5)
	.sorted(Comparator.reverseOrder())
	.forEach(System.out::println);

能够看到，sorted方法容许传入一个比较器Comparator让开发者本身实现排序逻辑。下面是一个自定义Comparator例子：

@Data
@AllArgsConstructor
static class Goods {
	private String goodsName;
	private int price;
}

Stream.of(
		new Goods("iphoneX", 4000)
		, new Goods("mate30 pro", 5999)
		, new Goods("redmek20", 2999)
		)
.sorted((goods1, goods2) -> {
	return Integer.compare(goods1.getPrice(), goods2.getPrice());
})
.forEach(System.out::println);

这个列子演示了按商品价格从低到高排序。此处的sorted部分能够简化为：.sorted(Comparator.comparing(Goods::getPrice))

map

map方法能够返回一个新的数据对象，组成一个新的Stream。

List<Goods> list = Arrays.asList(
		new Goods("iphoneX", 4000)
		, new Goods("mate30 pro", 5999)
		, new Goods("redmek20", 2999)
		);
list.stream()
	.map(goods -> goods.getGoodsName())
	.forEach(System.out::println);

上面的示例演示的是从原有的商品对象中拿到商品名称，而后组成一个新的List，其效果等同于

List<String> goodsNameList = new ArrayList<>(list.size());
for(Goods goods : list) {
	goodsNameList.add(goods.getGoodsName());
}

map方法通常配合collect()方法一块儿使用

List<Goods> list = Arrays.asList(
        new Goods("iphoneX", 4000)
        , new Goods("mate30 pro", 5999)
        , new Goods("redmek20", 2999)
);
List<String> nameList = list.stream()
        .map(goods -> goods.getGoodsName())
        .collect(Collectors.toList());

collect(Collectors.toList())的意思是将Stream中的元素转换成List

flatMap

flatMap()方法是map()方法的扁平化处理，与map不一样的是，flatMap把返回Stream对象操做交给开发者本身处理。看下面的例子：

Stream<String[]> stream = Stream.of("I am Java", "hello world")
        .map(s -> s.split(" "));

这个例子的本意是想要将每一个字符串进行拆分，把单词单独放入到Stream中，因为map返回的是一个字符串数组String[]，所以获得的Stream对象的泛型参数就是Stream<String[]>，而不是Stream<String>。

解决办法是使用flatMap：

Stream<String> stream2 = Stream.of("I am Java", "hello world")
                .flatMap(s -> Stream.of(s.split(" ")));
stream2.forEach(System.out::println);

打印：

I
am
Java
hello
world

综合示例

下面来看一个综合示例，演示的功能是：查询商品名称，价格大于3000，按价格降序

public class StreamTest3 {
    @Data
    @AllArgsConstructor
    static class Goods {
        private String goodsName;
        private int price;
    }

    public static void main(String[] args) {
        List<Goods> list = Arrays.asList(
                new Goods("iphoneX", 4000)
                , new Goods("mate30 pro", 5999)
                , new Goods("redmek20", 2999)
        );
        // 查询商品名称，价格大于3000，按价格降序
        List<String> nameList = list.stream()
                .filter(goods -> goods.getPrice() > 3000)
                .sorted(Comparator.comparing(Goods::getPrice).reversed())
                .map(Goods::getGoodsName)
                .collect(Collectors.toList());
        System.out.println(nameList);
    }
}

打印：[mate30 pro, iphoneX]

代码对应的SQL为：

SELECT goods_name FROM goods WHERE price > 3000 ORDER BY price DESC

小结

本篇讲解了如何建立Stream以及Stream一些经常使用方法的使用方式，咱们将会在下一篇着重讲解collect()和reduce()的用法。

按期分享技术干货，一块儿学习，一块儿进步！