HashMap、TreeMap和LinkedHashMap速通流

HashMap、TreeMap和LinkedHashMap

在Java中，HashMap、TreeMap和LinkedHashMap是Map接口的不同实现，它们之间有一些关键的差异，主要涉及到存储顺序、性能特征和适用场景。

1. HashMap

• 存储顺序： HashMap 不保证存储顺序，元素的存储顺序是由键的哈希码（hashCode）决定的。

• 性能特征： HashMap 具有良好的性能，常数时间复杂度的查找、插入和删除操作。

• 适用场景： 适用于大多数情况，不要求有序性，对性能要求较高。

2. TreeMap

• 存储顺序： TreeMap 会对键进行排序，可以按照键的自然顺序或者通过自定义比较器进行排序。

• 性能特征： TreeMap 的性能相对较差，因为它维护了一棵红黑树，查找、插入和删除的时间复杂度为对数级别。

• 适用场景： 适用于需要有序键值对的情况，对有序性要求较高。

3. LinkedHashMap

• 存储顺序： LinkedHashMap 会保留元素插入的顺序，即按照元素插入的顺序来维护键值对的顺序。

• 性能特征： LinkedHashMap 的性能较好，查找、插入和删除的时间复杂度为常数级别，略低于 HashMap。

• 适用场景： 适用于需要有序性，且希望保留元素插入顺序的情况。

总结

• 使用 HashMap 适用于大多数情况，无序性、性能要求较高。
• 使用 TreeMap 适用于需要有序键值对，对有序性要求较高的情况。
• 使用 LinkedHashMap 适用于需要有序性，且希望保留元素插入顺序的情况，性能介于 HashMap 和 TreeMap 之间。

代码如下：

多去看看就会了

package com.wxy.rpc.consumer;


import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

public class CollectionsTest {
    public static void MapTest() {
        // 1. 创建和初始化 Map
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("Alice", 25);
        hashMap.put("Bob", 30);
        hashMap.put("Charlie", 22);

        // 打印 Map
        System.out.println("HashMap: " + hashMap);

        // 2. 获取和修改 Map 中的值
        int age = hashMap.get("Alice");
        System.out.println("Alice's age: " + age);

        hashMap.put("Bob", 31);
        System.out.println("Updated HashMap: " + hashMap);

        // 3. 遍历 Map
        System.out.println("Entries:");
        for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        System.out.println("Keys:");
        for (String key : hashMap.keySet()) {
            System.out.println("Key: " + key);
        }

        System.out.println("Values:");
        for (Integer value : hashMap.values()) {
            System.out.println("Value: " + value);
        }

        // 4. 判断 Map 是否包含键或值
        if (hashMap.containsKey("Alice")) {
            System.out.println("Map contains key 'Alice'");
        }

        if (hashMap.containsValue(30)) {
            System.out.println("Map contains value 30");
        }
    }

    public static void TreeMapTest() {
        // 创建 TreeMap 实例
        TreeMap<String, Integer> treeMap = new TreeMap<>();

        // 1. 添加元素
        treeMap.put("Alice", 25);
        treeMap.put("Bob", 30);
        treeMap.put("Charlie", 22);

        // 2. 获取元素
        System.out.println("Age of Bob: " + treeMap.get("Bob"));

        // 3. 遍历键值对
        System.out.println("Entries:");
        for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // 4. 获取键的集合
        System.out.println("Keys: " + treeMap.keySet());

        // 5. 获取值的集合
        System.out.println("Values: " + treeMap.values());

        // 6. 判断是否包含键
        System.out.println("Contains key 'Alice': " + treeMap.containsKey("Alice"));

        // 7. 判断是否包含值
        System.out.println("Contains value 30: " + treeMap.containsValue(30));

        // 8. 删除元素
        treeMap.remove("Charlie");
        System.out.println("After removing Charlie: " + treeMap);

        // 9. 获取第一个和最后一个键值对
        System.out.println("First Entry: " + treeMap.firstEntry());
        System.out.println("Last Entry: " + treeMap.lastEntry());

        // 10. 获取小于等于给定键的最大键值对
        System.out.println("Floor Entry for Bob: " + treeMap.floorEntry("Bob"));

        // 11. 获取大于等于给定键的最小键值对
        System.out.println("Ceiling Entry for Bob: " + treeMap.ceilingEntry("Bob"));

        // 12. 获取小于给定键的最大键
        System.out.println("Lower Key for Bob: " + treeMap.lowerKey("Bob"));

        // 13. 获取大于给定键的最小键
        System.out.println("Higher Key for Bob: " + treeMap.higherKey("Bob"));

        // 14. 清空 TreeMap
        treeMap.clear();
        System.out.println("After clearing: " + treeMap);
    }

    public static void LinkedHashMapTest() {
        // 1. 创建和初始化 LinkedHashMap
        Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("Alice", 25);
        linkedHashMap.put("Bob", 30);
        linkedHashMap.put("Charlie", 22);

        // 打印 LinkedHashMap
        System.out.println("LinkedHashMap: " + linkedHashMap);

        // 2. 获取和修改 LinkedHashMap 中的值
        int age = linkedHashMap.get("Alice");
        System.out.println("Alice's age: " + age);

        linkedHashMap.put("Bob", 31);
        System.out.println("Updated LinkedHashMap: " + linkedHashMap);

        // 3. 遍历 LinkedHashMap
        System.out.println("Entries:");
        for (Map.Entry<String, Integer> entry : linkedHashMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        System.out.println("Keys:");
        for (String key : linkedHashMap.keySet()) {
            System.out.println("Key: " + key);
        }

        System.out.println("Values:");
        for (Integer value : linkedHashMap.values()) {
            System.out.println("Value: " + value);
        }

        // 4. 判断 LinkedHashMap 是否包含键或值
        if (linkedHashMap.containsKey("Alice")) {
            System.out.println("LinkedHashMap contains key 'Alice'");
        }

        if (linkedHashMap.containsValue(30)) {
            System.out.println("LinkedHashMap contains value 30");
        }
    }


    public static void main(String[] args) {
        CollectionsTest.MapTest();
        CollectionsTest.TreeMapTest();
        CollectionsTest.LinkedHashMapTest();
        
    }
}