JAVA8中list.stream()的一些简单使用

stream的介绍

Stream 中文称为 “流”，通过将集合转换为这么一种叫做 “流” 的元素序列，通过声明性方式，能够对集合中的每个元素进行一系列并行或串行的流水线操作。这种代码更多地表达了业务逻辑的意图，而不是它的实现机制。易读的代码也易于维护、更可靠、更不容易出错。
stream是无存储的。stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。

为函数式编程而生。对stream的任何修改都不会修改背后的数据源，比如对stream执行过滤操作并不会删除被过滤的元素，而是会产生一个不包含被过滤元素的新stream。
stream上的操作并不会立即执行，只有等到用户真正需要结果的时候才会执行。
stream只能被使用一次，一旦遍历过就会失效，就像容器的迭代器那样，想要再次遍历必须重新生成。
Stream 就如同一个迭代器，单向，不可往复，数据只能遍历一次，遍历过一次后便失效了。

stream中的一些常用方法

stream中获取某个元素集合

 List<Long> list = preList.stream()
                        .map(Student::getUserId).distinct().collect(Collectors.toList());

当遇到字段为null时，需要进行特殊处理

List<Integer> ages=studentList.stream().map(s -> s.getAge() == null ? "" : s.getAge()).collect(Collectors.toList());

ages.removeAll(Collectors.singleton(""));

将List转换为用逗号隔开的字符串

String str = list.stream().map(String::valueOf).collect(Collectors.joining(","));
//计算计算List对象中某个字段值的总和:
int total = list.stream().mapToInt(User::getAge).sum();

filter(T -> boolean)根据某个属性值获取到该对象

保存boolean部分为true的数据
和list.removeIf()方法刚好相反，removelf中的test方法返回true代表会被过滤掉，而filter中代表会保留下来。

 List<Long> userIdList = preList.stream().filter(a -> id.equals(a.getId()))
                        .map(Student::getUserId).distinct().collect(Collectors.toList());

map(T -> R)将T映射为R

Map<String, String> map = list.stream().collect(Collectors.toMap(Student::getId(), User::getName()));

Map<String, Object> map = list.stream().collect(Collectors.toMap(Student::getId(), t -> t));

distinct(去重)

去掉重复元素，如果是实体类需要我们先在类中定义equals方法，否则无法正确处理。

limit(long n) 返回前n个元素

返回前2个元素

list = list.stream().limit(2).collect(toList());

skip(long n) 去掉前n个元素

去掉前两个元素

list = list.stream().skip(2).collect(toList());

flatMap(T -> Stream) 提取

将流中的每一个元素 T 映射为一个流，再把每一个流连接成为一个流（例如使用flatMap 提取 List map 提取年龄）

List ages = grades.stream().flatMap(grade -> grade.getStudents().stream()).map(Student::getAge).collect(Collectors.toList());

anyMatch(T -> boolean)

流中是否有一个元素匹配给定的 T -> boolean 条件
allMatch(T -> boolean)
流中是否所有元素都匹配给定的 T -> boolean 条件
noneMatch(T -> boolean)
流中是否没有元素匹配给定的 T -> boolean 条件
最终返回boolean类型

findAny() 和 findFirst() 查找元素

findAny()：找到其中一个元素 （使用 stream() 时找到的是第一个元素；使用 parallelStream() 并行时找到的是其中一个元素）
findFirst()：找到第一个元素

reduce((T, T) -> T) 和 reduce(T, (T, T) -> T)

第二种方法的第一个T是起始值

//求年龄总和
int sum = list.stream().map(Student::getAge).reduce(0, (a, b) -> a + b);
int sum = list.stream().map(Student::getAge).reduce(0, Integer::sum);
Optional<Integer> sum = list.stream().map(Student::getAge).reduce(Integer::sum);

//求年龄乘积
int sum = list.stream().map(Student::getAge).reduce(1, (a, b) -> a * b);

List根据字段分组

//根据id分组
Map<String, List<Studednt>> resultList = list.stream().collect(Collectors.groupingBy(Studednt::getId));

分组过程中，使用LinkMap固定顺序

//样例
   Map<String,Map<String,List<ScoreInfo>>> cityMap  = rawList.stream()
                .collect(Collectors.groupingBy(ScoreInfo::getCity,LinkedHashMap::new,
                        Collectors.groupingBy(ScoreInfo::getCounty,
                                LinkedHashMap::new,Collectors.toList())));

对生成的map进行自定义排序

使用方法 public static <K, V> TreeMap<K, V> sort(Map<K, V> map, Comparator<? super K> comparator) 

样例  
cityMap=MapUtil.sort(cityMap, Comparator.comparingInt(t->sortOneList.indexOf(t)));

sorted() / sorted((T, T) -> int)

如果流中的元素的类实现了 Comparable 接口，即有自己的排序规则，那么可以直接调用 sorted() 方法对元素进行排序，如 Stream相反, 需要调用 sorted((T, T) -> int) 实现 Comparator 接口

list = list.stream()
           .sorted((p1, p2) -> p1.getSum() - p2.getSum())
           .collect(toList());

Slf4j中使用log.info打印数组

String str =  new ObjectMapper().writeValueAsString(resNodeFirsts);

Collectors.collectingAndThen 可用于：根据list中对象某属性进行去重（对结果集收集的结果再用function函数进行处理，第一个参数是Collector，可以使用Collectors里面的各种工具类）

public static <T,A,R,RR> Collector<T,A,RR> collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)
样例
List<ScoreInfo> rawHeader  = rawList.stream()
              .collect(Collectors.collectingAndThen(Collectors.toCollection(()->new TreeSet<>(Comparator.comparing(t->t.getSubtaskId()))), ArrayList::new));