Java8 Stream流多字段求和、汇聚的实例

目录
  • Stream流多字段求和、汇聚
    • 实现方法
    • 对象类型数据处理
    • Map类型数据处理
  • Stream分组求和使用笔记
    • 分组求和使用

Stream流多字段求和、汇聚

实现方法

利用

Collectors.toMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction)
  • keyMapper:代表你最终想要获得的Map<Key, Value> 的Key
  • valueMapper:代表你最终想要获得的Map<Key, Value> 的Value
  • mergeFunction:表示碰到Key冲突是处理过程,{x, y}中x是已汇聚对象,y表示当前处理对象

对象类型数据处理

public static Map<String, Model> streamGroupSum(List<Model> datas){
    return datas.stream().collect(Collectors.toMap(k -> k.getCode(), v -> v, (x, y) -> x.addCount().addAll(y)));
  }

Model

@Data
class Model{
    private String code;
    private int count = 0;
    private Integer sum1;
    private Integer sum2;
    public Model(String code, Integer sum1, Integer sum2){
      this.code = code;
      this.sum1 = sum1;
      this.sum2 = sum2;
    }
    public Model addCount(){
      this.count++;
      return this;
    }

    public Model addAll(Model y){
      return add(Model::setSum1, Model::getSum1, y)
          .add(Model::setSum2, Model::getSum2, y);
    }
    /**
    * 使用函数式编程,最终目的是为了求和,类似反射,具体使用方式请移步函数式编程
    */
    public Model add(BiConsumer<Model, Integer> set, Function<Model, Integer> get, Model y){
      set.accept(this, get.apply(this) + get.apply(y));
      return this;
    }
  }

Map类型数据处理

public static void main (String[] args) {
    List<Map<String, Object>> datas = getDatas();
    streamMapSum(datas);
  }
  public static Map<Object, Map<String, Object>> streamMapSum (List<Map<String, Object>> datas) {
    return datas.stream()
        .collect(Collectors.toMap(k -> k.get("name"), v -> {
              v.put("count", 1);
              return v;
            }
            , (x, y) -> {
             	x.put("count", (int) x.get("count") + 1);
             	x.put("aaa", (int) x.get("aaa") + (int) y.get("aaa"));
             	x.put("bbb", (int) x.get("bbb") + (int) y.get("bbb"));
             	x.put("ccc", (int) x.get("ccc") + (int) y.get("ccc"));
             	return x;
             	/*
              //使用ofMap重构
              return ofMap("name", x.get("name")
                  , "count", (int) x.get("count") + 1
                  , "aaa", add(x, y, "aaa")
                  , "bbb", add(x, y, "bbb")
                  , "ccc", add(x, y, "ccc"));*/
             }
         )
    );

  }
  public static int add (Map<String, Object> x, Map<String, Object> y, String key) {
    return (int) x.get(key) + (int) y.get(key);
  }
  public static Map<String, Object> ofMap (Object... objs) {
    System.out.println("ofMap");
    Map<String, Object> map = new LinkedHashMap<>();
    for (int i = 0; i < objs.length; i = i + 2) {
      map.put(objs[i].toString(), objs[i + 1]);
    }
    return map;
  }
  public static List<Map<String, Object>> getDatas () {
    List<Map<String, Object>> list = new ArrayList<>();
    list.add(ofMap("name", "张三", "aaa", 3, "bbb", 5, "ccc", 6));
    list.add(ofMap("name", "张三", "aaa", 8, "bbb", 51, "ccc", 521));
    list.add(ofMap("name", "李四", "aaa", 9, "bbb", 53, "ccc", 23));
    return list;
  }

Stream分组求和使用笔记

话不多说,直接贴代码,分组使用

class Foo {
    private int code;
    private int count;
    public Foo(int code, int count) {
        this.code = code;
        this.count = count;
    }
    public int getCode() {
        return code;
    }
    public void setCode(int code) {
        this.code = code;
    }
    public int getCount() {
        return count;
    }
    public void setCount(int count) {
        this.count = count;
    }
}
public static void main(String[] args) {
        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, List<Foo>> collect = list.stream().collect(Collectors.groupingBy(Foo::getCode));
        List<Foo> list1 = collect.get(1);
        List<Foo> list2 = collect.get(2);
        list1.forEach(e -> System.out.println(e.getCode() + ":" + e.getCount()));
        System.out.println("-----------这里是分界线-----------------------------");
        list2.forEach(e -> System.out.println(e.getCode() + ":" + e.getCount()));
    }

输出结果:

1:2
-----------这里是分界线-----------------------------
2:23
2:6

分组求和使用

public static void main(String[] args) {
        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);
        IntSummaryStatistics statistics2 = collect.get(2);
        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());
        System.out.println(statistics2.getSum());
        System.out.println(statistics2.getAverage());
        System.out.println(statistics2.getMax());
        System.out.println(statistics2.getMin());
        System.out.println(statistics2.getCount());
    }

输出结果:

2
2.0
2
2
1
29
14.5
23
6
2

stream真的是相当的好用,Mark一下,欢迎大神在评论区留下你的Stream骚操作。

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • Java8 stream 中利用 groupingBy 进行多字段分组求和案例

    Java8的groupingBy实现集合的分组,类似Mysql的group by分组功能,注意得到的是一个map 对集合按照单个属性分组.分组计数.排序 List<String> items = Arrays.asList("apple", "apple", "banana", "apple", "orange", "banana", "papaya");

  • java8新特性之stream流中reduce()求和知识总结

    1.stream().reduce()单字段求和 (1)普通数字求和 public static void test2(){ List<Integer> list= Arrays.asList(new Integer[]{1,2,3,4,5,6,7,8,9}); Integer sum=list.stream().reduce((x,y)->x+y).get(); System.out.println(sum); } 2.BigDecimal求和 public static void m

  • Java Stream流之求和的实现

    BigDecimal: BigDecimal bb =list.stream().map(Plan::getAmount).reduce(BigDecimal.ZERO,BigDecimal::add); int.double.long: double max = list.stream().mapToDouble(User::getHeight).sum(); 补充:java8-Stream流之数值函数(求和.最大值.最小值.平均值) 我就废话不多说了,大家还是直接看代码吧~ //todo s

  • Java8 Stream流多字段求和、汇聚的实例

    目录 Stream流多字段求和.汇聚 实现方法 对象类型数据处理 Map类型数据处理 Stream分组求和使用笔记 分组求和使用 Stream流多字段求和.汇聚 实现方法 利用 Collectors.toMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction) keyMapper:代表你最终想要获得的Map<Key, Value> 的Key valueMapper:代表你最终想要获得的Map<K

  • Java8 Stream流的常用方法汇总

    目录 1.快速创建List (1).new一个list,一个一个添加 (2).Stream流:创建动态list,可以添加元素 (3).如果创建一个固定长度的list,可以使用Arrays.asList(…args)直接返回一个list 2.取对象的某一列: (1).遍历 (2).Stream流:map 3.过滤,或者说是根据一个判断条件筛选出目标对象 (1).遍历加 if (2).Stream流:filter 4.分组 (1).遍历加 if (2).Stream流:groupingBy 5.求和

  • 使用Java8 Stream流的skip + limit实现批处理的方法

    为什么需要 Stream Stream 作为 Java 8 的一大亮点,它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念.它也不同于 StAX 对 XML 解析的 Stream,也不是 Amazon Kinesis 对大数据实时处理的 Stream.Java 8 中的 Stream 是对集合(Collection)对象功能的增强,它专注于对集合对象进行各种非常便利.高效的聚合操作(aggregate operation),或者大批量数据操作 (

  • java8 Stream流逐行处理文本文件

    本文中为大家介绍使用java8 Stream API逐行读取文件,以及根据某些条件过滤文件内容 1. Java 8逐行读取文件 在此示例中,我将按行读取文件内容并在控制台打印输出. Path filePath = Paths.get("c:/temp", "data.txt"); //try-with-resources语法,不用手动的编码关闭流 try (Stream<String> lines = Files.lines( filePath )) {

  • java8 stream的多字段排序实现(踩坑)

    关于java8 的stream排序用法这里不做多说,这里介绍下曾经在多字段排序时遇到过的一个坑. 需求:需要根据id去分组,然后取出每组中行号最大的一个对象值. 想到可以利用stream的多字段排序,先按id去排,再看行号去排,demo代码如下: class Tt{ private int id; private int line; public Tt(int id, int line) { this.id = id; this.line = line; } public int getId()

  • Java8 Stream 流常用方法合集

    目录 一.概述 二.分类 三.具体用法 1. 流的常用创建方法 2. 流的中间操作 3. 流的终止操作 一.概述 Stream 是 Java8 中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找.过滤和映射数据等操作.使用Stream API 对集合数据进行操作,就类似于使用 SQL 执行的数据库查询.也可以使用 Stream API 来并行执行操作. 简而言之,Stream API 提供了一种高效且易于使用的处理数据的方式. 特点: 不是数据结构,不会保存数据.

  • Java8 stream流的map()方法你会使用了吗

    目录 一.前言 二.概述 三.详述 3.1.找出所有的学生姓名 3.2.将姓名为“赵三”的语文成绩置为90 3.3.找出一年级学生的成绩 四.总结 一.前言 在日常的开发工作中经常碰到要处理list中数据的问题,比如从数据库中查出了很多学生,由于一些原因需要在内存中找出这些学生中的所有姓名,或者把名为“王五”的语文成绩暂时修改为“100”,这些问题怎么处理呐,之前我们想到的是遍历每个元素,然后取出来放到另外一个集合中,在java8中对集合可以进行流式操作使上面的处理更简洁.今天来看下map()方

  • Java8进行多个字段分组统计的实例代码

    Java8进行多个字段分组统计实现代码如下: // 分组统计 Map<String, Long> countMap = records.stream().collect(Collectors.groupingBy(o -> o.getProductType() + "_" + o.getCountry(), Collectors.counting())); List<Record> countRecords = countMap.keySet().stre

  • Java8 Stream流根据多个字段去重

    目录 Stream流根据多个字段去重 Stream多字段去重,去重求和 完整demo如下 启动主函数 Stream流根据多个字段去重 分组 list.stream().collect(Collectors.groupingBy(ClassEntity::getGrade)); java8有一个collectingAndThen可以根据多个字段去重 list.stream() .collect(Collectors.collectingAndThen(Collectors.toCollection

随机推荐