java基础之map

排序

参考：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的应用场景-优快云博客

获取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;
}