关于Map类型的List集合根据key值排序的方法

第一次写这个有点小激动，hhhhha，最近开发遇到这个需求；
原本是想这样写①，但是不行诶；
随后这样写②，好像可行，但是代码看起来有点不舒服；
强迫症严重，试着写个公共方法去调用。
(11.18更新了多重排序版本)

//方式一
List<Map<String, Object>> sortList = list1.stream()
.sorted(Comparator.comparing(x -> x.get("id")).reversed())
.collect(Collectors.toList());
//方式二
List<Map<String, Object>> sortList = list1.stream()
.sorted((o1, o2) -> Integer.compare(
Integer.parseInt(o1.get("id").toString()),
Integer.parseInt(o2.get("id").toString()))
).collect(Collectors.toList());

1.基于List的sort方法编写的排序

应该会有点局限性,各位根据自己的需求完善，考虑是int类型单独做比较，其他类型按字符串比较。

package com.sinoyd.util.utilsstream;

import java.math.BigDecimal;
import java.text.Collator;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
* 作者：xxx
* 创建时间：2019/10/22 9:14
* 版本：1.0
* 描述：排序扩展类
*/
public class SortUtil {
private static final Comparator<Object> CHINA_COMPARE = Collator.getInstance(Locale.CHINA);

/**
* map类型的集合排序,集合顺序中m1实则在m2之后,多重排序
*
* @param list   集合
* @param sortBy 排序的key值,如a+b-
*/
public static void listSort(List<Map> list, String sortBy) {
LinkedHashMap<String, Boolean> sort = getSortBy(sortBy);
list.sort((m1, m2) -> {
int compare = 0;
for (Map.Entry<String, Boolean> entry : sort.entrySet()) {
String key = entry.getKey();

if (entry.getValue()) {//是否倒序
compare = compare(m2.get(key), m1.get(key), -1, 1);
} else
compare = compare(m1.get(key), m2.get(key), 1, -1);

if (compare != 0) {
return compare;
}
}
return compare;
});
}

/**
* map类型的集合排序,集合顺序中m1实则在m2之后,只能单key值排序
*
* @param list 集合
* @param key  排序的key值
* @param isDesc 是否倒序
*/
public static void listSort(List<Map> list, Object key, boolean isDesc) {
if (isDesc)
list.sort((m1, m2) -> compare(m2.get(key), m1.get(key), -1, 1));//倒序
else
list.sort((m1, m2) -> compare(m1.get(key), m2.get(key), 1, -1));//正序
}

/**
* 处理排序机制
*
* @param sort 排序字符串 如a+b-
*/
private static LinkedHashMap<String, Boolean> getSortBy(String sort) {
String pattern = "[^+-][a-zA-z_]+[+-]*";
Pattern r = Pattern.compile(pattern);
Matcher m = r.matcher(sort);
LinkedHashMap<String, Boolean> map = new LinkedHashMap<>();
while (m.find()) {
String group = m.group();
map.put(group.replace("+", "").replace("-", "").trim(), group.contains("-"));
}

return map;
}

/**
* 当比较结果大于0位置不变,小于0位置互换,等于0似乎是比较其他东西
* 当两个比较值为都为空时,不改变所有空值的添加顺序 = 1
*
* @param r1 当o1为空时.是否交换位置;1不交换-1交换
* @param r2 当o2为空时.是否交换位置;1不交换-1交换
*/
private static int compare(Object o1, Object o2, int r1, int r2) {
if (o1 == null && o2 == null) {
return 1;
} else if (o2 == null) {
return r2;
} else if (o1 == null) {
return r1;
} else {
String s1 = o1.toString();
String s2 = o2.toString();
if (o1 instanceof Number && o2 instanceof Number) {
return new BigDecimal(s1).compareTo(new BigDecimal(s2));
}
return CHINA_COMPARE.compare(s1, s2);
}
}
}

上面的代码直接复制就好了，那开始测试吧

2.测试效果

public static void main(String[] args) {
List<Map> list = new ArrayList<>();
list.add(build(1.15, "额"));
list.add(build(1.24, "3.54"));
list.add(build(1.24, "9.11"));
list.add(build(null, "9.12"));
list.add(build(-2.54, "啊"));
list.add(build(2.22, "出"));
list.add(build(2.22, "的"));
list.add(build(-4.11, "个"));
list.add(build(4.12, "2"));
list.add(build(4.11, "1"));

//        SortUtil.listSort(list, "bb", true);
SortUtil.listSort(list, "aa-bb-");

System.out.println("aa顺序" + "  " + "bb顺序");
list.forEach(x -> {
System.out.print(x.get("aa"));
System.out.print("   ");
System.out.print(x.get("bb"));
System.out.println("");
});
}

private static Map<String, Object> build(Number a, String b) {
Map<String, Object> map = new HashMap<>();
map.put("aa", a);
map.put("bb", b);
return map;
}

emmmm，这样子还可以，考虑是将null一直放在最后面。希望对各位有所帮助，以上！

aa顺序  bb顺序
4.12   2
4.11   1
2.22   的
2.22   出
1.24   9.11
1.24   3.54
1.15   额
-2.54   啊
-4.11   个
null   9.12

后记，发现了点问题 已修改，另外如果key值基本变动少建议用定制dto去代替map来使用，再基于stream的Comparator类来实现排序，更可支持多排序。

• 点赞
• 收藏
• 分享
• 文章举报