在我们的统计中经常会有List<Map<String, Object>>格式的数据,但是我们需要对这种数据进行排序,我们可以使用Comparator撰写工具类对其排序
1.对List<Map<String, Object>>进行排序
对于需要对Map集合某一键值进行排序,可以自己撰写如下代码,对我们的List<Map<String, Object>>进行排序,得到排序好的List<Map<String, Object>>,只需要传入需要排序的list以及需要排序的字段,即可完成排序
/**
* @author wangli
* @create 2022-08-18 17:51
*/
public class SortUtil {
/**
* 对List<Map<String, Object>>中int类型的字段排序
* @param data 包含key为sort,value为desc,asc的map
* @param yList 需要排序的list
* @param type 需要排序的字段
* @return 返回排序后的List<Map<String, Object>>
*/
public static List<Map<String, Object>> sortMap(Map<String, Object> data, List<Map<String, Object>> yList, String type) {
if (Objects.equals(data.get("sort"), "asc")) {
yList.sort(Comparator.comparingInt(o -> Integer.parseInt(o.get(type).toString())));
return yList;
} else {
Collections.sort(yList, (o1, o2) -> Integer.parseInt(o2.get(type).toString()) - Integer.parseInt(o1.get(type).toString()));
}
return yList;
}
/**
* 对List<Map<String, Object>>中double类型的字段排序
* @param data 包含key为sort,value为desc,asc的map
* @param yList 需要排序的list
* @param type 需要排序的字段
* @return 返回排序后的List<Map<String, Object>>
*/
public static List<Map<String, Object>> sortDoubleMap(Map<String, Object> data, List<Map<String, Object>> yList, String type) {
if (Objects.equals(data.get("sort"), "asc")) {
yList.sort(Comparator.comparingDouble(o -> Double.parseDouble(o.get(type).toString())));
return yList;
} else {
Collections.sort(yList, (o1, o2) -> {
Double a = Double.parseDouble(o2.get(type).toString());
Double b = Double.parseDouble(o1.get(type).toString());
if (a > b) {
return 1;
}
return -1;
});
}
return yList;
}
}
创建测试方法,生成一些数据,对我们撰写的方法进行测试,测试demo如下
public class TestProject {
@Test
public void test1(){
ArrayList<Map<String, Object>> maps = new ArrayList<>();
for (int i = 0; i <3; i++) {
HashMap<String, Object> map = new HashMap<>();
map.put("count",i*2+1);
maps.add(map);
}
HashMap<String, Object> data = new HashMap<>();
data.put("sort","desc");
maps.stream().forEach(System.out::println);
List<Map<String, Object>> list = SortUtil.sortMap(data, maps, "count");
maps.stream().forEach(System.out::println);
}
}
排序结果打印如下
2.对List<List<String>>进行排序
/**
* @param data 输入需要排序的参数
* @param yList 需要排序的List<List<String>>
* @param s 需要过滤不排序的信息
* @param i list中需要排序的第几个字段
* @return 排序后的List<List<String>>
*/
public static List<List<String>> sortContainList(Map<String, Object> data, List<List<String>> yList,String s,int i) {
if (Objects.equals(data.get("sort"), "asc")) {
yList.sort(Comparator.comparingInt(o -> Integer.parseInt(o.get(i))));
return yList;
} else {
Collections.sort(yList, (o1, o2) -> {
if (o1.get(i).equals(s)||o2.get(i).equals(s)){
return 1;
}else {
return Integer.parseInt(o2.get(i)) - Integer.parseInt(o1.get(i));
}
});
}
return yList;
}
3.传入对象集合转换为List<Map<String,Object>>
我们在工作中有很多时候需要将List<User>转换为List<Map<String,Object>>这种格式的需求,所以我们可以调用如下方法,针对业务进行修改,完成转化过程。
/**
* 传入list对象转换为List<Map<String,Object>>
* @param list 传入对象集合
* @return 返回map集合
*/
public static List<Map<String,Object>> entityConvertMap(List<?> list){
List<Map<String,Object>> l = new LinkedList<>();
try {
for(Object t : list){
Map<String,Object> map = new HashMap<>();
Method[] methods = t.getClass().getMethods();
for (Method method : methods) {
if (method.getName().startsWith("get")) {
String name = method.getName().substring(3);
name = name.substring(0, 1).toLowerCase() + name.substring(1);
Object value = method.invoke(t);
if (value!=null&&!name.equals("version")&&!name.equals("class")){
map.put(name,value);
}
}
}
l.add(map);
}
} catch (Exception e) {
e.printStackTrace();
}
return l;
}
4.Map的value值排序
在工作中有很多地方需要对Map的value值进行排,我们只需要导入这个方法传入需要排序的Map获取排序好的Map即可
// Map的value值降序排序
public static <K, V extends Comparable<? super V>> Map<K, V> sortDescend(Map<K, V> map) {
List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
@Override
public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
int compare = (o1.getValue()).compareTo(o2.getValue());
return -compare;
}
});
Map<K, V> returnMap = new LinkedHashMap<K, V>();
for (Map.Entry<K, V> entry : list) {
returnMap.put(entry.getKey(), entry.getValue());
}
return returnMap;
}
// Map的value值升序排序
public static <K, V extends Comparable<? super V>> Map<K, V> sortAscend(Map<K, V> map) {
List<Map.Entry<K, V>> list = new ArrayList<Map.Entry<K, V>>(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
@Override
public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
int compare = (o1.getValue()).compareTo(o2.getValue());
return compare;
}
});
Map<K, V> returnMap = new LinkedHashMap<K, V>();
for (Map.Entry<K, V> entry : list) {
returnMap.put(entry.getKey(), entry.getValue());
}
return returnMap;
}