import java.lang.reflect.Field;
import java.util.*;
public class ListUtil {
/**
* map根据value排序,升序排列
* 降序只需要将 compare方法 返回值取反(改成负号)即可
* @param map //map集合
* @return Map
*/
public static <K, V extends Comparable<? super V>> Map<K, V> sortByValueAscending(Map<K, V> map){
List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(map.entrySet());
list.sort(new Comparator<Map.Entry<K, V>>() {
@Override
public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2){
return (o1.getValue()).compareTo(o2.getValue());
}
});
Map<K, V> result = new LinkedHashMap<K, V>();
for (Map.Entry<K, V> entry : list) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
/**
* map根据value排序
*/
public static <K, V extends Comparable<? super V>> Map<K, V> sortByValueAscending2(Map<K, V> map){
List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(map.entrySet());
list.sort(new Comparator<Map.Entry<K, V>>() {
@Override
public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2){
return -(o1.getValue()).compareTo(o2.getValue());
}
});
Map<K, V> result = new LinkedHashMap<K, V>();
for (Map.Entry<K, V> entry : list) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
/**
* map根据key排序 升序
*/
public static <K, V extends Comparable<? super V>> Map<K, V> sortByKeyAscending(Map<K, V> map){
List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(map.entrySet());
list.sort(new Comparator<Map.Entry<K, V>>() {
@Override
public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2){
return o1.getKey().toString().compareTo(o2.getKey().toString());
}
});
Map<K, V> result = new LinkedHashMap<K, V>();
for (Map.Entry<K, V> entry : list) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
/**
* map根据key排序 升序
*/
public static <K, V extends Comparable<? super V>> Map<K, V> sortByKeyAscending2(Map<K, V> map){
List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(map.entrySet());
list.sort(new Comparator<Map.Entry<K, V>>() {
@Override
public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2){
return -o1.getKey().toString().compareTo(o2.getKey().toString());
}
});
Map<K, V> result = new LinkedHashMap<K, V>();
for (Map.Entry<K, V> entry : list) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
/**
* list去重 , 适合自定义对象 根据某个属性去重
* 如 removeSameCustomObjectByAttribute(ListName,Student.class,"name")
* @param list list集合
* @param clazz list泛型类 Student.class
* @param name 去重对象的字段属性
* @return 去重后的list
* @throws Exception e
*/
public static <T> List<T> removeSameCustomObjectByAttribute(List<T> list,Class<?> clazz,String name) throws Exception{
Field field = clazz.getDeclaredField(name);
field.setAccessible(true);
int num = list.size();
List<T> result = new ArrayList<>(num);
result.addAll(list);
for (int i = 0; i < num - 1; i++) {
for (int j = num - 1; j > i; j--) {
if (field.get(list.get(j)) == field.get(list.get(i))) {
result.remove(list.get(i));
}
}
}
return result;
}
/**
* 字符串列表去重方法
* @param list List
* @return List
*/
public static List<String> removeSameForListString(List<String> list){
List<String> l = new ArrayList<>();
Set<String> s = new HashSet<>();
for(String str:list){
if(s.add(str)){
l.add(str);
}
}
return l;
}
/**
* 对map的value求和统计
* @param map Map<String,Integer>
* @return int
*/
public static int getMapCountValue(Map<String,Integer> map){
int count=0;
for(String str:map.keySet()){
count = count+map.get(str);
}
return count;
}
/**
* 返回 map中值最大的key
* @param map Map<String, Integer>
* @return String
*/
public static String getMaxValue(Map<String, Integer> map) {
List<Map.Entry<String, Integer>> list= new ArrayList<>(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
@Override
public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
return o2.getValue().compareTo(o1.getValue());
}
});
//获取最大的概率对应的key值
String key="";
for (Map.Entry<String, Integer> mapping : list) {
key=mapping.getKey();
break;
}
return key;
}
/**
* 返回 map中值最大的value
* @param map Map<String, Integer>
* @return String
*/
public static String getMaxValue_value(Map<String, Integer> map) {
List<Map.Entry<String, Integer>> list= new ArrayList<>(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
@Override
public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
return o2.getValue().compareTo(o1.getValue());
}
});
//获取最大的概率对应的key值
int key=0;
for (Map.Entry<String, Integer> mapping : list) {
key=mapping.getValue();
break;
}
return key+"";
}
}
java map工具类
最新推荐文章于 2024-08-02 18:42:00 发布