Stream API 利用Filter函数对没有实现Comperable接口对象做自定义去重并使用嵌套函数合并数量处理及利用Collectors收集器Collector.toMap()进行分批递增处理

class MyObj {
    String name;
    BigDecimal num;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setNum(BigDecimal num) {
        this.num = num;
    }
    public String getNum() {
        return num;
    }
    public MyObj(String name, BigDecimal num) {
        this.name = name;
        this.num = num;
    }
}

        

// 批次单位
int batchNum = 2;
// 使用流处理
List<MyObj> list = new ArrayList<MyObj> () {{
    add(new MyObj("a", 1));
    add(new MyObj("a", 2));
    add(new MyObj("b", 3));
    add(new MyObj("b", 4));
}};

list.stream()
    // 去重合并数量
    .filter(compareAndOperator(MyObj::getName, MyObj::getNum, t -> (a, b) -> t.setNum(a.add(b))))
    // 若 inputDat > 1000  则将 inputData 切割为以1000个为单位分组映射 key自增
    .collect(Collectors.groupingByConcurrent(incrSplitOf(batchNum), Collectors.toMap(MyObj::getName, Function.identity())));



list.stream()
    // 去重合并数量
    .filter(compareAndOperator(MyObj::getName, (a, b) -> {
        a.setNum(a.getNum().add(b.getNum()));
        return a;
    }))
    // 若 inputDat > 1000  则将 inputData 切割为以1000个为单位分组映射 key自增
    .collect(Collectors.groupingByConcurrent(incrSplitOf(batchNum), Collectors.toMap(MyObj::getName, Function.identity())));



    
/**
 * 按 限制 数 进行 key自增 分组映射 函数
 * @param limit
 * @param <T>
 * @return
 */
<T> Function<T,Integer> incrSplitOf(int limit) {
    AtomicInteger index = new AtomicInteger(0);
    AtomicInteger incrKey = new AtomicInteger(0);
    return t -> {
        if (index.intValue() >= limit) {
            index.set(0);
            incrKey.incrementAndGet();
        }
        index.incrementAndGet();
        return incrKey.intValue();
    };
}


/**
 * 比较并操作 函数1 嵌套函数
 * @param keyExtractor
 * @param valueMapper
 * @param operatorFunction
 * @param <T>
 * @param <U>
 * @param <K>
 * @return
*/
 <T,U,K> Predicate<T> compareAndOperator(Function<? super T, K> keyExtractor,
                                         Function<? super T, U> valueMapper,
                                         Function<? super T, BiConsumer<U,U>> operatorFunction) {
    ConcurrentMap<K,T> map = new ConcurrentHashMap<>();
    return t -> {
        K key = keyExtractor.apply(t);
        if (map.containsKey(key)) {
            operatorFunction.apply(map.get(key)).accept(valueMapper.apply(map.get(key)), valueMapper.apply(t));
        }
        return map.putIfAbsent(key, t) == null;
    };
}


/**
 * 比较并操作 函数2 BinaryOperator
 * @param keyExtractor
 * @param operatorFunction
 * @param <T>
 * @param <K>
 * @return
*/
<T,K> Predicate<T> comparatorAndOperator(Function<? super T, K> keyExtractor,
                                   BinaryOperator<? super T> operatorFunction) {
    ConcurrentMap<K,T> map = new ConcurrentHashMap<>();
    return t -> {
        K key = keyExtractor.apply(t);
        if (map.containsKey(key)) {
            T value = (T) operatorFunction.apply(map.get(key), t);
            map.replace(key, value);
        }
        return map.putIfAbsent(key, t) == null;
    };
}