java.util.Map API

Map<String, String> map = new HashMap<>();
Map<String, String>map = new LinkedHashMap<>();
Map<String, String>map = new TreeMap<>();
Map<String, String>map = new Hashtable<>();

V put(K key, V value)

void putAll(Map<? extends K,? extends V> m)

void clear()

getOrDefault(Object key, V defaultValue)
意思就是当Map集合中有这个key时，就使用这个key对应的value值，如果没有就使用默认值defaultValue

String k = "key";
HashMap<String, Integer> map = new HashMap<String, Integer>() {{
   put(k, 1);
}};
map.merge(k, 2, (oldVal, newVal) -> oldVal + newVal);

hashmap.computeIfAbsent(K key, Function remappingFunction)

参数说明：
    key - 键
    remappingFunction - 重新映射函数，用于重新计算值

例如：
public static void computeIfAbsent(){ // jdk1.8新特性哦
    HashMap<String, String> map = new HashMap();
    map.put("1","is map");
    map.put("2","contains a mapping");
    map.put("3","specified");
    map.put("4","inappropriate");
    map.computeIfAbsent("5", v -> "is exist");

    System.out.println(map.get("5"));
}

hashmap.computeIfPresent(K key, BiFunction remappingFunction)

参数说明：
    key - 键
    remappingFunction - 重新映射函数，用于重新计算值

例如：
public static void computeIfPresent() {
    // 创建一个 HashMap
    HashMap<String, Integer> prices = new HashMap<>();

    // 往HashMap中添加映射关系
    prices.put("Shoes", 200);
    prices.put("Bag", 300);
    prices.put("Pant", 150);
    System.out.println("HashMap: " + prices);

    // 重新计算鞋加上10%的增值税后的价值
    int shoesPrice = prices.computeIfPresent("Shoes", (key, value) -> value + value * 10/100);
    System.out.println("Price of Shoes after VAT: " + shoesPrice);

    // 输出更新后的HashMap
    System.out.println("Updated HashMap: " + prices);
}

Cat ououCat = new Cat ("欧欧", "雪娜瑞");
Cat yayaCat = new Cat ("亚亚", "拉布拉多");
Cat meimeiCat = new Cat ("美美", "雪娜瑞");
Cat feifeiCat = new Cat ("菲菲", "拉布拉多");

Map map=new HashMap();

map.put(ououDog.getName(),ououDog);
map.put(yayaDog.getName(),yayaDog);
map.put(meimeiDog.getName(),meimeiDog);
map.put(feifeiDog.getName(),feifeiDog);

第一种：JDK1.4 迭代器遍历（使用entrySet）
Iterator<Map.Entry<String, Dog>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Dog> entry = iterator.next();
    System.out.println(entry.getKey());
    System.out.println(entry.getValue());
}

第二种：迭代器遍历（使用keySet）
Set keys = map.keySet();//取出所有key的集合
Iterator iterator = keys.iterator();//获取Iterator对象
while(iterator .hasNext()){
    String key=(String)iterator .next();//取出key
    Dog dog=(Dog)dogMap.get(key);//根据key取出对应的值
}

第三种：JDK1.5 增强for循环遍历（使用entrySet）
for (Map.Entry<String, Dog> entry : map.entrySet()) {
    System.out.println(entry.getKey());
    System.out.println(entry.getValue());
}

第四种：增强for循环遍历（使用keySet）
遍历dogMap中的键 
for (String key : map.keySet()) {
    System.out.println(key + " ：" + dogMap.get(key));
}
遍历dogMap中的值 
for (Integer value : map.values()) { 
  System.out.println("Value = " + value); 
}

总结：entrySet 优于keySet，因为一次就把key和value放入了entry

第五种：JDK8 Lambda拉姆达
map.forEach((key, value) -> {
    System.out.println("key: "+ key + "  value: " + value );
});
map.forEach( (k,v)->{System.out.println(k+" "+v);} );


备注：使用 entrySet 遍历 Map 类集合 KV，而不是 keySet 方式进行遍历。
说明：keySet 其实是遍历了 2 次，一次是转为 Iterator 对象，另一次是从 hashMap 中取出 key 所对应的 value。
而 entrySet 只是遍历了一次就把 key 和 value 都放到了 entry 中，效率更高。如果是 JDK8，使用 Map.forEach 方法。

总结：

增强for循环使用方便，但性能较差，不适合处理超大量级的数据。
迭代器的遍历速度要比增强for循环快很多，是增强for循环的2倍左右。
使用entrySet遍历的速度要比keySet快很多，是keySet的1.5倍左右。

public class HashMap {

    public static void main(String[] args){

        Map<String, String> map = new HashMap<String, String>();
        map.put("a", "a");
        map.put("e", "e");
        map.put("d", "");
        map.put("b", "b");
        map.put("c", "c");

        //通过ArrayList构造函数把map.entrySet()转换成list
        List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(map.entrySet());
        //通过比较器实现比较排序
        Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
            public int compare(Map.Entry<String, String> mapping1, Map.Entry<String, String> mapping2) {
                return mapping1.getKey().compareTo(mapping2.getKey());
            }
        });

        for (Map.Entry<String, String> mapping : list) {
            System.out.println(mapping.getKey() + " ：" + mapping.getValue());
        }
    }
}

备注：HashMap是无序的

// 创建一个Map，并填入数据
Map<String, Integer> codes = new HashMap<>();
codes.put("United States", 1);
codes.put("Germany", 49);
codes.put("France", 33);
codes.put("China", 86);
codes.put("Pakistan", 92);

// 按照Map的键进行排序
Map<String, Integer> sortedMap = codes.entrySet().stream()  // 首先使用entrySet().stream() 将Map类型转换为Stream流类型。
        .sorted(Map.Entry.comparingByKey())  // 使用sorted方法排序，排序的依据是Map.Entry.comparingByKey()，也就是按照Map的键排序
        .collect(  // 用collect方法将Stream流转成LinkedHashMap
                Collectors.toMap(
                    Map.Entry::getKey, 
                    Map.Entry::getValue,
                    (oldVal, newVal) -> oldVal,
                    LinkedHashMap::new
                )
        );

// 将排序后的Map打印
sortedMap.entrySet().forEach(System.out::println);

Map<String, Integer> sortedMap2 = codes.entrySet().stream()
        .sorted(Map.Entry.comparingByValue())
        .collect(Collectors.toMap(
                Map.Entry::getKey,
                Map.Entry::getValue,
                (oldVal, newVal) -> oldVal,
                LinkedHashMap::new));

sortedMap2.entrySet().forEach(System.out::println);

TreeMap排序：

Map<String, String> map = new TreeMap<String, String>(new Comparator<String>() {
    public int compare(String obj1, String obj2) {
        return obj2.compareTo(obj1);// 降序排序
    }
});
map.put("a", "c");
map.put("b", "b");
map.put("c", "a");
 
for (String key : map.keySet()) {
    System.out.println(key + " ：" + map.get(key));
}

TreeMap排序（按value排序）

Map<String, String> map = new TreeMap<String, String>();
        map.put("a", "c");
        map.put("b", "b");
        map.put("c", "a");
 
        // 通过ArrayList构造函数把map.entrySet()转换成list
        List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(map.entrySet());
        // 通过比较器实现比较排序
        Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
            public int compare(Map.Entry<String, String> mapping1, Map.Entry<String, String> mapping2) {
                return mapping1.getValue().compareTo(mapping2.getValue());
            }
        });
 
        for (String key : map.keySet()) {
            System.out.println(key + " ：" + map.get(key));
        }
}

// 将 `HashMap` 转为 `TreeMap`
Map<String, Integer> sorted = new TreeMap<>(codes);