Java List 转map,分组,排序,去重

已于 2024-10-16 17:27:32 修改
阅读量468 收藏
点赞数 3
文章标签： java list 开发语言
于 2024-08-22 19:49:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wdquan19851029/article/details/141436389
版权

目录

1.List 排序

1.排序字段无null值

2.排序字段有null值

3.多字段排序

2.List转Map

1.List转成Map,object>

2.List转成Map,string>

3.List>转成Map>,map

4.List>转成Map,object>

5.List>转成Map>,map

6.List>转成Map,string>

3.List分组

方法一：分组的键（key）不为空

方法二：分组的键（key）为空 

方法三(不常用)：不常用的方式

4.去重

1.根据全部字段去重

2.根据某个字段去重

日常工作中经常需要用到对List集合的分组、排序、转Map等操作，每次都会忘记，然后去网上查，费时又费力，不如自己好好总结一下，提升工作效率和减少bug率。

1.List 排序

参考我写的另外一篇文章，写得更详细： Java8 对象List 排序_java8 list对象排序-CSDN博客 

1.排序字段无null值

Student User{
  private String name;
  private int age;
}

List<User> list = Lists.newArrayList(new User("lao_wang", 21), new User("lao_wang", 22));

排序方式：

List<User> nList = list.stream()
      .sorted(Comparator.comparing(User::getName))
      .collect(Collectors.toList());

2.排序字段有null值

Student User{
  private String name;
  private int age;
}

List<User> list = Lists.newArrayList(new User(null, 23), new User("lao_wang", 21), new User("lao_wang", 22));

排序方式：

List<User> nList = list.stream().sorted(
    Comparator.comparing(User::getName, Comparator.nullsFirst(String::compareTo)))
    .collect(Collectors.toList());
  • Comparator.nullsFirst: 排序字段为null的对象放在排序后的List最前面 
  • Comparator.nullsLast: 排序字段为null的对象放在排序后的List最后面

3.多字段排序

List按照多个字段排序，同步包含了处理null的功能。

List<User> detailEntityList = list.stream().sorted(Comparator.comparing(User::getName,Comparator.nullsFirst(String::compareTo))
 .thenComparing(User::getAge,Comparator.nullsFirst(String::compareTo))).collect(Collectors.toList());

2.List转Map

实体类：

public class Person {
    private String name;
    private String address;

    public Person(String name, String address) {
        this.name = name;
        this.address = address;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

1.List转成Map<String,Object>

List<Person> list = new ArrayList<>();
Person person1 = new Person("熊大","森林第一个小屋");
Person person2 = new Person("熊二","森林第二个小屋");
Person person3 = new Person("光头强","森林第三个小屋");
Person person4 = new Person("熊大","森林第四个小屋");
list.add(person1);
list.add(person2);
list.add(person3);
list.add(person4);
Map<String,Person> map =  list.stream().collect(Collectors.toMap(Person::getName,each->each,(value1, value2) -> value1));
System.out.println(JSON.toJSONString(map));

结果：2个name为熊大，只保留了第一个，因为Map的key是不能重复的

{“光头强”:{“address”:“森林第三个小屋”,“name”:“光头强”},

“熊大”:{“address”:“森林第一个小屋”,“name”:“熊大”},

“熊二”:{“address”:“森林第二个小屋”,“name”:“熊二”}} 

2.List转成Map<String,String>

List<Person> list = new ArrayList<>();
Person person1 = new Person("熊大","森林第一个小屋");
Person person2 = new Person("熊二","森林第二个小屋");
Person person3 = new Person("光头强","森林第三个小屋");
Person person4 = new Person("熊大","森林第四个小屋");
list.add(person1);
list.add(person2);
list.add(person3);
list.add(person4);
Map<String,String> map =  list.stream().collect(Collectors.toMap(Person::getName,Person::getAddress,(value1, value2) -> value1));
System.out.println(JSON.toJSONString(map));

结果：

{“光头强”:“森林第三个小屋”,

“熊大”:“森林第一个小屋”,

“熊二”:“森林第二个小屋”} 

3.List<Map<String,Object>>转成Map<String,Map<String,Object>>

List<Map<String,Object>> list = new ArrayList<>();
Person person1 = new Person("熊大","森林第一个小屋");
Person person2 = new Person("熊二","森林第二个小屋");
Person person3 = new Person("光头强","森林第三个小屋");
Map<String,Object> map1 = new HashMap<>();
map1.put("id","1");
map1.put("person",person1);
Map<String,Object> map2 = new HashMap<>();
map2.put("id","2");
map2.put("person",person2);
Map<String,Object> map3 = new HashMap<>();
map3.put("id","3");
map3.put("person",person3);
list.add(map1);
list.add(map2);
list.add(map3);
Map<String,Map<String,Object>> map = list.stream().collect(Collectors.toMap(each->Objects.toString(each.get("id"),""),each->each,(key1,key2)->key1));
System.out.println(JSON.toJSONString(map));

 控制台打印日志:

{“1”:{“person”:{“address”:“森林第一个小屋”,“name”:“熊大”},“id”:“1”},

“2”:{“person”:{“address”:“森林第二个小屋”,“name”:“熊二”},“id”:“2”},

“3”:{“person”:{“address”:“森林第三个小屋”,“name”:“光头强”},“id”:“3”}}

4.List<Map<String,Object>>转成Map<String,Object>

List<Map<String,Object>> list = new ArrayList<>();
Person person1 = new Person("熊大","森林第一个小屋");
Person person2 = new Person("熊二","森林第二个小屋");
Person person3 = new Person("光头强","森林第三个小屋");
Map<String,Object> map1 = new HashMap<>();
map1.put("id","1");
map1.put("person",person1);
Map<String,Object> map2 = new HashMap<>();
map2.put("id","2");
map2.put("person",person2);
Map<String,Object> map3 = new HashMap<>();
map3.put("id","3");
map3.put("person",person3);
list.add(map1);
list.add(map2);
list.add(map3);
Map<String,Object> map = list.stream().collect(Collectors.toMap(each->Objects.toString(each.get("id"),""),each->each.get("person"),(key1,key2)->key1));
System.out.println(JSON.toJSONString(map));

结果：

{“1”:{“address”:“森林第一个小屋”,“name”:“熊大”},

“2”:{“address”:“森林第二个小屋”,“name”:“熊二”},

“3”:{“address”:“森林第三个小屋”,“name”:“光头强”}} 

5.List<Map<String,String>>转成Map<String,Map<String,String>>

List<Map<String,String>> list = new ArrayList<>();
Map<String,String> map1 = new HashMap<>();
map1.put("id","1");
map1.put("name","熊大");
map1.put("address","森林第一个小屋");
Map<String,String> map2 = new HashMap<>();
map2.put("id","2");
map2.put("name","熊二");
map2.put("address","森林第二个小屋");
Map<String,String> map3 = new HashMap<>();
map3.put("id","3");
map3.put("name","光头强");
map3.put("address","森林第三个小屋");
list.add(map1);
list.add(map2);
list.add(map3);
Map<String,Map<String,String>> map = list.stream().collect(Collectors.toMap(each->each.get("id"),each->each,(key1,key2)->key1));
System.out.println(JSON.toJSONString(map));

结果：

{“1”:{“address”:“森林第一个小屋”,“name”:“熊大”,“id”:“1”},

“2”:{“address”:“森林第二个小屋”,“name”:“熊二”,“id”:“2”},

“3”:{“address”:“森林第三个小屋”,“name”:“光头强”,“id”:“3”}} 

6.List<Map<String,String>>转成Map<String,String>

List<Map<String,String>> list = new ArrayList<>();
Map<String,String> map1 = new HashMap<>();
map1.put("id","1");
map1.put("name","熊大");
map1.put("address","森林第一个小屋");
Map<String,String> map2 = new HashMap<>();
map2.put("id","2");
map2.put("name","熊二");
map2.put("address","森林第二个小屋");
Map<String,String> map3 = new HashMap<>();
map3.put("id","3");
map3.put("name","光头强");
map3.put("address","森林第三个小屋");
list.add(map1);
list.add(map2);
list.add(map3);
Map<String,String> map = list.stream().collect(Collectors.toMap(each->each.get("id"),each->each.get("name"),(key1,key2)->key1));
System.out.println(JSON.toJSONString(map));

结果：

{“1”:“熊大”,“2”:“熊二”,“3”:“光头强”}

3.List分组

List 转成Map<String,List>

方法一：分组的键（key）不为空
List<Person> list = new ArrayList<>();
Person person1 = new Person("熊大","森林第一个小屋");
Person person2 = new Person("熊二","森林第二个小屋");
Person person3 = new Person("光头强","森林第三个小屋");
Person person4 = new Person("熊大","森林第四个小屋");
list.add(person1);
list.add(person2);
list.add(person3);
list.add(person4);
Map<String, List<Person>> map = list.stream().collect(Collectors.groupingBy(Person::getName));
System.out.println(JSON.toJSONString(map));

 控制台打印日志:

{“光头强”:[{“address”:“森林第三个小屋”,“name”:“光头强”}],“熊大”:[{“address”:“森林第一个小屋”,“name”:“熊大”},{“address”:“森林第四个小屋”,“name”:“熊大”}],“熊二”:[{“address”:“森林第二个小屋”,“name”:“熊二”}]}

方法二：分组的键（key）为空 
List<Person> list = new ArrayList<>();
Person person1 = new Person("熊大","森林第一个小屋");
Person person2 = new Person("熊二","森林第二个小屋");
Person person3 = new Person("光头强","森林第三个小屋");
Person person4 = new Person("熊大","森林第四个小屋");
list.add(person1);
list.add(person2);
list.add(person3);
list.add(person4);
Map<String, List<Person>> map = list.stream().collect(Collectors.groupingBy(item -> item.getName() == null ? "null_key" : item.getName()));
System.out.println(JSON.toJSONString(map));

或者使用Optional

List<Person> list = new ArrayList<>();
Person person1 = new Person("熊大","森林第一个小屋");
Person person2 = new Person("熊二","森林第二个小屋");
Person person3 = new Person("光头强","森林第三个小屋");
Person person4 = new Person("熊大","森林第四个小屋");
list.add(person1);
list.add(person2);
list.add(person3);
list.add(person4);
Map<String, List<Person>> map = list.stream().collect(Collectors.groupingBy(x -> Optional.ofNullable(x.getName()).orElse("null_key")));
System.out.println(JSON.toJSONString(map));
方法三(不常用)：不常用的方式
List<Person> list = new ArrayList<>();
Person person1 = new Person("熊大","森林第一个小屋");
Person person2 = new Person("熊二","森林第二个小屋");
Person person3 = new Person("光头强","森林第三个小屋");
Person person4 = new Person("熊大","森林第四个小屋");
list.add(person1);
list.add(person2);
list.add(person3);
list.add(person4);
Map<String,List<Person>> map =  list.stream().collect(Collectors.toMap(Person::getName,each->Collections.singletonList(each),(value1, value2) -> {
        List<Person> union = new ArrayList<>(value1);
        union.addAll(value2);
        return union;
    }));
System.out.println(JSON.toJSONString(map));

 结果：

{“光头强”:[{“address”:“森林第三个小屋”,“name”:“光头强”}],“熊大”:[{“address”:“森林第一个小屋”,“name”:“熊大”},{“address”:“森林第四个小屋”,“name”:“熊大”}],“熊二”:[{“address”:“森林第二个小屋”,“name”:“熊二”}]}

4.去重

1.根据全部字段去重

 // 去重
List<Dictionaries> dictionaries = list.stream().distinct().collect(Collectors.toList());
            );

2.根据某个字段去重

// 根据名称去重
List<Dictionaries> dictionaries = list.stream().collect(
                    Collectors.collectingAndThen(
                            Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Work::getRepairDepart))), ArrayList::new)

 

 

困知勉行1985
关注
Java8 快速实现List转map 、分组、过滤等操作
2401_83916283的博客
04-02 793
//List 以ID分组 MapMap groupBy = appleList.stream().collect(Collectors.groupingBy(Apple::getId));System.err.println(“groupBy:”+groupBy);{1=[Apple{id=1, name=‘苹果1’, money=3.25, num=10}, Apple{id=1, name=‘苹果2’, money=1.35, num=20}],
List数据转Map数据并进行分组排序
weixin_33831196的博客
09-14 1080
　　利用JAVA 8的特性实现List数据转Map数据并进行分组排序。 1、准备数据 List<Map<String, Object>> list = new ArrayList<>(); Map<String, Object> m1 = new HashMap<>(); m1....
java8特性：list转Map并排序
JesJiang的博客
11-23 1万+
初始代码 public Map&amp;lt;String,List&amp;lt;RgwstBean&amp;gt;&amp;gt; getMap(List&amp;lt;RgwstBean&amp;gt; lists){ Map&amp;lt;String,List&amp;lt;RgwstBean&amp;gt;&amp;gt; map = new TreeMap&amp;lt;String,List&am
list转map(根据某个或多个属性分组)
天青色等烟雨
11-20 2379
List转Map List转Map
Java8 流使用Collectors.mapping对集合进行映射
张紫娃的博客
04-12 3569
Java8 List 转 Map
java list分组成map
做一个有思想的技术人
08-16 4184
将List集合分成分组成map在工作中常常会遇到
将list转成map，并按照另外一个list排序
qacjava的博客
08-27 2487
需求说明：A list假如是一串编码， 通过in的sql语句可以查到一连串另外的数据（List&lt;B&gt; = select (A list); ），但查出来的数据(List&lt;B&gt;)是按数据库的自然顺序进行排序的，无法与原来的list(A List)对应，也就是说 无法做到A、B、C进去a、b、c出来，而是变成其他顺序出来，所以需要对出来的数据进行重新排序。   环境：j...
Java实现对两个List快速去重并排序操作示例
08-27
Java实现对两个List快速去重并排序操作示例 Java语言中，List类型的数据结构广泛应用于各个领域，但是在实际应用中，我们经常需要对List进行去重和排序操作以满足业务需求。因此，本文将详细介绍Java实现对两个...
Java中List集合对象去重及按属性去重的8种方法
09-08
【Java中List集合对象去重及按属性去重的8种方法】 在Java编程中，当我们处理包含重复元素的List时，有时需要去除其中的重复项。以下文章将详细介绍8种针对List集合对象去重的方法，包括基于对象整体以及按特定属性...
JAVA8 Stream流式编程的去重、过滤、映射(map)、分组、统计(sum、max、min、avg)、分页
最新发布
aplis的博客
08-13 916
Stream提供了两种类型的操作——中间操作和终端操作。中间操作用于链式调用，并可以有多个，而终端操作是触发计算的地方。Stream流的实现原理主要基于迭代器和函数式编程的思想。在内部迭代的过程中，流通过一系列操作进行链式处理，将每个元素传递给下一个操作，并最终生成结果。方法一核心代码：list = list.stream().filter(o -> o.getName()!= null).collect(在并行流的情况下，流将输入数据分成多个小块，分配给不同的线程并行处理。处理完后，再合并结果并返回。
List<map>多字段组合排序
02-14
List<map>,List<Map, Object>>,多字段组合排序。提供一个简易的思路，如果需要进行参考。
Java List返回Map List中文数字排序 List返回JSONString
weixin_45409897的博客
08-02 439
JAVA对List传入任意对象list和对应字段返回对应Map并且重排序(中文一二三四五六七八九十 排序)和返回对应字段list去重数据多层json
遍历list 分组求和_java8 stream List转map 、分组、过滤
weixin_39517400的博客
12-10 1353
来源：IT小白_Lhttps://blog.csdn.net/lu930124/article/details/77595585利用java8新特性，可以用简洁高效的代码来实现一些数据处理。定义1个Apple对象：publicclassApple{privateIntegerid;privateStringname;privateBigDecima...
Java8-对List转换Map、分组、求和、过滤
热门推荐
晏霖/胖虎的博客
03-16 1万+
前言 在java8之后我们list转map再也不用循环put到map了，我们用lambda表达式，使用stream可以一行代码解决，下面我来简单介绍list转map的几种方式，和转为map后对map进行分组、求和、过滤等操作。 正文 数据准备 我们准备一个ArrayList，故意让age有一对重复值 List&lt;User&gt; list = new ArrayList&lt;Us...
java list 分组_Java8 快速实现List转map 、分组、过滤等操作
weixin_39747615的博客
11-29 73
利用java8新特性，可以用简洁高效的代码来实现一些数据处理。定义1个Apple对象：public class Apple { private Integer id; private String name; private BigDecimal money; private Integer num; public Apple(Integer id, Str...
对list实现转map、过滤、分组、去重、最大最小等操作
程序员阿文
09-05 2226
对list实现转map、过滤、分组、去重、最大最小等操作准备工作（准备实体类和测试数据）一、List 转 Map (toMap)1. id 为 key, product 为 value2. id 为 key, product.name 为 value3. 如果集合中有重复的 key，会报错 Duplicate key; 可以用 (key1, key2) -> key1 来设置，如果有重复的key, 则保留key1, 舍弃key2。二、过滤 (filter)1. 过滤品牌为华为的产品2. 过滤价格大于8
Java Stream：List分组成Map或LinkedHashMap
shyの个人笔记
11-10 6071
List集合可以通过stream()进行分组，但是一般默认得到的是无序的map集合，那么如何分组成有序的LinkedHashMap集合呢，
java8中list转map并排序
05-18
假设你有一个`List`对象，其中包含`Person`对象，每个`Person`对象都有一个唯一的`id`属性和一个`name`属性。现在你想将这个`List`转换为一个`Map`，其中`id`属性作为键，`Person`对象本身作为值，并按照`name`属性对Map进行排序。可以按照如下方式实现： ```java List<Person> personList = ... // 假设这是你的Person对象列表 Map<Integer, Person> personMap = personList.stream() .collect(Collectors.toMap(Person::getId, Function.identity())) .entrySet().stream() .sorted(Map.Entry.comparingByValue(Comparator.comparing(Person::getName))) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new)); ``` 上述代码使用Java 8中的`Stream` API先将`List`转换为`Map`，然后使用`sorted`方法根据`Person`对象的`name`属性排序，并最终将结果收集到`LinkedHashMap`中以保留排序顺序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值