Java8 流操作

分类

Stream操作分类
中间操作	无状态	unordered(), filter(), map(),mapToInt(), mapToLong(), mapToDouble() , flatMap(), flatMapToInt() , flatMapToLong(),flatMapToDouble(),peek()
	有状态	distinct(),limit(),sorted(),skip
结束操作	非短路操作	forEach(),toArray(),forEachOrdered()collect(),max(),min(),count
	短路操作	anyMatch(),noneMatch(),allMatch(),findFirst(),findAny()

• 无状态：指元素的处理不受之前元素的影响；
• 有状态：指该操作只有拿到所有元素之后才能继续下去。
• 非短路操作：指必须处理所有元素才能得到最终结果；
• 短路操作：指遇到某些符合条件的元素就可以得到最终结果，如 A || B，只要A为true，则无需判断B的结果

用法

创建

//通过Collection集合
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream();

//数组转化
String[] list = new String[5];
Stream<String> stream = Arrays.stream(list);

//Stream中的静态方法：of()、iterate()、generate()
Stream<Integer> stream1 = Stream.of(1,2,3,4,5,6);
Stream<Integer> stream2 = Stream.iterate(0, x -> x).limit(3);
Stream<Double> stream3 = Stream.generate(Math::random).limit(4);

流中间操作

筛选与切片

filter 过滤、distinct 去重

list.stream()
        //将年份大于10的留下
        .filter(x->x.getYear()>10)
        //去重，由于list内是对象，则通过hash值
        .distinct();

skip 跳过、limit 取出

• skip和limit共同使用可以实现分页效果，类似于mysql的limit关键字

list.stream()
        //跳过前两条
        .skip(2)
        //取出结果的1-3条
        .limit(3);

映射

map、flatMap

• map：产生的结果只会一对一
• flatMap：产生一对多结果

List<String> list = Arrays.asList("Hello", "World");
//map产生的结果数量不会增多
List<String[]> mapResult = list.stream()
        .map(x -> x.split(""))
        .collect(toList());
//flatMap产生的结果数量会增多
List<String> flatMapResult = list.stream()
                .flatMap(x -> Arrays.stream(x.split("")))
                .collect(toList());

排序

sorted()、sorted(Comparator com)

• sorted()：自然排序，流中元素需实现Comparable接口
• sorted(Comparator com)：定制排序，自定义Comparator排序器

//传入比较器
Stream<User> sorted = list1.stream().sorted((o1, o2) -> {
  return o2.getId() - o1.getId();
});

消费

peek 赋值

Stream<User> sorted = list1.stream()
               //修改数据
               .peek(x->x.setId(5));

匹配操作

anyMatch、allMatch、noneMatch、findFirst、…

• anyMatch：只要有一个匹配上
• allMatch：每一个匹配上
• noneMatch：没有一个匹配上
• findFirst：返回流中第一个元素
• findAny：返回流中的任意元素
• count：返回流中元素的总个数
• max：返回流中元素最大值
• min：返回流中元素最小值

boolean b = list.stream()
                //有一个符合条件返回true
                .anyMatch(x -> x.getId() > 1);

计算汇总

@Data
@NoArgsConstructor
@AllArgsConstructor
/**
 * 学生
 */
class Student{
    private String name;
    private Integer age;
    private Integer type;
    private BigDecimal money;
}

Student s1 = new Student("aa", 10,1,new BigDecimal(1000));
Student s2 = new Student("bb", 20,1,new BigDecimal(2000));
Student s3 = new Student("cc", 25,2,new BigDecimal(3000));
Student s4 = new Student("dd", 30,2,new BigDecimal(2500));
list = Arrays.asList(s1, s2, s3,s4);

//转成list
List<Integer> ageList = list.stream().map(Student::getAge).collect(Collectors.toList());

//转成set
Set<Integer> ageSet = list.stream().map(Student::getAge).collect(Collectors.toSet());

//字符串分隔符连接（aa,bb,cc）
String stringJoin = list.stream().map(Student::getName).collect(Collectors.joining(",", "(", ")"));


//-------------聚合操作----------------
// 1.计算数量
Long count = list.stream().filter(x->x.getAge()>3).count();

// 2.最大值
Integer maxAge = list.stream().map(Student::getAge).max(Integer::compare).orElse(0);

// 3.求和
Integer sumAge = list.stream().mapToInt(Student::getAge).sum();
//BigDecimal需要做一次转化
BigDecimal sumMoney = list.stream()
        .map(Student::getMoney)
        .reduce(
                BigDecimal.ZERO,
                BigDecimal::add
        );

//平均值
Double averageAge = list.stream().collect(Collectors.averagingDouble(Student::getAge));
BigDecimal averMoney = list.stream().map(Student::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(list.size()), 2, BigDecimal.ROUND_HALF_UP);


//分组
Map<Integer, List<Student>> ageMap = list.stream().collect(Collectors.groupingBy(Student::getAge));
//多重分组,先根据类型分再根据年龄分
Map<Integer, Map<Integer, List<Student>>> sexAgeMap = list.stream().collect(Collectors.groupingBy(Student::getSex, Collectors.groupingBy(Student::getAge)));
// 分组求和
Map<Integer, BigDecimal> map = lockMemberWalletList.stream().collect(Collectors.groupingBy(LockMemberWallet::getMemberWalletId, Collectors.reducing(BigDecimal.ZERO, LockMemberWallet::getTotal, BigDecimal::add)));

//分区
//分成两部分，一部分大于10岁，一部分小于等于10岁
Map<Boolean, List<Student>> partMap = list.stream().collect(Collectors.partitioningBy(v -> v.getAge() > 10));

//reduce 归并
BigDecimal t = list.stream()
        .map(Student::getMoney)
        .reduce(
                BigDecimal.ZERO,
                (x,y)->{
                    return x.add(BigDecimal.ONE).multiply(y);
                }
        );