java stream笔记

交集(查询在另一个集合中已存在的所有元素)

Stream.of("a","b","c","d")
  .filter(val -> Stream.of("b","c","d","e").anyMatch(str -> str.equals(val)))
  .forEach(System.out::println);

查询在另一个集合中不存在的所有元素

Stream.of("a","b","c","d")
.filter(val -> Stream.of("b","c","d","e").noneMatch(str -> str.equals(val)))
.forEach(System.out::println);

Stream 根据字段去重

memberPOS.stream()
.collect(Collectors.collectingAndThen(Collectors.toCollection(
() -> new TreeSet<MemberPO>(Comparator.comparing(MemberPO :: getHisId))), ArrayList::new));
 

Stream根据多个字段去重

classEntities.stream()
  .collect (Collectors.collectingAndThen(Collectors.toCollection(
    () ->new TreeSet<>(Comparator.comparing(
          o -> o.getProfessionId() + ";" +o.getGrade()))), ArrayList::new));

Stream分页

public PageResult(int pageNum, int pageSize,List<T> rows){
        this.pageNum = pageNum;
        this.pageSize = pageSize;
        this.totalRows = rows.size();
        this.rows= rows.stream().skip((pageNum - 1) * pageSize).limit(pageSize).
                collect(Collectors.toList());
        this.totalPages= rows.size()/pageSize +  (rows.size()%pageSize >0 ? 1:0);
    }

java8 stream多字段排序

Comparator.comparing(类::属性一).reversed(); // 获得排序结果后再排序

Comparator.comparing(类::属性一,Comparator.reverseOrder()); // 直接进行排序

stream 排序说明

List<类> rankList = new ArrayList<>();  // 表明某个集合
 
// 返回 对象集合以类属性一升序排序
 
rankList.stream().sorted(Comparator.comparing(类::属性一));
 
//返回 对象集合以类属性一降序排序 注意两种写法
 
rankList.stream().sorted(Comparator.comparing(类::属性一).reversed()); //先以属性一升序,而后对结果集进行属性一降序
 
rankList.stream().sorted(Comparator.comparing(类::属性一, Comparator.reverseOrder())); //以属性一降序
 
//返回 对象集合以类属性一升序 属性二升序
 
rankList.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));
 
//返回 对象集合以类属性一降序 属性二升序 注意两种写法
 
rankList.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));//先以属性一升序,升序结果进行属性一降序,再进行属性二升序
 
rankList.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));//先以属性一降序,再进行属性二升序
 
//返回 对象集合以类属性一降序 属性二降序 注意两种写法
 
rankList.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,升序结果进行属性一降序,再进行属性二降序
 
rankList.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一降序,再进行属性二降序
 
//返回 对象集合以类属性一升序 属性二降序 注意两种写法
 
rankList.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());//先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
 
rankList.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,再进行属性二降序

并行流

并行流就是把一个内容分成多个数据块，并用不同的线程分成多个数据块，并用不同的线程分别处理每个数据块的流。

  list.parallelStream()  // 生成并行流
  list.stream().parallel()  // 串行流转化成并行流

两个集合使用 stream 作比较/Optional空值处理的案例

list.stream().map(val ->
                // 本地记录
                Optional.ofNullable(LocalList).orElse(Collections.emptyList())
                        .stream()
                        .filter(item -> item.getHisOrderCode().equals(val.getHisOrderCode()))
                        .findFirst()  // 查询处本地记录中与当前记录相等的一条(Optional容器)
                        .map(item -> {       // 如果存在 这将本机地记录赋值给当前记录(Optional容器Map方法)
                            val.setId(item.getId());
                            val.setStatus(item.getStatus());
                            val.setModulesStatus(item.getModulesStatus());
                            val.setFinishDt(item.getFinishDt());
                            val.setStopJson(item.getStopJson());
                            return val;
                        }).orElseGet(() -> {     // 如果不存在给当前记录设置id(Optional容器orElseGet方法)
                            val.setId(DaoHelper.getSeq());
                            return val;
                        });
                return val;
            }).collect(Collectors.toList());

分组统计

list.stream()
    .collect(
    Collectors.groupingBy(
        val -> val.getParams().get("age"),   // key 分组条件
        Collectors.counting()               // value 
    )
);

多条件分组

// 创建集合
List<JSONObject> jsonObjectList = new ArrayList<>();
jsonObjectList.add(new JSONObject().fluentPut("name","哈哈").fluentPut("sex","男").fluentPut("age",11));
jsonObjectList.add(new JSONObject().fluentPut("name","嘿嘿").fluentPut("sex","男").fluentPut("age",12));
jsonObjectList.add(new JSONObject().fluentPut("name","霍霍").fluentPut("sex","男").fluentPut("age",12));
jsonObjectList.add(new JSONObject().fluentPut("name","嗯嗯").fluentPut("sex","女").fluentPut("age",12));

// 第一步以性别为条件进行分组, 对分组后的集合以年龄为条件进行分组统计
Map<Object, Map<Object, Long>> collect = jsonObjectList.stream()
        .collect(Collectors.groupingBy(val -> val.get("sex"), Collectors.groupingBy(v -> v.get("age"), Collectors.counting())));
System.out.println(collect);

每个分组取一个数据

list.stream()
.collect(
Collectors.groupingBy(
 val -> val.getParams().get("age"),   // key 分组条件
 // key值出现重复使用已存在的数据
  Collectors.toMap(val -> val.getParams().get("age"), val -> val, (entity1, entity2) -> entity1)));

filter 判断逻辑优化

Predicate 方法

boolean test(T t) 用来处理参数T 条件是否满足

default Predicate<T> and(Predicate<? super T> other) 条件与

default Predicate<T> or(Predicate<? super T> other) 条件或

default Predicate<T> negate() 条件非

static <T> Predicate<T> isEqual(Object targetRef) 是否相等调用T的equals方法进行判断

// Person实体类
@Data
class Person{
        private int age;
        private String name;
}
// 判断用户中名称为"lisi"或者年龄大于25岁的用户
 Predicate<Person> predicate =  x -> x.name.equals("lisi");
 predicate = predicate.or(x -> x.age > 25);
// filter过滤
 System.out.println(
                Stream.of(
                        new Person(21,"zhangsan"),
                        new Person(22,"lisi"),
                        new Person(23,"wangwu"),
                        new Person(24,"wangwu"),
                        new Person(25,"lisi"),
                        new Person(26,"zhangsan")
                )
                        .filter(personPredicate.negate())
                        .count()
        );