精华内容
下载资源
问答
  • Java中list集合根据字段汇总金额

    千次阅读 2021-02-26 12:48:24
    Supplier mapFactory, Collector downstream) 我把泛型去掉方便好看,其实参数也就是三种 classifier:根据什么方式去做分类,这是一个Function mapFactory:最终分类的数据以什么类型map存放,因为分类嘛,就是...

    既然题主提到说要用lambda表达式,而lambda本质来说就是一种写法,用stream的内部循环和传统的外部循环来比较,那就是写法不一样,写法不一样那就更应该明确当前需要的输入和输出了,输入是给清楚了,但是输出呢?题主只是说要返回一个新的List集合,这个List里装的啥?不同的东西最终可能导致写法的不太一致,没准思考方式也不太一样哈

    我暂且以最终还是返回List为例,做个参考。

    如果你想直接看最后的答案,可以直接拖到最后,下面只是我的一个思考过程而已

    因为这里需要处理的主要问题就是相同的id和currency上的amount相加,那归根到底就是相同的id和currency的Foo对象要放在一起处理,这就是归类,归类在stream的api当然就要用Collectors.groupBy方法了

    Collectors.groupBy有三个重载方法

    groupingBy(Function classifier)

    groupingBy(Function classifier, Collector downstream)

    groupingBy(Function classifier, Supplier mapFactory, Collector downstream)

    我把泛型去掉方便好看,其实参数也就是三种

    classifier:根据什么方式去做分类,这是一个Function

    mapFactory:最终分类的数据以什么类型map存放,因为分类嘛,就是相同类型的对象在一起,所以最终肯定是一个map结构

    downstream:同一类的对象应该什么方式去做收集或者叫聚合

    为了方便理解这三个参数,我们如果直接使用Collectors.groupingBy(Foo::getId)最后得到的就是Map>

    List fooList = new ArrayList<>();

    Map> map = fooList.stream().collect(Collectors.groupingBy(Foo::getId));

    我们可以看一下一个参数的Collectors.groupingBy是怎么实现的

    131517f29bd7360a24ca2d23fb05c531.png

    它调用的是两个参数的方法,并且给downstream参数传递的是常用的toList()方法

    这两个参数的方法又是调用的三个参数的方法

    a199cc5a61e2bc42a1381f44a218bae1.png

    所以好理解为啥是最终得到Map>,有了这个准备的基础我们再来看题主的问题

    需要按照id和currency分类, 那我们就创建一个分类的方式

    fooList.stream()

    .collect(Collectors.groupingBy(foo -> foo.getId() + "_" + foo.getCurrency()))

    这样写不太好看,我们可以把这个分类方式放在Foo里

    @Getter

    @Setter

    @AllArgsConstructor

    public class Foo {

    private String id;

    private String currency;

    private BigDecimal amount;

    public String groupKey() {

    return this.id + "_" + this.currency;

    }

    }

    那我们就可以按照方法引用的方式写成

    Map> map = fooList.stream()

    .collect(Collectors.groupingBy(Foo::groupKey));

    接下来我们考虑如何合并这些同类Foo对象的amount值,由于我们本身来说最终的结果不需要对于Collectors.groupingBy方法的第二个参数mapFactory做过多定制,所以我们就只采用两个参数的方法了

    剩下这个参数downstream需要去处理amount的问题,相当于我们现在已经按照Foo::groupKey的方式做了归类,我们拿到了同一类的一堆Foo对象

    如果我们downstream参数写Collectors.toList,那最终结果肯定是Map>

    如果我们downstream参数写Collectors.toSet,那最终结果肯定是Map>

    但是这些方式不是我们想要的,我们不想要把这一堆的Foo对象转换为Set或者List,我们是希望把他们合并在一起,也就是

    一堆Foo -> 一个Foo

    那对应stream的api当然就要用Collectors.reducing方法了,这个reducing就是聚合的方法,把多个聚合成一个,正是我们想要的

    reducing方法也有三个参数,不过比较稍微复杂一点点,我之前也有个回答提到了java8中3个参数的reduce方法怎么理解? 你可以去看一下,虽然里面说的是stream.reduce,但是和Collectors.reducing是一样的

    总得来说就是处理两个相同的Foo如何合并为一个Foo,也就是提供reducing方法参数里的一种处理方式BinaryOperator

    当然我们也可以把这种处理方式写到Foo类中,新增merge方法

    @Getter

    @Setter

    @AllArgsConstructor

    public class Foo {

    private String id;

    private String currency;

    private BigDecimal amount;

    public String groupKey() {

    return this.id + "_" + this.currency;

    }

    public Foo merge(Foo foo) {

    return new Foo(this.id, this.currency, this.amount.add(foo.getAmount()));

    }

    }

    结合之前的groupKey的写法,现在我们这个分类代码就可以写为

    fooList.stream()

    .collect(Collectors.groupingBy(Foo::groupKey, Collectors.reducing(Foo::merge)));

    看似现在可以了,其实还不行,因为此时返回的map的格式其实是Map>

    为啥map的value是Optional呢,其实主要就是因为我们使用了reducing的一个参数的方法,只是指明了如何合并多个对象,但是万一这个stream是空的,所以reducing对应一个参数的方法返回的就是Optional了

    但是我们是先分类,然后再相同类中做reducing,所以只要有分类,reducing一定不会为空,所以这个Optional一定是有值的,那么我们是可以直接get出来的,不需要Optional的保护

    相同于我们做完了reducing操作之后,还需要再做一个get操作,那这个对应stream的api当然就要用Collectors.collectingAndThen方法了

    从方法名就可以看得出来,这个方法就是先收集然后再做其他操作,跟我们的需求就是吻合的,看方法签名

    collectingAndThen(Collector downstream, Function finisher)

    也是两个参数,第一个参数就是如何收集Collector,第二个就是转换的Function

    根据我们之间的思考,第一个Collector参数就是Collectors.reducing(Foo::merge),那第二个参数Function显然也是我们之前说的get,也就是Optional::get

    于是我们分类的代码就可以变为

    fooList.stream()

    .collect(Collectors.groupingBy(

    Foo::groupKey,

    Collectors.collectingAndThen(

    Collectors.reducing(Foo::merge),

    Optional::get)))

    此时最终返回的就是Map,因为最终我们要的只是里面的values,所以我们再加上map的values()方法即可

    Collection values = fooList.stream()

    .collect(Collectors.groupingBy(

    Foo::groupKey,

    Collectors.collectingAndThen(

    Collectors.reducing(Foo::merge),

    Optional::get)))

    .values();

    但是注意此时返回的是Collection,不是List,如果题主不纠结这个的话,这样就可以了,但是非要转换为List只有不用values()方法而是再次循环一次Map

    List values = fooList.stream()

    .collect(Collectors.groupingBy(

    Foo::groupKey,

    Collectors.collectingAndThen(

    Collectors.reducing(Foo::merge),

    Optional::get)))

    .entrySet()

    .stream()

    .map(Map.Entry::getValue)

    .collect(Collectors.toList());

    所以总结一下答案:

    基础Foo类

    @Getter

    @Setter

    @AllArgsConstructor

    public class Foo {

    private String id;

    private String currency;

    private BigDecimal amount;

    public String groupKey() {

    return this.id + "_" + this.currency;

    }

    public Foo merge(Foo foo) {

    return new Foo(this.id, this.currency, this.amount.add(foo.getAmount()));

    }

    }

    1. 多出一次循环的方案(groupingBy+collectingAndThen+reducing)

    List values = fooList.stream()

    .collect(Collectors.groupingBy(

    Foo::groupKey,

    Collectors.collectingAndThen(

    Collectors.reducing(Foo::merge),

    Optional::get)))

    .entrySet()

    .stream()

    .map(Map.Entry::getValue)

    .collect(Collectors.toList());

    2. 只有一次循环的方案(定制Collector)

    因为上一个方案各种groupingBy+collectingAndThen+reducing其实他们返回的都是一个Collector,由于jdk给的Collector实现不一定完全满足我们的需求,所以不用jdk自带的,我们定制一个Collector也是可以的,之前也小写了一个文章Java8 collector接口的定制实现介绍,可以去看看,看完了再理解我写的,你会发现其实这种方案也挺简单的

    public class FooCollectorImpl implements Collector, List> {

    private Map map = new HashMap<>();

    @Override

    public Supplier> supplier() {

    return ArrayList::new;

    }

    @Override

    public BiConsumer, Foo> accumulator() {

    return (fooList, foo) -> {

    String key = foo.groupKey();

    Integer index = map.get(key);

    if (index == null) {

    fooList.add(foo);

    map.put(key, fooList.size() - 1);

    }else {

    Foo innerFoo = fooList.get(index);

    innerFoo = innerFoo.merge(foo);

    fooList.add(index, innerFoo);

    }

    };

    }

    @Override

    public BinaryOperator> combiner() {

    return (fooList, fooList2) -> fooList;

    }

    @Override

    public Function, List> finisher() {

    return Function.identity();

    }

    @Override

    public Set characteristics() {

    return Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.IDENTITY_FINISH));

    }

    }

    因为定制的Collector已经把很多逻辑实现了,所以调用的时候显得非常简单

    List values = fooList.stream().collect(new FooCollectorImpl());

    以上,仅供参考~╭( ̄▽ ̄)╯

    展开全文
  • // 创建几个对象放在list集合中 List collect1 = list.stream() // 根据name进行分组 .collect(Collectors.groupingBy(Good::getId)) .entrySet() .stream() .map(entry -> { int key = entry.getKey(); List value...

    直接代码:上面代码是int,下面是bigDecimal

    public class StreamTest {
        public static void main(String[] args) {
    
            List<Good> list = new ArrayList<>();
            Good g1 = new Good(1,"x",1);
            Good g2 = new Good(2,"x",1);
            Good g3 = new Good(1,"x",2);
            Good g4 = new Good(3,"y",8);
            list.add(g1);
            list.add(g2);
            list.add(g3);
            list.add(g4);
            // 创建几个对象放在list集合中
    
            List<Good> collect1 = list.stream()
                    // 根据name进行分组
                    .collect(Collectors.groupingBy(Good::getId))
                    .entrySet()
                    .stream()
                    .map(entry -> {
                        int key = entry.getKey();
                        List<Good> value = entry.getValue();
                        Integer sum = value.stream().mapToInt(Good::getTotal).sum();
                        return new Good(key,sum);
                    })
                    // 根据total倒序排序
    //                .sorted(Comparator.comparing(Good::getTotal).reversed())
                    .collect(Collectors.toList());
            System.out.println(collect1.toString());
        }
    }
    
    
    @Data
    @AllArgsConstructor
    class Good {
        private int id;
        private String name;
        private int total;
    
        public Good(int id, int total) {
            this.id = id;
            this.total = total;
        }
    }

    结果:

    [Good(id=1, name=null, total=3), Good(id=2, name=null, total=1), Good(id=3, name=null, total=8)]
    
    BigDecimal:
    package com.ali99.java.test.stream;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    
    import java.math.BigDecimal;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.stream.Collectors;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            List<Good> list = new ArrayList<>();
            Good g1 = new Good(1,"x",new BigDecimal(1));
            Good g2 = new Good(2,"x",new BigDecimal(1));
            Good g3 = new Good(1,"x",new BigDecimal(2));
            Good g4 = new Good(3,"y",new BigDecimal(8));
            list.add(g1);
            list.add(g2);
            list.add(g3);
            list.add(g4);
            // 创建几个对象放在list集合中
    
            List<Good> collect1 = list.stream()
                    // 根据name进行分组
                    .collect(Collectors.groupingBy(Good::getId))
                    .entrySet()
                    .stream()
                    .map(entry -> {
                        int key = entry.getKey();
                        List<Good> value = entry.getValue();
                        BigDecimal sum = value.stream().map(Good::getTotal).reduce(BigDecimal.ZERO,BigDecimal::add);
                        return new Good(key,sum);
                    })
                    // 根据total倒序排序
    //                .sorted(Comparator.comparing(Good::getTotal).reversed())
                    .collect(Collectors.toList());
            System.out.println(collect1.toString());
        }
    }
    @Data
    @AllArgsConstructor
    class Good {
        private int id;
        private String name;
        private BigDecimal total;
    
        public Good(int id, BigDecimal total) {
            this.id = id;
            this.total = total;
        }
    }
    

    结果一样

    展开全文
  • 项目中很多地方都会用到分组,提到分组,最简单的就是用java8的stream,但是有些条件下(比方说我,今天)用的java7....fuck..java8用起来比较方便根据普通单个字段//假设传入一个非空订单集合List orderList;//想要按照...

    项目中很多地方都会用到分组,提到分组,最简单的就是用java8的stream,但是有些条件下(比方说我,今天)用的java7....fuck..

    java8用起来比较方便

    根据普通单个字段

    //假设传入一个非空订单集合

    List orderList;

    //想要按照订单号分组

    Map> collect = orderList.stream()

    .collect(Collectors.groupingBy(t -> t.getTradeNo()));

    根据多个字段

    //假设传入一个非空订单集合,想要根据订单号和userId进行分组

    @Data

    @AllArgsConstructor

    @EqualsAndHashCode

    class UserTrade{

    private String userId;

    private String tradeNo

    }

    List orderList;

    //分组

    Map> collect = orderList.stream().

    collect(Collectors.groupingBy(new Function() {

    @Override

    public UserTrade apply(BaseOrder baseOrder) {

    return new UserTrade(baseOrder.getUserId(), baseOrder.getTradeNo());

    }

    }));

    java7

    核心:核心用到的是guava的LinkedListMultimap类.此类可以针对单个key,放多个value,这些value会组成一个list

    //假设传入一个非空订单集合,想要根据订单号和userId进行分组

    @Data

    @AllArgsConstructor

    @EqualsAndHashCode

    class UserTrade{

    private String userId;

    private String tradeNo

    }

    //分组

    List orderList;

    LinkedListMultimap multimap = LinkedListMultimap.create();

    for(BaseOrder baseOrder:orderList){

    multimap.put(new UserTrade(baseOrder.getUserId(),baseOrder.getTradeNo()),baseOrder);

    }

    List orders = multimap.get(new UserTrade("123","123"))

    以上是基于java8和java7的两种不同的分组方式

    展开全文
  • 业务场景:有一批节点,每个节点的字段是是一样的,如下:uid,cmmdtyCode,supplierCode。要求统计各商户下各个cmmdtyCode出现了多少次。样例数据如下:[{"uid":"127437864373237009","cmmdtyCode":" ...

    业务场景:

    有一批节点,每个节点的字段是是一样的,如下:uid,cmmdtyCode,supplierCode。要求统计各商户下各个cmmdtyCode出现了多少次。样例数据如下:

    [

    {

    "uid":"127437864373237009",

    "cmmdtyCode":" 000000000659869748",

    "supplierCode":" 0070113914"

    },

    {

    "uid":"127437864373237010",

    "cmmdtyCode":" 000000000659869748",

    "supplierCode": " 0070113914"

    },

    {

    "uid":”127437864373237011”,

    "cmmdtyCode":" 000000000659869749",

    "supplierCode":" 0070113914"

    },

    {

    "uid”:”127437864373237012”,

    "cmmdtyCode":" 000000000659869748",

    "supplierCode": "0070113915"

    }

    ]

    预期输出:supplierCode:cmmdtyCode=商品出现次数

    实现方法

    1)环境说明

    本例jdk版本为1.7,代码在testng里面执行

    2)数据准备

    将前面的样例数据以List>的格式存储起来,代码如下:

    import java.util.List;

    import java.util.Map;

    import org.powermock.modules.testng.PowerMockTestCase;

    import org.testng.annotations.BeforeMethod;

    import com.beust.jcommander.internal.Lists;

    import com.google.common.collect.Maps;

    public class TestJ2 extends PowerMockTestCase {

    private List> params = Lists.newArrayList();

    @BeforeMethod

    public void initMethod() {

    Map item = Maps.newHashMap();

    item.put("uid", "127437864373237009");

    item.put("cmmdtyCode", "000000000659869748");

    item.put("supplierCode", "0070113914");

    params.add(item);

    Map item2 = Maps.newHashMap();

    item2.put("uid", "127437864373237010");

    item2.put("cmmdtyCode", "000000000659869748");

    item2.put("supplierCode", "0070113914");

    params.add(item2);

    Map item3 = Maps.newHashMap();

    item3.put("uid", "127437864373237011");

    item3.put("cmmdtyCode", "000000000659869749");

    item3.put("supplierCode", "0070113914");

    params.add(item3);

    Map item4 = Maps.newHashMap();

    item4.put("uid", "127437864373237012");

    item4.put("cmmdtyCode", "000000000659869748");

    item4.put("supplierCode", "0070113915");

    params.add(item4);

    }

    }

    3)实现方法1

    // 一般计算方法

    @Test

    public void execute() {

    // 每个商户下,不同商品出现的次数

    Map numMap = Maps.newHashMap();

    for (Map item : params) {

    Integer num = MapUtils.getInteger(numMap, getKey(item));

    if (num == null) {

    num = 1;

    } else {

    num += 1;

    }

    numMap.put(getKey(item), num);

    }

    printResult(numMap);

    }

    // 拼接业务主键

    private String getKey(Map item) {

    return MapUtils.getString(item, "supplierCode") + ":" + MapUtils.getString(item, "cmmdtyCode");

    }

    // 打印计算结果

    private void printResult(Map numMap) {

    for (Map.Entry entry : numMap.entrySet()) {

    System.out.println(entry.getKey() + "=" + entry.getValue());

    }

    }

    输出结果:

    0070113914:000000000659869748=2

    0070113914:000000000659869749=1

    0070113915:000000000659869748=1

    耗时:8ms

    4)实现方法2

    // 改进计算方法

    /**

    * 在jdk1.7(含)以下的版本中,普通Map类没有putIfAbsent,只有ConcurrentMap的子类才有,jdk8(含)之后,普通类也提供了该方法

    * 由于作者本人机器使用的是JDK1.7,故使用ConcurrentMap类进行演示,实际上,在单线程计算中,普通map类的效率要高于ConcurrentMap

    */

    @Test

    public void execute2() {

    ConcurrentMap numMap = Maps.newConcurrentMap();

    for (Map item : params) {

    // 如果集合中不包括key,则写入默认值1,并返回null;否则直接返回集合中key对应的value对象的引用

    AtomicInteger oldValue = numMap.putIfAbsent(getKey(item), new AtomicInteger(1));

    if (oldValue != null) {

    // 对象数值+1

    oldValue.incrementAndGet();// 利用map存储的是对象的引用,直接对象的值,不需要重新写回map

    }

    }

    printResult(numMap);

    }

    // 拼接业务主键

    private String getKey(Map item) {

    return MapUtils.getString(item, "supplierCode") + ":" + MapUtils.getString(item, "cmmdtyCode");

    }

    private void printResult(Map numMap) {

    for (Map.Entry entry : numMap.entrySet()) {

    System.out.println(entry.getKey() + "=" + entry.getValue());

    }

    }

    输出结果:

    0070113914:000000000659869749=1

    0070113914:000000000659869748=2

    0070113915:000000000659869748=1

    耗时:11ms

    5)实现方法3

    // 分组计算方法

    @Test

    public void execute3() {

    HashMultimap> group = HashMultimap.create();

    // 将所有节点分组,cmmdtyCode和supplierCode相同的item分入一组

    for (Map item : params) {

    group.put(getKey(item), item);

    }

    Map numMap = Maps.newHashMap();

    // 统计每一组的元素个数

    for (String key : group.keySet()) {

    numMap.put(key, group.get(key).size());

    }

    printResult(numMap);

    }

    // 拼接业务主键

    private String getKey(Map item) {

    return MapUtils.getString(item, "supplierCode") + ":" + MapUtils.getString(item, "cmmdtyCode");

    }

    // 打印计算结果

    private void printResult(Map numMap) {

    for (Map.Entry entry : numMap.entrySet()) {

    System.out.println(entry.getKey() + "=" + entry.getValue());

    }

    }

    该方法引入了google API,具体引用路径为:

    import com.google.common.collect.HashMultimap;

    输出结果:

    0070113914:000000000659869748=2

    0070113914:000000000659869749=1

    0070113915:000000000659869748=1

    耗时:43ms

    6)增加测试数据

    @BeforeMethod

    public void initMethod() {

    for (int i = 0; i < 100; i++) {

    Map itemR = Maps.newHashMap();

    itemR.put("uid", i);

    itemR.put("cmmdtyCode", "000000000659869748");

    itemR.put("supplierCode", "0070113915");

    params.add(itemR);

    }

    for (int j = 0; j < 100; j++) {

    Map itemR = Maps.newHashMap();

    itemR.put("uid", j);

    itemR.put("cmmdtyCode", "000000000659869749");

    itemR.put("supplierCode", "0070113915");

    params.add(itemR);

    }

    for (int j = 0; j < 100; j++) {

    Map itemR = Maps.newHashMap();

    itemR.put("uid", j);

    itemR.put("cmmdtyCode", "000000000659869748");

    itemR.put("supplierCode", "0070113914");

    params.add(itemR);

    }

    }

    耗时如下:

    数据量

    10

    100

    1000

    方法1耗时

    11ms

    8ms

    19ms

    方法2耗时

    9ms

    11ms

    18ms

    方法3耗时

    45ms

    40ms

    59ms

    总结:

    方法1耗时最少,且较为常见,推荐

    展开全文
  • 我找到了通过POJO中的某些字段名称对对象进行分组的代码。以下是该代码:public class Temp {static class Person {private String name;private int age;private long salary;Person(String name, int age, long ...
  • 项目中遇到了需要对list进行分组的场景,根据List中entity的某字段或者多个字段进行分组,形成Map<String,List>,然后根据map进行相关的业务操作。 之前考虑自己遍历list进行处理,总感觉还有更便捷的方..
  • java8 多字段分组+count

    2021-08-19 13:12:57
    java8 多字段分组+countMysql分组计数sql语句执行结果java8分组实现 Mysql分组计数 sql语句 SELECT follow_user,action_clue_type,COUNT(DISTINCT clue_id) followClueNum,GROUP_CONCAT(DISTINCT clue_id) FROM crm_...
  • 如何将List中存放的实体按照某个字段进行分组呢?来看看下面的例子,假如实体中有个字段叫批次号,我们将具有相同批次号的实体放在一起,那么怎么实现呢?看下面的代码:可以定义个Map,Map的key用于存放异常批次号...
  • 将对象 List 根据的某一字段分组,使用 Java8 stream 的 filter、sorted 操作实现非常便捷。 示例代码如下: Map<String,List<Object>> objectMap = objectList.stream().collect(Collectors.grouping...
  • 将对象 List 根据的某一字段生成 Map,使用 Java8 stream 的 toMap 操作实现非常便捷。 1、转换成对象某一字段与对象的Map 示例代码如下: Map, Object> map = objectList.stream().collect(Collectors.toMap(Object...
  • 以产品类型和国家两个字段为关键字,进行计数。比如中国的电脑有多少种,韩国的洗衣机有多少种? 产品类型 国家 分类 电脑 中国 台式 洗衣机 ...
  • 你有两个班:Account: number: String, balance: LongTransaction: uuid: String, sum: Long, account: Account这两个类都具有相应名称的所有字段的getter(getNumber(),getSum(),getAccount()等).我需要计算每个帐户...
  • LIst字段分组为Map

    2021-08-16 17:30:50
    Java8 根据一个字段进行分组 https://blog.csdn.net/Y1H2L/article/details/105335072 https://blog.csdn.net/Y1H2L/article/details/105335072
  • 第一次回答,希望能帮到你User类:class User {String name;String phone;String address;Long scope;public User(String name, String phone, String address) {this.name = name;this.phone = phone;...
  • by 'createdOn' in desc order so, the expected result is _id | messageId | chainId | createOn 3 | 3 | A | 225 5 | 5 | C | 228 6 | 6 | B | 300 We are using spring-data in our java application....
  • Java | 字段(Field)

    2021-03-29 14:52:49
    字段(Field),是 Java 编程语言中类的一个成员,主要用来存储对象的状态(如同某些编程语言中的变量),所以有时也可称为成员字段或成员变量(Member Variable)。
  • import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; public class ...
  • 前言本文将展示groupingBy收集器的多个示例,阅读本文需要先准备Java Stream和Java收集器Collector的知识。一、GroupingBy收集器Java8的Stream API允许我们以声明的方式来处理数据集合。静态工厂方法:Collectors....
  • 之前写接口文档比较痛苦,每个字段都是一个一个的对写对应的描述,后来我写了个小玩意,有了这个就不头疼了,分享一哈; 直接复制到自己的项目中就可以用了,关于@Slf4j 注解,有的小伙伴不需要可以去掉(同时也要...
  • //原有list(根据第二个字段:userName和第四个字段:age 统计重复的记录数) //jdk8的方法统计个数: Map> map = list.stream().collect(Collectors.groupingBy(User::getUserName,Collectors.groupingBy(User::getAge,...
  • 根据 单个字段、多个字段,分组求和示意图:1、根据 单个字段,分组求和:根据2019这个字段,计算一个list集合里,同属于2019的某个字段累加和2、根据 多个字段,分组求和:(1)先根据2019这个字段,再根据1这个字段...
  • Here is my List fooListclass Foo {private String name;private int code;private int account;private int time;private String others;... constructor, getters &... setters}e.g.(all the value of account h...
  • 与之相似的也有商品的分类,部分所下属的部门列表 均可参考此逻辑实现 实现方法 首先创建数据库表,图中表仅为举例说明 id 字段为唯一值,为当前记录的唯一标识 parent_id为父节点id,此属性是起到 链接其他节点的...
  • import java.util.concurrent.ConcurrentHashMap; import java.util.function.Function; import java.util.function.Predicate; import java.util.ArrayList; import java.util.List; import java
  • 这里写自定义目录标题java8特性(stream)基本思路 java8特性(stream) 现在有个业务需求,就是根据对象某个属性分组并导出到excel 数据示例 类型 c d A 12 13 A 14 15 B 16 17 B 18 19 类似这种...
  • Java中sql的分类

    2021-01-04 20:50:56
    基础查询 多个字段查询 select 字段名1,字段名2... from 表名; 去除重复,关键字distinct放select后面 select distinct 字段名1,字段名2... from 表名; 起别名,字段名 后写关键字 as 或省略as 直接用空格。 ...
  • java对集合中的某个类的属性按首字母分组排序(可直接使用)直接上代码一、导入jar包com.belerwebpinyin4j2.5.0PinYinUtil工具类import net.sourceforge.pinyin4j.PinyinHelper;import ...
  • Java 将List中的实体类按照某个字段进行分组并存放至Map中操作1、JDK1.8之前:代码2、JDK1.8 新特性实现:代码 1、JDK1.8之前: 假设有实体类User,里面有字段id,我们将相同id的User进行分组,并存放在Map中。...
  • php的二维数组根据某个字段去重,在这默认为二维数组的结构是一样的,现在根据二维数组里的id字段去重,把id相同的重复的元素去掉/*** 二维数组根据某个字段去重* @param array $array 二维数组* @para array 去重后...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 89,009
精华内容 35,603
关键字:

java根据字段分类

java 订阅