Stream（流）是一个来自数据源的元素队列并支持聚合操作
元素是特定类型的对象，形成一个队列。 - Java中的Stream并不会存储元素，而是按需计算。
数据源，流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。
聚合操作，类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。
和以前的Collection操作不同， Stream操作还有两个基础的特征：Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。
Stream操作的三个步骤
- 创建 Stream
集合接口有两个方法来生成流：
- stream() − 为集合创建串行流。
- parallelStream() − 为集合创建并行流。
- 中间操作
一个中间操作链，对数据源的数据进行处理。比如fifter、distinct、limit、skip、map、sorted、
- 终止操作
一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用。
比如：match、findFirst、count、max、min、forEach、reduce、collect
创建 Stream
一般我们使用的场景是对列表或数组操作。通过Collection的方法stream()和parallelStream()获取。
List<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9);
list.stream().forEach(System.out::println);
list.parallelStream().forEach(System.out::println);
中间操作
fifter(Predicate<? super T> predicate)
根据过滤条件，保留符合条件的元素
List<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9, 9);
list.stream().filter(item -> item > 5).forEach(System.out::println);
distinct ()
去重
list.stream().filter(item -> item > 5).distinct().forEach(System.out::println);
limit(long maxSize)
返回前maxSize个元素
list.stream().filter(item -> item > 5).limit(2).forEach(System.out::println);
skip(long n)
调过前n个
list.stream().filter(item -> item > 5).skip(2).forEach(System.out::println);
sorted()/sorted(Comparator<? super T> comparator)
// 自然排序
list.stream().sorted().forEach(System.out::println);
// 根据比较器顺序排序
list.stream().sorted((a1, a2) -> a2.compareTo(a1)).forEach(System.out::println);
map/flatMap
map(Function<? super T, ? extends R> mapper)
mapToInt(ToIntFunction<? super T> mapper)
mapToDouble(ToDoubleFunction<? super T> mapper)
mapToLong(ToLongFunction<? super T> mapper)
flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
flatMapToInt(Function<? super T, ? extends IntStream> mapper)
flatMapToLong(Function<? super T, ? extends LongStream> mapper)
flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper)
map() 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
flatMap()接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
创建一个对象product
public class Product {
private Long id;
private Integer num;
private Double price;
private String name;
public Product() {}
public Product(Long id, Integer num, Double price, String name) {
this.id = id;
this.num = num;
this.price = price;
this.name = name;
}
// get/set省略
}
Product prod1 = new Product(1L, 1, new Double(15.5), "面包");
Product prod2 = new Product(2L, 2, new Double(20), "饼干");
Product prod3 = new Product(3L, 3, new Double(30), "月饼");
List<Product> prodList = Lists.newArrayList(prod1, prod2, prod3);
List<String> nameList = prodList.stream().map(item -> item.getName()).collect(Collectors.toList());
System.out.println(nameList); // [面包, 饼干, 月饼]
Long count = prodList.stream().mapToInt(item -> item.getNum()).count();
System.out.println(count); // 3
Long min = prodList.stream().mapToLong(item -> item.getId()).min().getAsLong();
System.out.println(min); // 1
prodList.stream().mapToDouble(item -> item.getPrice()).forEach(System.out::println);
// 15.5 20.0 30.0
List<String> strList = prodList.stream().flatMap(item -> Arrays.stream(item.getName().split(""))).collect(Collectors.toList());
System.out.println(strList.toString());
// [面, 包, 饼, 干, 月, 饼]
终止操作
终止操作会从流的流水线生成结果。
anyMatch(Predicate<? super T> predicate);
检查是否有至少一个能够满足条件
Boolean anyMatch = prodList.stream().anyMatch(item -> "面包".equals(item.getName()));
System.out.println("anyMatch="+anyMatch);
allMatch(Predicate<? super T> predicate)
检查是否所有满足条件
Boolean allMatch = prodList.stream().allMatch(item -> "面包".equals(item.getName()));
System.out.println("allMatch="+allMatch);
noneMatch
Boolean noneMatch = prodList.stream().noneMatch(item -> "面包".equals(item.getName()));
System.out.println("noneMatch="+noneMatch);
findFirst
返回第一个
findAny
返回任意一个
System.out.println(prodList.stream().filter(item -> item.getNum() < 3).findFirst().get().getId());
System.out.println(prodList.stream().filter(item -> item.getNum() < 3).findAny().get().getId());
count()总数/min最小数/max最大数
Long count = prodList.stream().count();
Integer num = prodList.stream().min((a1, a2) -> a1.getNum().compareTo(a2.getNum())).get().getNum();
Double price = prodList.stream().max((a1, a2) -> a1.getPrice().compareTo(a2.getPrice())).get().getPrice();
System.out.println(count);
System.out.println(num);
System.out.println(price);
forEach
内部迭代
reduce
- T reduce(T identity, BinaryOperator<T> accumulator)
可以将流中元素反复结合起来，得到一个值，返回 T
- Optional<T> reduce(BinaryOperator<T> accumulator);
将流中元素反复结合起来，得到一个值, 返回 Optional<T>
List<Integer> list = Lists.newArrayList(1, 3, 2, 4, 5, 6, 7, 8, 9);
Integer reduce = list.stream().reduce(0, (x, y) -> x+y);
System.out.println(reduce);
// 有可能为null
List<Product> prodList = Lists.newArrayList();
Optional<Integer> reduceOpt = prodList.stream().map(Product::getNum).reduce(Integer::sum);
System.out.println(reduceOpt.isPresent());
collect
将流转化为其他形式，常用的List,Set、Map、Collection
// 转为list
List<String> nameList = prodList.stream().map(item -> item.getName()).collect(Collectors.toList());
// 转为Set
Set<String> nameSet = prodList.stream().map(item -> item.getName()).collect(Collectors.toSet());
// 转为Map
Map<Long, Product> idMap = prodList.stream().collect(Collectors.toMap(Product::getId,Functions.identity()));
// 转为LinkedList
prodList.stream().map(item -> item.getName()).collect(Collectors.toCollection(LinkedList::new));
//统计总数
Long count = prodList.stream().collect(Collectors.counting());
// 分组
Map<Long, List<Product>> listMap = prodList.stream().collect(Collectors.groupingBy(Product::getId));
// 拼接
String nameJoin = prodList.stream().map(Product::getName).collect(Collectors.joining());
