开发无忧-Stream

Stream（重要）

map：

map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。下方函数中这里流中的每个元素由Field变为了Pair，因此在操作时是支持将流中元素变为其他类型的元素。

	//处理所有字段 Pair<fieldName, fieldResult>  
	       List<Pair<String, FieldResult>> fieldResults = ReflectUtil.getFields(this.getClass()).stream()  
	               .map(field -> Pair.of(field.getName(), handleField(field, target)))  
	               .peek(pair -> json.put(pair.getKey(), pair.getValue().getResult())) //更新json  
	               .collect(Collectors.toList());  

Map里->后可以用大括号写函数必须要有返回值

	List<ExtVarDTO> dtoList = extVarBOS.stream()  
          .map(extVarBO -> {  
           ExtVarDTO dto = assembler.toExtVartDTO(extVarBO);  
            dto.setMappingStatus(CollectionUtils.isNotEmpty(extVarMappingMap.get(extVarBO.getId())) ? Status.ENABLE : Status.DISABLE);  
              return dto;  
          }).collect(Collectors.toList());  

取出一个元素返回，关键！

Peek消费：

peek：如同于map，能得到流中的每一个元素。但map接收的是一个Function表达式，有返回值；而peek接收的是Consumer表达式，没有返回值。因此如下代码所示，peek方法在map方法后面使用。

	//处理所有字段 Pair<fieldName, fieldResult>  
	     List<Pair<String, FieldResult>> fieldResults = ReflectUtil.getFields(this.getClass()).stream()  
             .map(field -> Pair.of(field.getName(), handleField(field, target)))  
             .peek(pair -> json.put(pair.getKey(), pair.getValue().getResult())) //更新json  
             .collect(Collectors.toList());  

Collect收集

1，返回集合

	//处理所有字段 Pair<fieldName, fieldResult>  
	     List<Pair<String, FieldResult>> fieldResults = ReflectUtil.getFields(this.getClass()).stream()  
	             .map(field -> Pair.of(field.getName(), handleField(field, target)))  
             .peek(pair -> json.put(pair.getKey(), pair.getValue().getResult())) //更新json  
	             .collect(Collectors.toList()); 

2、返回Map

Map<String, RuleStatSubBO> map = ruleStatRepo.getAvgPercentList(statBO).stream().collect(Collectors.toMap(RuleStatSubBO::getD, v -> v));

如果想以元素里的属性作为键值对的话直接如上方RuleStatSubBO::getD，如果想用对象本身作为键值对的话用v->v，原因未知暂时。

flatmap合并集合（重要）

flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

场景1、直接将多个集合合并为流
Stream.of(list1,list2).flatMap(Collection::stream).distinct().collect(Collectors.toList());
场景2、map里映射结果是集合：

List<VarEventRelationBO> toUpdateRels = bos.stream()
        .map(u -> genEventVarList(u.getId(), varType, importReplaceDTO))
        .flatMap(Collection::stream)
        .collect(Collectors.toList());
relFunc.accept(toUpdateRels);

filter、limit、skip、distinct筛选和切片

filter：过滤流中的某些元素,如果只有一行就不要加{}

limit(n)：获取n个元素
skip(n)：跳过n元素，配合limit(n)可实现分页
distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素
结合下方代码理解方法的意思

Stream<Integer> stream = Stream.of(6, 4, 6, 7, 3, 9, 8, 10, 12, 14, 14);  
Stream<Integer> newStream = stream.filter(s -> s > 5) //6 6 7 9 8 10 12 14 14  
  .distinct() //6 7 9 8 10 12 14  
  .skip(2) //9 8 10 12 14  
   .limit(2); //9 8  
newStream.forEach(System.out::println);  

allmatch，anymatch，nonematch，匹配

Predicate函数表示接受一个参数返回一个boolean类型的函数式接口。
allMatch：接收一个 Predicate 函数，当流中每个元素都符合该断言时才返回true，否则返回false
noneMatch：接收一个 Predicate 函数，当流中每个元素都不符合该断言时才返回true，否则返回false
anyMatch：接收一个 Predicate 函数，只要流中有一个元素满足该断言则返回true，否则返回false
结合下方代码来看

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);  
	   
boolean allMatch = list.stream().allMatch(e -> e > 10); //false  
boolean noneMatch = list.stream().noneMatch(e -> e > 10); //true  
boolean anyMatch = list.stream().anyMatch(e -> e > 4);  //true  

findfirst、findany、count、max、min聚合

findFirst：返回流中第一个元素
findAny：返回流中的任意元素
count：返回流中元素的总个数
max：返回流中元素最大值
min：返回流中元素最小值
结合下方代码来看

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);  
	Integer findFirst = list.stream().findFirst().get(); //1  
	Integer findAny = list.stream().findAny().get(); //1  
	long count = list.stream().count(); //5  
	Integer max = list.stream().max(Integer::compareTo).get(); //5  
	Integer min = list.stream().min(Integer::compareTo).get(); //1