排序
参考:https://www.cnblogs.com/cchilei/p/13152615.html
1、key排序
/**
* 使用 Map按key进行排序
*
* @param unSortMap
* @return
*/
public static Map<String, String> SortByKey(Map<String, String> unSortMap) {
Map<String, String> result = unSortMap.entrySet().stream()
.sorted(Map.Entry.comparingByKey())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
(oldValue, newValue) -> oldValue, LinkedHashMap::new));
return result;
}
不限类型
// 2、根据key值倒序排序
public <K extends Comparable<? super K>, V > Map<K, V> sortByKey(Map<K, V> map) {
Map<K, V> result = new LinkedHashMap<>();
map.entrySet().stream()
.sorted(Map.Entry.<K, V>comparingByKey()
.reversed()).forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
return result;
}
2、value排序
/**
* 1、使用 Map按value进行排序
*
* @param unSortMap
* @return
*/
public static Map<String, String> sortByValueDesc(Map<String, String> unSortMap) {
Map<String, String> result = unSortMap.entrySet().stream()
.sorted(Map.Entry.<String, String>comparingByValue().reversed())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
(oldValue, newValue) -> oldValue, LinkedHashMap::new));
return result;
}
public static Map<String, String> sortByValueAsc(Map<String, String> unSortMap) {
Map<String, String> result = unSortMap.entrySet().stream()
.sorted(Map.Entry.<String, String>comparingByValue())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
(oldValue, newValue) -> oldValue, LinkedHashMap::new));
return result;
}
不限类型
// 根据value值倒序排序
public <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) {
Map<K, V> result = new LinkedHashMap<>();
map.entrySet().stream()
.sorted(Map.Entry.<K, V>comparingByValue()
.reversed()).forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
return result;
}
map遍历
//第一种:通过Map.keySet()遍历key和value
//keySet获取map集合key的集合 然后在遍历key即可
for(String key:map.keySet()){
String value = map.get(key).toString();
System.out.println("key:"+key+" vlaue:"+value);
}
//通过迭代器的方式
//第二种:通过Map.entrySet使用iterator遍历key和value
Iterator<Entry<String, Object>> it = map.entrySet().iterator();
while(it.hasNext()){
Entry<String, Object> entry = it.next();
System.out.println("key:"+entry.getKey()+" key:"+entry.getValue());
}
//推荐,尤其是容量大时
//第三种:通过Map.entrySet遍历key和value
for (Map.Entry<String, Object> m : map.entrySet()) {
System.out.println("key:" + m.getKey() + " value:" + m.getValue());
}
//第四种:通过Map.values()遍历所有的value,但不能遍历key
for(Object m:map.values()){
System.out.println(m);
}
map中value统一自增或自减
// 方法1
Map<Integer, Integer> map = new HashMap<>();
map.forEach((key, value)->map.put(key,map.get(key)-1));
// 方法2
Map<Integer, Integer> map = new HashMap<>();
map.forEach((key, value) -> map.merge(key, -1, Integer::sum));
// 有个限制 merge之后不能发生结构性修改(也就是map中元素数量不能发生变化),在当前场景下只要保证merge后不为空值即可
// 方法3
Map<Integer, Integer> map = new HashMap<>();
map.replaceAll((k,v)->v+1);
几种map的区别
HashMap、HashTable、TreeMap、LinkedHashMap的区别
几种实现类的类结构:
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, java.io.Serializable
思维导图
- HashMap
HashMap 是一个最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值,具有很快的访问速度。遍历时,取得数据的顺序是完全随机的。
HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null。
HashMap不支持线程的同步(即任一时刻可以有多个线程同时写HashMap),可能会导致数据的不一致。如果需要同步,可以用 Collections的synchronizedMap方法使HashMap具有同步的能力,或者使用ConcurrentHashMap。
- HashTable
Hashtable与 HashMap类似,它继承自Dictionary类。不同的是:它不允许记录的键或者值为空;它支持线程的同步(即任一时刻只有一个线程能写Hashtable),因此也导致了 Hashtable在写入时会比较慢。
- LinkedHashMap
LinkedHashMap保存了记录的插入顺序,在用Iterator遍历LinkedHashMap时,先得到的记录肯定是先插入的。也可以在构造时带参数,按照应用次数排序。
在遍历的时候会比HashMap慢,不过有种情况例外:当HashMap容量很大,实际数据较少时,遍历起来可能会比LinkedHashMap慢。因为LinkedHashMap的遍历速度只和实际数据有关,和容量无关,而HashMap的遍历速度和他的容量有关。
- TreeMap
TreeMap实现SortMap接口,能够把它保存的记录根据键排序。
默认是按键值的升序排序,也可以指定排序的比较器,当用Iterator 遍历TreeMap时,得到的记录是排过序的。
参考:【Java集合篇之Map】HashMap、HashTable、TreeMap、LinkedHashMap的区别以及应用场景_hashmap和hashtable的应用场景-CSDN博客
获取map中的最值
最小KEY
/**
* 求Map<K,V>中Key(键)的最小值
* @param map
* @return
*/
public static Object getMinKey(Map<Integer, Integer> map) {
if (map == null) return null;
Set<Integer> set = map.keySet();
Object[] obj = set.toArray();
Arrays.sort(obj);
return obj[0];
}
最小VALUE
/**
* 求Map<K,V>中Value(值)的最小值
* @param map
* @return
*/
public static Object getMinValue(Map<Integer, Integer> map) {
if (map == null) return null;
Collection<Integer> c = map.values();
Object[] obj = c.toArray();
Arrays.sort(obj);
return obj[0];
}
Map与实体类相互转换
使用fastjson
Map<String, Object> mapString = new HashMap<>();
Book book = JSON.parseObject(JSON.toJSONString(mapString), Book.class);
Map map = JSON.parseObject(JSON.toJSONString(book), Map.class);
List<Map>转换为对应的实体类
public static <T> T mapToEntity(Map<String,Object> map, Class<T> clazz){
return JSON.parseObject(JSON.toJSONString(map), clazz);
}
public static <T> List<T> listToEntity(List<Map<String,Object>> list, Class<T> clazz){
List<T> tList = new ArrayList<>();
for (Map<String, Object> stringObjectMap : list) {
T t = JSON.parseObject(JSON.toJSONString(stringObjectMap), clazz);
tList.add(t);
}
return tList;
}