80、Java集合框架：Map、SortedMap与枚举集合的深入解析

Java集合框架：Map、SortedMap与枚举集合的深入解析

1. Map与SortedMap接口概述

在Java编程中， Map<K,V> 接口是一个非常重要的概念，但它并不继承自 Collection 接口，这是因为它们有着显著不同的契约。 Map 主要用于存储键值对，而不是像 Collection 那样存储单个元素。

当你使用 Map 时，你添加的是键值对，而不是单个元素。一个键（通过其 equals 方法定义）可以映射到一个值或者没有值，而一个值可以被任意数量的键映射。例如，你可以使用 Map 来存储一个人的姓名和他们的地址之间的映射关系。如果某个姓名下有对应的地址，那么在 Map 中只会有一个这样的映射；如果没有映射，那么该姓名就没有对应的地址值。此外，多个人可能共享同一个地址，因此 Map 可能会为两个或更多的姓名返回相同的值。

Map 接口的基本方法如下：
| 方法 | 描述 |
| — | — |
| public int size() | 返回此映射的大小，即当前包含的键值映射的数量。即使映射包含更多元素，返回值也限制为 Integer.MAX_VALUE 。 |
| public boolean isEmpty() | 如果此集合当前不包含任何映射，则返回 true 。 |
| public boolean containsKey(Object key) | 如果集合包含指定键的映射，则返回 true 。 |
| public boolean containsValue(Object value) | 如果集合包含至少一个映射到指定值的映射，则返回 true 。 |
| public V get(Object key) | 返回指定键映射到的对象，如果键没有映射，则返回 null 。如果在允许 null 值的映射中，键被映射到 null ，也会返回 null 。你可以使用 containsKey 来区分这两种情况，但这会增加开销。为了避免进行第二次检查，可以将标记对象而不是 null 放入映射中。 |
| public V put(K key, V value) | 将指定键与指定值关联起来。如果键已经存在映射，则更改其值并返回原始值。如果不存在映射，则 put 方法返回 null ，这也可能意味着键最初被映射到 null 。（可选操作） |
| public V remove(Object key) | 移除指定键的任何映射。返回值的语义与 put 方法相同。（可选操作） |
| public void putAll(Map<? extends K, ? extends V> otherMap) | 将 otherMap 中的所有映射放入此映射中。（可选操作） |
| public void clear() | 移除所有映射。（可选操作） |

需要注意的是，以键作为参数的方法可能会抛出 ClassCastException （如果键的类型不适合此映射）或 NullPointerException （如果键为 null 且此映射不接受 null 键）。

虽然 Map 不继承自 Collection ，但具有相同含义的方法具有相同的名称，类似的方法也有类似的名称，这有助于你记住这些方法及其功能。

一般来说， Map 通常针对查找键下的值进行了优化。例如，在较大的映射中， containsKey 方法通常比 containsValue 方法高效得多。在 HashMap 中， containsKey 的时间复杂度为 $O(1)$，而 containsValue 的时间复杂度为 $O(n)$，因为键是通过哈希查找的，而值必须逐个元素进行搜索直到找到匹配项。

Map 本身不是一个集合，但有一些方法可以让你使用集合来查看映射：
- public Set<K> keySet() ：返回一个包含此映射所有键的 Set 。
- public Collection<V> values() ：返回一个包含此映射所有值的 Collection 。
- public Set<Map.Entry<K,V>> entrySet() ：返回一个包含此映射所有键值对的 Set ，其中每个元素都是一个 Map.Entry 对象，代表映射中的单个映射。

这些方法返回的集合由 Map 支持，因此从这些集合中移除一个元素会从映射中移除相应的键值对。你不能向这些集合中添加元素，因为它们不支持集合的可选添加方法。如果你并行迭代键集和值集，不能保证得到的是键值对，因为它们可能以任意顺序返回各自集合中的值。如果你需要这样的配对，应该使用 entrySet 。

Map.Entry<K,V> 接口定义了用于操作映射中条目的方法：
- public K getKey() ：返回此条目的键。
- public V getValue() ：返回此条目的值。
- public V setValue(V value) ：设置此条目的值并返回旧值。

需要注意的是，没有 setKey 方法，你需要通过移除原始键的现有映射并添加新键的映射来更改键。

SortedMap 接口扩展了 Map 接口，要求键必须是有序的。这种排序要求会影响 keySet 、 values 和 entrySet 方法返回的集合。 SortedMap 还添加了一些在有序映射中有意义的方法：
| 方法 | 描述 |
| — | — |
| public Comparator<? super K> comparator() | 返回用于对映射进行排序的比较器。如果没有使用比较器，则返回 null ，这意味着映射使用键的自然顺序进行排序。 |
| public K firstKey() | 返回此映射中的第一个（最低值）键。 |
| public K lastKey() | 返回此映射中的最后一个（最高值）键。 |
| public SortedMap<K,V> subMap(K minKey, K maxKey) | 返回此映射中键大于或等于 minKey 且小于 maxKey 的部分的视图。 |
| public SortedMap<K,V> headMap(K maxKey) | 返回此映射中键小于 maxKey 的部分的视图。 |
| public SortedMap<K,V> tailMap(K minKey) | 返回此映射中键大于或等于 minKey 的部分的视图。 |

任何返回的映射都由原始映射支持，因此对其中一个映射所做的更改对另一个映射也是可见的。

SortedMap 与 Map 的关系类似于 SortedSet 与 Set 的关系，除了 SortedMap 处理键之外，它们提供了几乎相同的功能。 SortedMap 方法抛出的异常与 SortedSet 对应方法抛出的异常类似。

2. Map的常见实现类

java.util 包提供了四种通用的 Map 实现类： HashMap 、 LinkedHashMap 、 IdentityHashMap 和 WeakHashMap ，以及一种 SortedMap 实现类： TreeMap 。

2.1 HashMap

HashMap 使用哈希表实现 Map 接口，其中每个键的 hashCode 方法用于在表中选择一个位置。如果 hashCode 方法编写良好，添加、移除或查找键值对的时间复杂度为 $O(1)$。这使得 HashMap 成为一种非常高效的关联键和值的方式，是最常用的集合之一。

HashMap 的构造函数如下：
- public HashMap(int initialCapacity, float loadFactor) ：创建一个具有指定初始容量和负载因子的新 HashMap ，负载因子必须是一个正数。
- public HashMap(int initialCapacity) ：创建一个具有指定初始容量和默认负载因子的新 HashMap 。
- public HashMap() ：创建一个具有默认初始容量和负载因子的新 HashMap 。
- public HashMap(Map<? extends K, ? extends V> map) ：创建一个新的 HashMap ，其初始映射从指定的 map 复制而来。初始容量基于 map 的大小，使用默认负载因子。

哈希映射内部使用的表由多个桶组成，初始桶的数量由哈希映射的初始容量决定。对象的哈希码（或哈希映射实现使用的特殊哈希函数）决定了对象应该存储在哪个桶中。桶的数量越少，不同对象存储在同一个桶中的可能性就越大，因此查找对象的时间会更长，因为需要详细检查桶。桶的数量越多，这种情况发生的可能性就越小，查找性能会提高，但哈希映射占用的空间会增加。此外，桶的数量越多，迭代所需的时间就越长，因此如果迭代很重要，你可能需要减少桶的数量，因为迭代的成本与哈希映射的大小和容量之和成正比。

负载因子决定了哈希映射何时会自动增加其容量。当哈希映射中的条目数量超过负载因子和当前容量的乘积时，容量将翻倍。增加容量需要对所有元素进行重新哈希并存储在正确的新桶中，这是一个代价高昂的操作。

在创建哈希映射时，你需要考虑负载因子和初始容量，了解映射预计包含的元素数量以及预计的使用模式。如果初始容量太小且负载因子太低，将会发生大量的重新哈希操作；相反，如果初始容量和负载因子足够大，可能永远不需要重新哈希。你需要在正常操作的成本与迭代和重新哈希的成本之间进行平衡，默认的负载因子 0.75 提供了一个很好的通用权衡。

下面是一个简单的 HashMap 使用示例：

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        // 创建一个 HashMap
        Map<String, Integer> map = new HashMap<>();

        // 添加键值对
        map.put("apple", 1);
        map.put("banana", 2);
        map.put("cherry", 3);

        // 获取键对应的值
        Integer value = map.get("apple");
        System.out.println("The value of apple is: " + value);

        // 检查是否包含某个键
        boolean containsKey = map.containsKey("banana");
        System.out.println("Does the map contain banana? " + containsKey);

        // 移除键值对
        map.remove("cherry");
        System.out.println("After removing cherry, the size of the map is: " + map.size());
    }
}

2.2 LinkedHashMap

LinkedHashMap<K,V> 继承自 HashMap<K,V> ，并通过定义映射中条目的顺序来细化 HashMap 的契约。默认情况下，迭代 LinkedHashMap 的内容（无论是条目集还是键集）将按插入顺序返回条目，即它们被添加的顺序。除此之外， LinkedHashMap 的行为与 HashMap 类似，并定义了相同形式的构造函数。

由于维护链表结构的开销， LinkedHashMap 的性能可能比 HashMap 稍慢一些；然而，迭代只需要与大小成比例的时间，而与容量无关。

此外， LinkedHashMap 提供了一个构造函数，它接受初始容量、负载因子和一个布尔标志 accessOrder 。如果 accessOrder 为 false ，则映射的排序行为如前所述；如果 accessOrder 为 true ，则映射从最近访问的条目到最久未访问的条目进行排序，这使得它适合实现最近最少使用（LRU）缓存。只有直接使用 put 、 get 和 putAll 方法才被视为对条目的访问，但如果在映射的不同视图上调用这些方法（请参阅相关文档），则这些方法不被视为访问。

下面是一个使用 LinkedHashMap 实现 LRU 缓存的示例：

import java.util.LinkedHashMap;
import java.util.Map;

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int capacity;

    public LRUCache(int capacity) {
        super(capacity, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
                return size() > capacity;
            }
        };
        this.capacity = capacity;
    }

    public static void main(String[] args) {
        LRUCache<String, Integer> cache = new LRUCache<>(3);
        cache.put("one", 1);
        cache.put("two", 2);
        cache.put("three", 3);
        System.out.println(cache); // 输出: {one=1, two=2, three=3}
        cache.get("one");
        System.out.println(cache); // 输出: {two=2, three=3, one=1}
        cache.put("four", 4);
        System.out.println(cache); // 输出: {three=3, one=1, four=4}
    }
}

2.3 IdentityHashMap

Map 的一般契约要求键的相等性基于等价性（即使用 equals 方法）。但在某些情况下，你可能需要一个 Map 来存储关于特定对象的信息，而不是将所有等价对象视为信息的单一键。例如，在序列化机制中，当确定序列化图中的对象是否已经被处理过时，你需要检查它是否是实际的对象，而不仅仅是等价的对象。

为了支持这种需求， IdentityHashMap 类使用对象标识（使用 == 进行比较）来确定给定的键是否已经存在于映射中。这很有用，但它违反了 Map 的一般契约。

IdentityHashMap 有三个构造函数：
- public IdentityHashMap(int expectedSize) ：创建一个具有指定预期最大大小的新 IdentityHashMap 。
- public IdentityHashMap() ：创建一个具有默认预期最大大小的新 IdentityHashMap 。
- public IdentityHashMap(Map<? extends K, ? extends V> map) ：创建一个包含指定映射中所有条目的新 IdentityHashMap 。

预期最大大小是对映射初始容量的一个提示，但其确切效果未指定。

下面是一个 IdentityHashMap 的使用示例：

import java.util.IdentityHashMap;
import java.util.Map;

public class IdentityHashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> identityMap = new IdentityHashMap<>();
        String key1 = new String("key");
        String key2 = new String("key");
        identityMap.put(key1, 1);
        identityMap.put(key2, 2);
        System.out.println(identityMap.size()); // 输出: 2
    }
}

2.4 WeakHashMap

在 Java 中，集合实现通常对元素、值和键使用强引用。然而，有时你可能需要一个集合以较弱的方式持有其包含的对象。 WeakHashMap 就是这样一种集合。

WeakHashMap 的行为类似于 HashMap ，但有一个重要区别： WeakHashMap 使用弱引用对象来引用键，而不是强引用。弱引用允许对象被垃圾回收，因此你可以将对象放入 WeakHashMap 中，而不会因为映射的引用而强制对象保留在内存中。当一个键只有弱可达性时，其映射可能会从映射中移除，这也会丢弃映射对键值对象的强引用。如果值对象在其他地方没有强可达性，这可能导致值也被回收。

WeakHashMap 在调用可以修改内容的方法（如 put 、 remove 或 clear ）时会检查未引用的键，但在调用 get 方法之前不会检查。这使得这些方法的性能取决于自上次检查以来变为未引用的键的数量。如果你想强制移除，可以以不会产生实际效果的方式调用其中一个修改方法，例如移除一个没有映射的键（如果你不使用 null 作为键，可以使用 null ）。

由于映射中的条目可能随时消失，一些方法的行为可能会令人惊讶。例如，连续调用 size 方法可能会返回越来越小的值；或者某个集合视图的迭代器在 hasNext 返回 true 后可能会抛出 NoSuchElementException 。

WeakHashMap 类提供了与 HashMap 相同的构造函数：无参构造函数、接受初始容量的构造函数、接受初始容量和负载因子的构造函数，以及接受一个 Map 作为初始内容的构造函数。

下面是一个 WeakHashMap 的使用示例：

import java.util.WeakHashMap;
import java.util.Map;

public class WeakHashMapExample {
    public static void main(String[] args) {
        Map<Object, String> weakMap = new WeakHashMap<>();
        Object key = new Object();
        weakMap.put(key, "value");
        System.out.println(weakMap.get(key)); // 输出: value
        key = null;
        System.gc(); // 建议垃圾回收
        try {
            Thread.sleep(1000); // 等待垃圾回收完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(weakMap.get(key)); // 输出: null
    }
}

2.5 TreeMap

TreeMap 类实现了 SortedMap 接口，它以与 TreeSet 相同的方式对键进行排序。这使得添加、移除或查找键值对的时间复杂度为 $O(log n)$。因此，通常只有在需要排序或者键的 hashCode 方法编写不佳（从而破坏了 HashMap 的 $O(1)$ 性能）时，才会使用 TreeMap 。

TreeMap 的构造函数如下：
- public TreeMap() ：创建一个根据键的自然顺序排序的新 TreeMap 。添加到该映射的所有元素必须实现 Comparable 接口，并且相互可比。
- public TreeMap(Map<? extends K, ? extends V> map) ：相当于先使用 TreeMap() 创建一个新的 TreeMap ，然后将指定映射的所有键值对添加到该映射中。
- public TreeMap(Comparator<? super K> comp) ：创建一个根据指定比较器的顺序排序的新 TreeMap 。
- public TreeMap(SortedMap<K, ? extends V> map) ：创建一个初始内容与指定 SortedMap 相同且排序方式相同的新 TreeMap 。

下面是一个使用 TreeMap 的示例：

import java.util.TreeMap;
import java.util.Map;

public class TreeMapExample {
    public static void main(String[] args) {
        // 创建一个 TreeMap
        Map<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("banana", 2);
        treeMap.put("apple", 1);
        treeMap.put("cherry", 3);
        // 遍历 TreeMap
        for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

3. 枚举集合：EnumSet与EnumMap

除了上述的 Map 实现类，Java 还提供了两种专门为枚举常量设计的集合： EnumSet 和 EnumMap 。

3.1 EnumSet

EnumSet<E extends Enum<E>> 抽象类表示一个由特定枚举类型的所有枚举常量组成的集合。例如，在编写与反射相关的 API 时，你可以定义一个枚举来表示不同的字段修饰符，然后让 Field 类返回适用于该字段的修饰符集合：

enum FieldModifiers { STATIC, FINAL, VOLATILE, TRANSIENT }
public class Field {
    public EnumSet<FieldModifiers> getModifiers() {
        // ...
        return null;
    }
    // ... 其他 Field 方法 ...
}

一般来说，当枚举表示一组标志或“状态位”时，你可能希望将适用于给定元素的标志集合分组到 EnumSet 中。

EnumSet 对象不是直接创建的，而是通过 EnumSet 类的一些静态工厂方法获得：
| 方法 | 描述 |
| — | — |
| public static <E extends Enum<E>> EnumSet<E> allOf(Class<E> enumType) | 创建一个包含指定枚举类型所有元素的 EnumSet 。 |
| public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> enumType) | 创建一个可以包含指定枚举类型元素的空 EnumSet 。 |
| public static <E extends Enum<E>> EnumSet<E> copyOf(EnumSet<E> set) | 创建一个与指定 EnumSet 具有相同枚举类型并包含其所有元素的 EnumSet 。 |
| public static <E extends Enum<E>> EnumSet<E> complementOf(EnumSet<E> set) | 创建一个与指定 EnumSet 具有相同枚举类型并包含所有不在该 EnumSet 中的枚举常量的 EnumSet 。 |
| public static <E extends Enum<E>> EnumSet<E> copyOf(Collection<E> coll) | 从指定集合创建一个 EnumSet 。如果集合是 EnumSet ，则返回其副本。任何其他集合必须包含一个或多个元素，且所有元素都必须是来自同一枚举的常量；该枚举将是返回的 EnumSet 的枚举类型。如果集合为空且不是 EnumSet ，则抛出 IllegalArgumentException ，因为没有指定该集合的枚举类型。 |

of 方法用于创建包含指定枚举常量的枚举集合，它有五种重载形式，分别接受一到五个元素作为参数。例如，接受三个元素的形式如下：

public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3)

此外，还有一个接受任意数量元素的重载形式：

public static <E extends Enum<E>> EnumSet<E> of(E first, E... rest)

最后， range 方法接受两个枚举常量，定义了枚举集合将包含的第一个和最后一个元素。如果第一个和最后一个元素的顺序错误，则抛出 IllegalArgumentException 。

一旦获得了 EnumSet ，你可以根据需要自由修改它。 EnumSet 内部使用位向量，因此它既紧凑又高效。 EnumSet 的迭代器不是其他集合通常使用的快速失败迭代器，而是一个弱一致性迭代器，它按枚举常量的自然顺序（即枚举常量的声明顺序）返回枚举值。弱一致性迭代器永远不会抛出 ConcurrentModificationException ，但它可能不会反映迭代过程中发生的任何更改。

下面是一个使用 EnumSet 的示例：

import java.util.EnumSet;

enum Days {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

public class EnumSetExample {
    public static void main(String[] args) {
        // 创建一个包含所有工作日的 EnumSet
        EnumSet<Days> weekdays = EnumSet.range(Days.MONDAY, Days.FRIDAY);
        System.out.println(weekdays); // 输出: [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY]

        // 创建一个包含所有休息日的 EnumSet
        EnumSet<Days> weekends = EnumSet.complementOf(weekdays);
        System.out.println(weekends); // 输出: [SATURDAY, SUNDAY]
    }
}

3.2 EnumMap

EnumMap<K extends Enum<K>, V> 是一种特殊的 Map ，它使用枚举值作为键。映射中的所有值必须来自同一枚举类型。与 EnumSet 一样，枚举值按其自然顺序排序，迭代器也是弱一致性的。

例如，假设你正在编写一个动态构建和显示在线表单的应用程序，基于以 XML 等结构化格式编写的描述。给定一组预期的表单元素作为枚举：

enum FormElements { NAME, STREET, CITY, ZIP }

你可以创建一个 EnumMap 来表示填写的表单，其中键是表单元素，值是用户输入的内容。

EnumMap 有三个构造函数：
- public EnumMap(Class<K> keyType) ：创建一个可以持有指定枚举类型键的空 EnumMap 。
- public EnumMap(EnumMap<K, ? extends V> map) ：创建一个与指定 EnumMap 具有相同枚举类型并包含其所有元素的 EnumMap 。
- public EnumMap(Map<K, ? extends V> map) ：从指定映射创建一个 EnumMap 。如果映射是 EnumMap ，则返回其副本。任何其他映射必须包含一个或多个键，且所有键都必须是来自同一枚举的常量；该枚举将是返回的 EnumMap 的枚举类型。如果映射为空且不是 EnumMap ，则抛出 IllegalArgumentException ，因为没有指定该映射的枚举类型。

EnumMap 内部使用数组实现，因此它既紧凑又高效。

下面是一个使用 EnumMap 的示例：

import java.util.EnumMap;
import java.util.Map;

enum Size {
    SMALL, MEDIUM, LARGE
}

public class EnumMapExample {
    public static void main(String[] args) {
        // 创建一个 EnumMap
        Map<Size, String> sizeMap = new EnumMap<>(Size.class);
        sizeMap.put(Size.SMALL, "Small Size");
        sizeMap.put(Size.MEDIUM, "Medium Size");
        sizeMap.put(Size.LARGE, "Large Size");
        // 遍历 EnumMap
        for (Map.Entry<Size, String> entry : sizeMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

通过对 Map 、 SortedMap 及其实现类以及枚举集合的深入了解，你可以根据具体的需求选择合适的集合来提高代码的性能和可读性。在实际开发中，合理使用这些集合类可以帮助你更高效地处理数据。

4. 各类Map实现的性能对比与选择建议

在实际开发中，选择合适的 Map 实现类对于程序的性能至关重要。下面我们将对前面介绍的几种 Map 实现类进行性能对比，并给出选择建议。

实现类	插入性能	查找性能	删除性能	排序特性	空间占用	适用场景
HashMap	平均 $O(1)$，极端情况可能退化	平均 $O(1)$，极端情况可能退化	平均 $O(1)$，极端情况可能退化	无	较高，取决于负载因子和初始容量	一般场景，对插入、查找、删除性能要求较高，不要求排序
LinkedHashMap	略低于 HashMap ，因为要维护链表结构	略低于 HashMap ，因为要维护链表结构	略低于 HashMap ，因为要维护链表结构	默认按插入顺序，可配置为访问顺序	略高于 HashMap ，因为要维护链表结构	需要按插入顺序或访问顺序遍历元素，如实现 LRU 缓存
IdentityHashMap	与 HashMap 类似，但使用 == 比较键	与 HashMap 类似，但使用 == 比较键	与 HashMap 类似，但使用 == 比较键	无	与 HashMap 类似	需要使用对象标识作为键的场景
WeakHashMap	与 HashMap 类似，但键使用弱引用	与 HashMap 类似，但键使用弱引用	与 HashMap 类似，但键使用弱引用	无	与 HashMap 类似	希望键在没有其他强引用时能被垃圾回收的场景
TreeMap	$O(log n)$	$O(log n)$	$O(log n)$	键按自然顺序或指定比较器排序	相对较低，使用红黑树结构	需要对键进行排序的场景，或者键的 hashCode 方法性能不佳

下面是一个简单的 mermaid 流程图，展示了选择 Map 实现类的决策过程：

graph TD;
    A[是否需要排序?] -->|是| B[选择 TreeMap];
    A -->|否| C[是否需要按插入或访问顺序遍历?];
    C -->|是| D[选择 LinkedHashMap];
    C -->|否| E[是否需要使用对象标识作为键?];
    E -->|是| F[选择 IdentityHashMap];
    E -->|否| G[是否希望键能被垃圾回收?];
    G -->|是| H[选择 WeakHashMap];
    G -->|否| I[选择 HashMap];

例如，如果你正在开发一个简单的缓存系统，只需要快速地插入、查找和删除键值对，并且不需要排序，那么 HashMap 是一个不错的选择。如果你需要实现一个 LRU 缓存，那么 LinkedHashMap 会更合适。如果你需要对键进行排序，比如根据键的字母顺序输出结果，那么 TreeMap 是首选。

5. EnumSet 和 EnumMap 的优势与应用场景

EnumSet 和 EnumMap 是专门为枚举常量设计的集合，它们具有许多独特的优势，适用于特定的应用场景。

5.1 EnumSet 的优势与应用场景

• 优势

  • 高效性 ： EnumSet 内部使用位向量实现，这使得它在存储和操作枚举常量时非常紧凑和高效。位向量可以在常数时间内完成插入、删除和查找操作。
  • 类型安全 ： EnumSet 只能存储特定枚举类型的常量，这保证了类型安全，避免了运行时类型错误。
  • 弱一致性迭代器 ： EnumSet 的迭代器是弱一致性的，不会抛出 ConcurrentModificationException ，适合在多线程环境下安全地遍历。

• 应用场景

  • 标志集合 ：当枚举表示一组标志或状态位时， EnumSet 可以方便地组合和操作这些标志。例如，在权限管理系统中，枚举可以表示不同的权限， EnumSet 可以用来存储用户拥有的权限集合。
  • 反射 API ：在反射相关的 API 中， EnumSet 可以用来存储字段修饰符、方法修饰符等枚举常量集合。

// 权限管理系统示例
enum Permission {
    READ, WRITE, EXECUTE
}

public class PermissionManager {
    private EnumSet<Permission> userPermissions;

    public PermissionManager(EnumSet<Permission> permissions) {
        this.userPermissions = permissions;
    }

    public boolean hasPermission(Permission permission) {
        return userPermissions.contains(permission);
    }

    public static void main(String[] args) {
        EnumSet<Permission> adminPermissions = EnumSet.allOf(Permission.class);
        PermissionManager adminManager = new PermissionManager(adminPermissions);
        System.out.println("Admin has read permission: " + adminManager.hasPermission(Permission.READ));
    }
}

5.2 EnumMap 的优势与应用场景

• 优势

  • 高效性 ： EnumMap 内部使用数组实现，因此在存储和操作枚举键的映射时非常紧凑和高效。数组的访问速度快，使得 EnumMap 的性能优于一般的 Map 实现。
  • 类型安全 ： EnumMap 只能使用枚举类型作为键，保证了类型安全，避免了运行时类型错误。
  • 排序特性 ：枚举键按其自然顺序排序，迭代器也是弱一致性的，方便按顺序遍历。

• 应用场景

  • 表单数据存储 ：在动态构建和显示在线表单的应用中， EnumMap 可以用来存储表单元素和用户输入的映射关系。
  • 配置管理 ：在配置管理系统中，枚举可以表示不同的配置项， EnumMap 可以用来存储配置项和对应的值。

// 表单数据存储示例
enum FormField {
    NAME, AGE, EMAIL
}

public class FormData {
    private EnumMap<FormField, String> formValues;

    public FormData() {
        this.formValues = new EnumMap<>(FormField.class);
    }

    public void setValue(FormField field, String value) {
        formValues.put(field, value);
    }

    public String getValue(FormField field) {
        return formValues.get(field);
    }

    public static void main(String[] args) {
        FormData form = new FormData();
        form.setValue(FormField.NAME, "John Doe");
        form.setValue(FormField.AGE, "30");
        System.out.println("Name: " + form.getValue(FormField.NAME));
    }
}

6. 常见问题与解决方案

6.1 HashMap 的哈希冲突问题

HashMap 使用哈希表实现，当不同的键产生相同的哈希码时，就会发生哈希冲突。哈希冲突会影响 HashMap 的性能，因为在查找、插入和删除键值对时，需要遍历链表或红黑树来解决冲突。

• 解决方案
  • 优化 hashCode 方法 ：编写良好的 hashCode 方法可以减少哈希冲突的发生。 hashCode 方法应该尽可能均匀地分布键的哈希码。
  • 调整负载因子和初始容量 ：适当增加初始容量和调整负载因子可以减少哈希冲突的概率。默认的负载因子 0.75 是一个不错的选择，但在某些情况下，你可能需要根据实际情况进行调整。
  • 使用更高级的哈希算法 ：在某些情况下，你可以使用更高级的哈希算法来提高哈希码的分布均匀性。

6.2 WeakHashMap 中键值对意外消失问题

WeakHashMap 使用弱引用引用键，当键没有其他强引用时，键及其对应的映射可能会被垃圾回收，导致键值对意外消失。

• 解决方案
  • 注意键的引用管理 ：确保你确实希望键在没有其他强引用时被垃圾回收。如果不希望键值对意外消失，应该使用其他类型的 Map 。
  • 定期清理 ：在适当的时候调用 put 、 remove 或 clear 方法，触发 WeakHashMap 对未引用键的检查和清理。

6.3 TreeMap 中键的比较问题

TreeMap 需要键实现 Comparable 接口或提供一个 Comparator 来进行排序。如果键没有正确实现比较逻辑，可能会导致 TreeMap 无法正常工作。

• 解决方案
  • 确保键实现 Comparable 接口 ：如果键是自定义类，确保该类实现了 Comparable 接口，并正确实现了 compareTo 方法。
  • 提供 Comparator ：如果键无法实现 Comparable 接口，或者需要自定义排序规则，可以在创建 TreeMap 时提供一个 Comparator 。

import java.util.Comparator;
import java.util.TreeMap;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class TreeMapComparatorExample {
    public static void main(String[] args) {
        Comparator<Person> ageComparator = Comparator.comparingInt(Person::getAge);
        TreeMap<Person, String> personMap = new TreeMap<>(ageComparator);
        personMap.put(new Person("John", 30), "Employee");
        personMap.put(new Person("Jane", 25), "Intern");
        for (var entry : personMap.entrySet()) {
            System.out.println(entry.getKey().getName() + ": " + entry.getValue());
        }
    }
}

7. 总结

本文深入介绍了 Java 中的 Map 、 SortedMap 接口及其常见实现类，包括 HashMap 、 LinkedHashMap 、 IdentityHashMap 、 WeakHashMap 和 TreeMap ，以及专门为枚举常量设计的 EnumSet 和 EnumMap 。通过对这些集合类的详细介绍和性能对比，我们可以得出以下结论：

• HashMap ：是最常用的 Map 实现，适用于大多数场景，提供了高效的插入、查找和删除操作。
• LinkedHashMap ：适合需要按插入顺序或访问顺序遍历元素的场景，如实现 LRU 缓存。
• IdentityHashMap ：适用于需要使用对象标识作为键的场景。
• WeakHashMap ：适用于希望键在没有其他强引用时能被垃圾回收的场景。
• TreeMap ：适用于需要对键进行排序的场景，或者键的 hashCode 方法性能不佳的情况。
• EnumSet 和 EnumMap ：专门为枚举常量设计，具有高效、类型安全等优点，适用于处理枚举相关的数据。

在实际开发中，我们应该根据具体的需求选择合适的集合类，合理使用这些集合类可以提高代码的性能和可读性，更高效地处理数据。同时，我们也需要注意一些常见问题，如哈希冲突、键值对意外消失和键的比较问题，并采取相应的解决方案来避免这些问题的发生。