Java8中Stream的使用_the method sorted(comparator<? super mcajsprgstats-CSDN博客

本文链接：https://blog.csdn.net/u014231523/article/details/100636009

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 accumulator)

可以将流中元素反复结合起来，得到一个值，返回 T

Optional reduce(BinaryOperator accumulator);

将流中元素反复结合起来，得到一个值, 返回 Optional

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());