java8 分组 和 排序

 

1. 排序

list.sort((o1, o2) -> o2.getAge() - o1.getAge());

 

汉字排序：

 

 private final static Comparator<Object> CHINA_COMPARE = Collator.getInstance(java.util.Locale.CHINA);

    public static void main(String[] args) {
        List<String> cityList = new ArrayList<String>();
        cityList.add("啊");
        cityList.add("博");
        cityList.add("次");
        cityList.add("上海");
        cityList.add("北京");
        cityList.add("广州");
        cityList.add("深圳");

        Collections.sort(cityList, CHINA_COMPARE);
        System.out.println(cityList);
    }

 mylist.sort((o1,o2) ->{
            Collator collator =   Collator.getInstance(java.util.Locale.CHINA);
            return collator.compare(o1.getname(),o2.getname()) ;
        });

 

        // 中文排序
        List<Cwjkproject> collect =  mylist.stream().sorted((o1, o2) -> {
            Comparator comparator = Collator.getInstance(Locale.CHINA);
          return   comparator.compare(o1.getName(),o2.getName());
        }).collect(Collectors.toList()); 

 

1. 多个分组

 Map<Long,Map<Long,List<RStudentExam>>> map = list
            .stream()
            .collect(Collectors.groupingBy(RStudentExam::getId,Collectors.groupingBy(RStudentExam::getSchoolId)));

2. 分组后求和

 参考链接：

https://blog.csdn.net/weixin_44905182/article/details/105792291

需求：

求得每个学生的总成绩

模拟数据如下：

  List<StudentScore> studentScoreList = new ArrayList<>();

        StudentScore studentScore1 = new StudentScore("慕容皝","语文",BigDecimal.valueOf(99));
        StudentScore studentScore2 = new StudentScore("慕容皝","数学",BigDecimal.valueOf(99));
        StudentScore studentScore3 = new StudentScore("慕容皝","英语",BigDecimal.valueOf(97));
        StudentScore studentScore4 = new StudentScore("慕容皝","历史",BigDecimal.valueOf(97));
        studentScoreList.add(studentScore1) ;
        studentScoreList.add(studentScore2) ;
        studentScoreList.add(studentScore3) ;
        studentScoreList.add(studentScore4) ;


        StudentScore studentScore5 = new StudentScore("慕容垂","语文",BigDecimal.valueOf(89));
        StudentScore studentScore6 = new StudentScore("慕容垂","数学",BigDecimal.valueOf(89));
        StudentScore studentScore7 = new StudentScore("慕容垂","英语",BigDecimal.valueOf(87));
        StudentScore studentScore8 = new StudentScore("慕容垂","历史",BigDecimal.valueOf(87));
        studentScoreList.add(studentScore5) ;
        studentScoreList.add(studentScore6) ;
        studentScoreList.add(studentScore7) ;
        studentScoreList.add(studentScore8) ;


        StudentScore studentScore9 = new StudentScore("慕容雪","语文",BigDecimal.valueOf(79));
        StudentScore studentScore10 = new StudentScore("慕容雪","数学",BigDecimal.valueOf(79));
        StudentScore studentScore11 = new StudentScore("慕容雪","英语",BigDecimal.valueOf(77));
        StudentScore studentScore12 = new StudentScore("慕容雪","历史",BigDecimal.valueOf(77));

        studentScoreList.add(studentScore9) ;
        studentScoreList.add(studentScore10) ;
        studentScoreList.add(studentScore11) ;
        studentScoreList.add(studentScore12) ;

 

常规做法：

map 的merge 方法

java8 分组后对组内数据的处理（扩展）

常规：

  // 法① 常规做法
        Map<String, BigDecimal> studentScoreMap1 = new HashMap<>();
        studentScoreList.forEach(studentScore -> {
            if (studentScoreMap1.containsKey(studentScore.getName())) {
                studentScoreMap1.put(studentScore.getName(),
                        // 拿到旧值，在原来的基础上操作
                        studentScoreMap1.get(studentScore.getName()).add(studentScore.getScore()));
            } else {
                studentScoreMap1.put(studentScore.getName(), studentScore.getScore());
            }
        });
        studentScoreMap1.forEach((k,v) -> System.out.println("key: " + k + " , " + "value: " + v));

        System.out.println("-----------------------------sum----------------------");

 

merge：

// 法②
        Map<String, BigDecimal> studentScoreMap2 = new HashMap<>();
        studentScoreList.forEach(studentScore -> studentScoreMap2.merge(
                // key
                studentScore.getName(),
                // value
                studentScore.getScore(),
                (a,b) ->{
                    // add 是返回一个新的 BigDecimal 对象
                    a = a.add(b);
                    return a;
                }));
        studentScoreMap2.forEach((k,v) -> System.out.println("key: " + k + " , " + "value: " + v));

 

merge方法定义在 java.util.Map 中，方法定义如下：

default V merge(K key, V value,
            BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        Objects.requireNonNull(value);
        // 获取旧值
        V oldValue = get(key);
        // 旧值为null ，用value 直接作为新value ; 旧值非null ，执行 函数接口
        V newValue = (oldValue == null) ? value :
                   remappingFunction.apply(oldValue, value);
        if(newValue == null) {
            remove(key);
        } else {
            // insert  or update
            put(key, newValue);
        }
        return newValue;
    }

 

BiFunction 定义：

@FunctionalInterface
public interface BiFunction<T, U, R> {

    /**
     * Applies this function to the given arguments
     * @param t the first function argument
     * @param u the second function argument
     * @return the function result
     */
    R apply(T t, U u);
}

法③

需要自定义 函数式接口 etc（参考int 的算法，比较麻烦）

   // 法③ Java8原生只提供了summingInt、summingLong、summingDouble三种基础类型的方法，想要对BigDecimal类型的数据操作需要自己新建工具类

        System.out.println("-----------------------------sum 3.1 ----------------------");
        Map<String,BigDecimalSummaryStatistics> studentScoreMap4 =
                studentScoreList.stream()
                        .collect(Collectors.groupingBy(StudentScore::getName ,  CollectorsUtil.summarizingBigDecimal(StudentScore::getScore))   );

        studentScoreMap4.forEach((k,v) -> System.out.println("key: " + k + " , " + "value: " + v.getSum()));

 这个最常用：

  
public static <T, K> Collector<T, ?, Map<K, List<T>>>
    groupingBy(Function<? super T, ? extends K> classifier) {
        return groupingBy(classifier, toList());
    }

 

上面的用到的底层是下面的

  public static <T, K, A, D>
    Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
                                          Collector<? super T, A, D> downstream) {
        return groupingBy(classifier, HashMap::new, downstream);
    }

而上面两个方法的最底层调用的都是 下面的：

public static <T, K, D, A, M extends Map<K, D>>
    Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier,
                                  Supplier<M> mapFactory,
                                  Collector<? super T, A, D> downstream) {
        Supplier<A> downstreamSupplier = downstream.supplier();
        BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();
        BiConsumer<Map<K, A>, T> accumulator = (m, t) -> {
            K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
            A container = m.computeIfAbsent(key, k -> downstreamSupplier.get());
            downstreamAccumulator.accept(container, t);
        };
        BinaryOperator<Map<K, A>> merger = Collectors.<K, A, Map<K, A>>mapMerger(downstream.combiner());
        @SuppressWarnings("unchecked")
        Supplier<Map<K, A>> mangledFactory = (Supplier<Map<K, A>>) mapFactory;

        if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
            return new CollectorImpl<>(mangledFactory, accumulator, merger, CH_ID);
        }
        else {
            @SuppressWarnings("unchecked")
            Function<A, A> downstreamFinisher = (Function<A, A>) downstream.finisher();
            Function<Map<K, A>, M> finisher = intermediate -> {
                intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v));
                @SuppressWarnings("unchecked")
                M castResult = (M) intermediate;
                return castResult;
            };
            return new CollectorImpl<>(mangledFactory, accumulator, merger, finisher, CH_NOID);
        }
    }

对分组后，组内数据是int 的求和

 Foo foo1 = new Foo(1, 2);
        Foo foo2 = new Foo(2, 23);
        Foo foo3 = new Foo(2, 6);
        List<Foo> list = new ArrayList<>(4);
        list.add(foo1);
        list.add(foo2);
        list.add(foo3);
        Map<Integer, IntSummaryStatistics> collect = list.stream().collect(Collectors.groupingBy(Foo::getCode, Collectors.summarizingInt(Foo::getCount)));
        IntSummaryStatistics statistics1 = collect.get(1);
        System.out.println(statistics1.getSum());
        System.out.println(statistics1.getAverage());
        System.out.println(statistics1.getMax());
        System.out.println(statistics1.getMin());
        System.out.println(statistics1.getCount());

 源码如下：

  public static <T>
    Collector<T, ?, IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper) {
        return new CollectorImpl<T, IntSummaryStatistics, IntSummaryStatistics>(
                IntSummaryStatistics::new,
                (r, t) -> r.accept(mapper.applyAsInt(t)),
                (l, r) -> { l.combine(r); return l; }, CH_ID);
    }

 构造器定义如下：

static class CollectorImpl<T, A, R> implements Collector<T, A, R> {
        private final Supplier<A> supplier;
        private final BiConsumer<A, T> accumulator;
        private final BinaryOperator<A> combiner;
        private final Function<A, R> finisher;
        private final Set<Characteristics> characteristics;

        CollectorImpl(Supplier<A> supplier,
                      BiConsumer<A, T> accumulator,
                      BinaryOperator<A> combiner,
                      Function<A,R> finisher,
                      Set<Characteristics> characteristics) {
            this.supplier = supplier;
            this.accumulator = accumulator;
            this.combiner = combiner;
            this.finisher = finisher;
            this.characteristics = characteristics;
        }

        CollectorImpl(Supplier<A> supplier,
                      BiConsumer<A, T> accumulator,
                      BinaryOperator<A> combiner,
                      Set<Characteristics> characteristics) {
            this(supplier, accumulator, combiner, castingIdentity(), characteristics);
        }

package java.util;

import java.util.function.IntConsumer;
import java.util.stream.Collector;

/**
 * @since 1.8
 */
public class IntSummaryStatistics implements IntConsumer {
    private long count;
    private long sum;
    private int min = Integer.MAX_VALUE;
    private int max = Integer.MIN_VALUE;

   
    public IntSummaryStatistics() { }

   
    @Override
    public void accept(int value) {
        // 计数,求平均数用的
        ++count;
        // 求和
        sum += value;
        // 最小值
        min = Math.min(min, value);
        // 最大值
        max = Math.max(max, value);
    }

    // 计算对应的值
    public void combine(IntSummaryStatistics other) {
        count += other.count;
        sum += other.sum;
        min = Math.min(min, other.min);
        max = Math.max(max, other.max);
    }


    public final long getCount() {
        return count;
    }

    // 返回和 
    public final long getSum() {
        return sum;
    }

    // 返回最小值
    public final int getMin() {
        return min;
    }

    // 返回最大值
    public final int getMax() {
        return max;
    }

     // 返回平均值（sum 除以 count）
    public final double getAverage() {
        return getCount() > 0 ? (double) getSum() / getCount() : 0.0d;
    }

    @Override
    public String toString() {
        return String.format(
            "%s{count=%d, sum=%d, min=%d, average=%f, max=%d}",
            this.getClass().getSimpleName(),
            getCount(),
            getSum(),
            getMin(),
            getAverage(),
            getMax());
    }
}

 

而他的父接口是函数式接口

 

package java.util.function;

import java.util.Objects;

/**
 * @since 1.8
 */
@FunctionalInterface
public interface IntConsumer {

  
    void accept(int value);

  
}

 

@FunctionalInterface
public interface BiConsumer<T, U> {

    void accept(T t, U u);
}

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T>{

}

 

@FunctionalInterface
public interface BiFunction<T, U, R> {

    R apply(T t, U u);
}

自定义函数式接口

@FunctionalInterface
public interface ToIntFunction<T> {

    int applyAsInt(T value);
}

 

 

接下来改写 一个针对BigDecimal 类型的 group by

先定义初始化对象 ，返回对象

package com.example.demo.service.Impl;

import com.example.demo.entity.annotation.BigDecimalConsumer;

import java.math.BigDecimal;

/**
 * @author: guoyiguang
 **/
public class BigDecimalSummaryStatistics implements BigDecimalConsumer {

    private BigDecimal sum;
    public BigDecimalSummaryStatistics() { }


    public BigDecimal combine(BigDecimalSummaryStatistics other) {
     // 求和
      return   sum = sum.add(other.sum)  ;
    }
    @Override
    public void accept(BigDecimal value) {
        if (null  == sum){
            sum =  value ;
        }else {
            // 计算
            sum  = sum.add(value);
        }

    }

    @Override
    public String toString() {
        return "BigDecimalSummaryStatistics{" +
                "sum=" + sum +
                '}';
    }

     // 要获取到这个对象里的 sum 需要get 方法

    public BigDecimal getSum() {
        return sum;
    }
}

自定义函数式接口

@FunctionalInterface
public interface ToBigDecimalFunction<T> {
    // 传一个 ，返回 BigDecimal  对象
    BigDecimal applyAsBigDecimal(T value);
}

 提供一个返回  stream 流 里的 Collector 的工具类

 

package com.example.demo.utils;

import com.example.demo.entity.annotation.ToBigDecimalFunction;
import com.example.demo.service.Impl.BigDecimalSummaryStatistics;
import java.util.Collections;
import java.util.Set;
import java.util.function.*;
import java.util.stream.Collector;

public class CollectorsUtil {
    static final Set<Collector.Characteristics> CH_NOID = Collections.emptySet();

    private CollectorsUtil() {
    }

    @SuppressWarnings("unchecked")
    private static <I, R> Function<I, R> castingIdentity() {
        return i -> (R) i;
    }

    static class CollectorImpl<T, A, R> implements Collector<T, A, R> {
        private final Supplier<A> supplier;
        private final BiConsumer<A, T> accumulator;
        private final BinaryOperator<A> combiner;
        private final Function<A, R> finisher;
        private final Set<Characteristics> characteristics;

        CollectorImpl(Supplier<A> supplier, BiConsumer<A, T> accumulator, BinaryOperator<A> combiner,
                      Function<A, R> finisher, Set<Characteristics> characteristics) {
            this.supplier = supplier;
            this.accumulator = accumulator;
            this.combiner = combiner;
            this.finisher = finisher;
            this.characteristics = characteristics;
        }


        // 模仿int写的
        CollectorImpl(Supplier<A> supplier, BiConsumer<A, T> accumulator, BinaryOperator<A> combiner,
                      Set<Characteristics> characteristics) {
            this(supplier, accumulator, combiner, castingIdentity(), characteristics);
        }

        @Override
        public BiConsumer<A, T> accumulator() {
            return accumulator;
        }

        @Override
        public Supplier<A> supplier() {
            return supplier;
        }

        @Override
        public BinaryOperator<A> combiner() {
            return combiner;
        }

        @Override
        public Function<A, R> finisher() {
            return finisher;
        }

        @Override
        public Set<Characteristics> characteristics() {
            return characteristics;
        }
    }


    //  CollectorImpl(Supplier<A> supplier,
    //                      BiConsumer<A, T> accumulator,
    //                      BinaryOperator<A> combiner,
    //                      Set<Characteristics> characteristics)
//  T 不管
// 第一个 BigDecimalSummaryStatistics 是初始化对象
// 第二个  BigDecimalSummaryStatistics 是返回对象
    public static <T>
    Collector<T, BigDecimalSummaryStatistics, BigDecimalSummaryStatistics> summarizingBigDecimal(ToBigDecimalFunction<? super T>  mapper) {
//  T 不管
// 第一个 BigDecimalSummaryStatistics 是初始化对象
// 第二个  BigDecimalSummaryStatistics 是返回对象
        return new CollectorImpl<T, BigDecimalSummaryStatistics, BigDecimalSummaryStatistics>(
                BigDecimalSummaryStatistics::new  ,
                // 上一行 new 出来的 BigDecimalSummaryStatistics 对象作为 BiConsumer 的第一个参数
                (r, t) -> r.accept(mapper.applyAsBigDecimal(t)),
                // 上一行 new 出来的 BigDecimalSummaryStatistics 对象作为 BinaryOperator 的第二个参数
                (l, r) -> { l.combine(r); return l; }, CH_NOID);
    }

}

测试代码如下：

 

   // 法③ Java8原生只提供了summingInt、summingLong、summingDouble三种基础类型的方法，想要对BigDecimal类型的数据操作需要自己新建工具类

        System.out.println("-----------------------------sum 3.1 ----------------------");
        Map<String,BigDecimalSummaryStatistics> studentScoreMap4 =
                studentScoreList.stream()
                        .collect(Collectors.groupingBy(StudentScore::getName ,  CollectorsUtil.summarizingBigDecimal(StudentScore::getScore))   );

        studentScoreMap4.forEach((k,v) -> System.out.println("key: " + k + " , " + "value: " + v.getSum()));

测试结果：

-----------------------------sum 3.1 ----------------------
key: 慕容皝 , value: 392
key: 慕容垂 , value: 352
key: 慕容雪 , value: 312