Java Review (二十九、集合----- Map 集合)

简介: Java Review (二十九、集合----- Map 集合)

   

文章目录

图一:Map集合结构图

image.png

Map用于保存具有映射关系的数据,因此 Map 集合里保存着两组值 , 一组值用于保存 Map 里的 key 另外一组值用于保存 Map 里的 value , key 和 value 都

可以是任何引用类型的数据 。 Map 的 key 不允许重复 ,即同一个 Map 对象的任何两个 key 通过 equals 方法比较总是返回 false 。

key 和 value 之间存在单向一对一关系, 即通过指定的 key,总能找到唯一的、确定的 value 。 从 Map  中取出数数据时只要给出指定的 key , 就可以取出对应的value 。 如果把 Map 的两组值拆开来看 , Map 里  的数据有如图二所示的结构 。

图二:分开看 Map 的 key 组和 value 组

image.png

从图二中可以看出 ,如果把 Map 里 的所有 key数据组放在一起来看,它们就组成了一个 Set 集合(所有的 key 没有顺序, key 与  key 之间不能重复) ,实际Map 确实包含了 一个 keySet()方法 ,用于返回 Map 里所有 key 组成的 Set 集合 。

实际上,Map的实现类和子接口中 key 集的存储形式和对应Set 集合中元素的存储形式完全相同 。

Set 与 Map 之间的关系非常密切 。 虽然 Map中放的元素是 key-value 对 , Set 集合中放的元素是单个对象 ,  但如果把 key-value 对中的 value 当成 key 的 附庸 : key 在哪里, value就跟在哪里 。 这样就可以像对待  Set 一样来对待 Map 了 。 事实上, Map 提供了 一个 Entry内部类来封装 key-value对 , 而计算  Entry存储时则只考虑 Enume封装的 key。从 Java源代码来看, Java则是先实现了 Map ,然后通过包装一个所有  Value都为null的Map来实现Set集合 。

如果把 Map 里的所有 value 放在一起来看,它们又非常类似于一个 List: 元素与元素之间可以重复,每个元素可以根据索引来查找 ,  只是 Map 中的索引不再使用整数值,而是以另 一 个对象作为索引 。 如果需要从 List 集合中取出元素,则需要提供该元素的数字索引 ;  如果需要从 Map 中取出元素, 则需要提供该元素的 key 索引 。 因此 , Map 有时也被称为字典,或关联数组 。

 Map 接口中定义了如下常用的方法 :

  • void clear(): 删除该 Map 对象中的所有 key-value 对 。
  • boolean containsKey(Object key): 查询 Map 中 是否包含指定的 key ,如果包含则返回 true 。
  • boolean containsValue(Object value): 查询 Map 中 是否包含一个或多个 value ,如果包含则返回 true ,
  • Set entrySet(): 返回 Map 中包含 的 key-value 对所组成的 Set 集合,每个集合元素都是 Map.Entry(Entry 是 Map 的内部类)对象 。
  • Object get(Object key): 返回指定 key 所对应的 value; 如果此 Map 中不包含该 key ,则 返回 null 。
  • boolean isEmpty(): 查询该 Map 是否为空(即不包含任何 key-value 对 ) ,如 果为空则返回 true 。
  • Set keySet(): 返回该 Map 中所有 key 组成的 Set 集合 。
    Object put(Object key, Object value): 添加 一个 key-value 对,如果当前 Map 中己有一个与该 key相等的 key-value 对,则新的 key-value 对会覆盖原来的 key-value 对 。
  • void putAll(Map m): 将指定 Map 中的 key-value 对复制到本 Map 中 。
  • Object remove(Object key): 删除指定 key 所对应的 key-value 对,返回被删除 key 所关联的 value ,如果该 key 不存在,则返回 null 。
  • boolean  remove(Object key, Object value): 这是 Java 8 新增的方法,删除指定 key 、 value 所对应的  key-value 对 。 如果从该 Map 中成功地删除该 key-value 对,该方法返回 true ,否则返回 false 。
  • int sizeO : 返回该 Map 里的 key-value 对的个数 。
  • Collection values() : 返回该 Map 里所有 value 组成的 Collection 。

  Map 中包括一个内部类 Entry, 该类封装了 一个 key-value 对 。 Entry 包含如下三个方法:

  • Object getKey(): 返回该 En町里包含的 key 值 。
  • Object getValue(): 返回该 Entry 里包含的 value 值 。
  • Object setValue(V value): 设置该 Entry 里包含的 value 值,井返回新设置的 value 值 。

  下面程序示范了 Map 的基本功能:

MapTest.java

public class MapTest
{
  public static void main(String[] args)
  {
    Map map = new HashMap();
    // 成对放入多个key-value对
    map.put("疯狂Java讲义" , 109);
    map.put("疯狂iOS讲义" , 10);
    map.put("疯狂Ajax讲义" , 79);
    // 多次放入的key-value对中value可以重复
    map.put("轻量级Java EE企业应用实战" , 99);
    // 放入重复的key时,新的value会覆盖原有的value
    // 如果新的value覆盖了原有的value,该方法返回被覆盖的value
    System.out.println(map.put("疯狂iOS讲义" , 99)); // 输出10
    System.out.println(map); // 输出的Map集合包含4个key-value对
    // 判断是否包含指定key
    System.out.println("是否包含值为 疯狂iOS讲义 key:"
      + map.containsKey("疯狂iOS讲义")); // 输出true
    // 判断是否包含指定value
    System.out.println("是否包含值为 99 value:"
      + map.containsValue(99)); // 输出true
    // 获取Map集合的所有key组成的集合,通过遍历key来实现遍历所有key-value对
    for (Object key : map.keySet() )
    {
      // map.get(key)方法获取指定key对应的value
      System.out.println(key + "-->" + map.get(key));
    }
    map.remove("疯狂Ajax讲义"); // 根据key来删除key-value对。
    System.out.println(map); // 输出结果不再包含 疯狂Ajax讲义=79 的key-value对
  }
}

Java 8 除为 Map 增加 了 remove(Object key , Object value)默认方法之外,还增加了如下方法:

  • Object compute(Object key, BiFunction remappingFunction) : 该方法使用  remappingFunction 根据原 key-value 对计算一个新 value 。 只要新 value 不为 null. 就使用新  value 覆盖原 value ; 如果原value 不为 null ,但新 value 为 null ,则删除原 key-value  对;如果原 value 、新 value 同时为 null ,那么该方法不改变任何 key-value 对,直接返回 null 。
  • Object  computeIfAbsent(Object key, Function mappingFunction): 如果传给该方法的 key  参数在Map 中对应的 value 为 null ,则使用 mappingFunction 根据 key 计算一个新的结果,如果计算结果不为  null ,则用计算结果覆盖原有的value 。 如果原 Map 原来不包括该 key,那么该方法可能会添加一组 key-value 对 。
  • Object  computeIfPresent(Object key, BiFunction remappingFunction): 如果传给该方法的  key 参数在 Map 中对应的 value 不为 null. 该方法将使用 remappingFunction 根据原 key、 value  计算一个新的结果,如果计算结果不为 null. 则使用该结果覆盖原来的 value; 如果计算结果为 null.则删除原 key-value 对  。
  • void forEach(BiConsumer action): 该方法是 Java 8 为 Map 新增的 一个遍历 key-value 对的方法,通过该方法可以更简洁地遍历 Map 的 key-value 对 。
  • Object getOrDefault(Object key, V defaultValue) : 获取指定 key 对应的 value 。 如果该 key 不存在 ,则返回 defaultValue 。
  • Object  merge(Object key, Object value, BiFunction remappingFunction): 该方法会先根据  key 参数获取该 Map 中对应的 value 。 如果获取的 value 为 null. 则直接用传入的 value 覆盖原有的  value(在这种情况下,可能要添加一组 key-value 对) ;如果获取的 value 不为 null  ,则使用remappingFunction 函数根据原 value 、 新 value 计算 一个新的结果,并用得到的结果去覆盖原有的  value 。
  • Object putlfAbsent(Object key, Object value): 该方法会自动检测指定  key 对应的 value 是否为 null,如果该 key 对应的 value 为 null. 该方法将会用新 value 代替原来的  null 值 。
  • Object replace(Object key, Object value): 将 Map 中指定 key  对应的 value 替换成新 value 。与传统put()方法不同的是 , 该方法不可能添加新的 key-value 对 。 如果尝试替换 的  key 在原 Map 中不存在,该方法不会添加 key-value 对,而是返回 null 。
  • boolean  replace(K key, V oldValue, V newValue): 将 Map 中指定 key-value 对的原 value  替换成新value 。 如果在 Map 中找到指定的 key-value 对,则执行替换并返回 true ,否则返回 false 。
  • replaceAll(BíFunction  function): 该力活使用 BiFunction 别原 key-value 对执行计算,并将计算结果作为该 key-value 对的  value 值 。Object computeIfAbsent(Object key, Function mappingFunction):  如果传给该方法的 key 参数在Map 中对应的 value 为 null ,则使用 mappingFunction 根据 key  计算一个新的结果,如果计算结果不为 null ,则用计算结果覆盖原有的 value 。 如果原 Map 原来不包括该  key,那么该方法可能会添加一组 key-value 对 。
  • Object computeIfPresent(Object  key, BiFunction remappingFunction): 如果传给该方法的 key 参数在 Map 中对应的 value 不为  null. 该方法将使用 remappingFunction 根据原 key、 value 计算一个新的结果,如果计算结果不为 null.  则使用该结果覆盖原来的 value; 如果计算结果为 null.则删除原 key-value 对 。
  • void forEach(BiConsumer action): 该方法是 Java 8 为 Map 新增的 一个遍历 key-value 对的方法,通过该方法可以更简洁地遍历 Map 的 key-value 对 。
  • Object getOrDefault(Object key, V defaultValue) : 获取指定 key 对应的 value 。 如果该 key 不存在 ,则返回 defaultValue 。
  • Object  merge(Object key, Object value, BiFunction remappingFunction): 该方法会先根据  key 参数获取该 Map 中对应的 value 。 如果获取的 value 为 null. 则直接用传入的 value 覆盖原有的  value(在这种情况下,可能要添加一组 key-value 对) ;如果获取的 value 不为 null  ,则使用remappingFunction 函数根据原 value 、 新 value 计算 一个新的结果,并用得到的结果去覆盖原有的value  。
  • Object putlfAbsent(Object key, Object value): 该方法会自动检测指定 key  对应的 value 是否为 null,如果该 key 对应的 value 为 null. 该方法将会用新 value 代替原来的 null 值 。
  • Object  replace(Object key, Object value): 将 Map 中指定 key 对应的 value 替换成新 value  。与传统put()方法不同的是 , 该方法不可能添加新的 key-value 对 。 如果尝试替换 的 key 在原 Map  中不存在,该方法不会添加 key-value 对,而是返回 null 。
  • boolean replace(K key, V  oldValue, V newValue): 将 Map 中指定 key-value 对的原 value 替换成新value 。 如果在 Map  中找到指定的 key-value 对,则执行替换并返回 true ,否则返回 false 。
  • replaceAll(BíFunction function): 该力活使用 BiFunction 别原 key-value 对执行计算,并将计算结果作为该 key-value 对的 value 值 。

API:java.util.Map

HashMap 和 Hashtable 实现类

图三:HashMap继承示意图

image.png

HashMap 和 Hashtable 都是 Map 接口的典型实现类,它们之间的关系完全类似于 ArrayList 和 Vector的关系。

Java 8 改进了 HashMap 的实现,使用 HashMap 存在 key 冲突时依然具有较好的性能。

 除此之外 , Hashtable 和 HashMap 存在两点典型区别 。

  • Hashtable 是一个线程安全的 Map 实现,但 HashMap 是线程不安全的实现,所以 HashMap 比Hashtable 的性能高一 点;但如果有多个线程访问同 一个 Map 对象时,使用 Hashtable 实现类会更好。
  • Hashtable  不允许使用 null 作为 key 和 value ,如果试图把 null 值放进 Hashtable 中,将会引发  NullPointerException 异常 ; 但 HashMap 可以使用 null 作为 key 或 value 。

与 Vector 类似的是,应当尽量少用 Hashtable实现类,即使需要创建线程安全的 Map 实现类,也无须使用 Hashtable 实现类,可以通过 Collections 工具类把 HashMap 变成线程安全的 。

为了成功地在 HashMap 、 Hashtable 中存储、获取对象,用作 key 的对象必须实现 hashCode()方法和 equals()方法 。

与 HashSet 集合不能保证元素的顺序一样, HashMap 、 Hashtable 也不能保证其中 key-value 对的顺序 。 类似于 HashSet , HashMap 、 Hashtable 判断两个 key 相等的标准也是:两个 key 通过 equals()方法比较返回 true ,两个 key 的 hashCode 值也相等 。

除此之外, HashMap 、 Hashtable 中还包含一个 containsValue()方法,用于判断是否包含指定的 value 。

HashMap 、 Hashtable 判断两个 value 相等的标准更简单 : 只要两个对象通过 equals()方法比较返回 true 即可 。

 下面程序示范了 Hashtable 判断两个 key相等的标准和两个 value 相等的标准 :

HashtableTest.java

class A
{
  int count;
  public A(int count)
  {
    this.count = count;
  }
  // 根据count的值来判断两个对象是否相等。
  public boolean equals(Object obj)
  {
    if (obj == this)
      return true;
    if (obj != null && obj.getClass() == A.class)
    {
      A a = (A)obj;
      return this.count == a.count;
    }
    return false;
  }
  // 根据count来计算hashCode值。
  public int hashCode()
  {
    return this.count;
  }
}
class B
{
  // 重写equals()方法,B对象与任何对象通过equals()方法比较都返回true
  public boolean equals(Object obj)
  {
    return true;
  }
}
public class HashtableTest
{
  public static void main(String[] args)
  {
    Hashtable ht = new Hashtable();
    ht.put(new A(60000) , "疯狂Java讲义");
    ht.put(new A(87563) , "轻量级Java EE企业应用实战");
    ht.put(new A(1232) , new B());
    System.out.println(ht);
    // 只要两个对象通过equals比较返回true,
    // Hashtable就认为它们是相等的value。
    // 由于Hashtable中有一个B对象,
    // 它与任何对象通过equals比较都相等,所以下面输出true。
    System.out.println(ht.containsValue("测试字符串")); // ① 输出true
    // 只要两个A对象的count相等,它们通过equals比较返回true,且hashCode相等
    // Hashtable即认为它们是相同的key,所以下面输出true。
    System.out.println(ht.containsKey(new A(87563)));   // ② 输出true
    // 下面语句可以删除最后一个key-value对
    ht.remove(new A(1232));    //③
    System.out.println(ht);
  }
}

值得一提的是: 虽然容器号称存储的是 Java 对象,但实际上并不会真正将 Java 对象放入容器中,只是在容器中保留这些对象的引用,而这些引用变量指向了我们要实际保存的 Java 对象。

图四:HashMap存储对象示意图

image.png

API:java.util.HashMap

API:java.util.Hashtable

LinkedHashMap 实现类

HashSet 有一个 LinkedHashSet 子类, HashMap 也有 一个 LinkedHashMap 子类 ;  LinkedHashMap 也使用双向链表来维护 key-value 对的次序(其实只需要考虑、 key 的次序) , 该链表负责维护 Map  的迭代顺序,迭代顺序与 key-value 对的插入顺序保持一致 。

LinkedHashMap 可以避免对 HashMap 、 Hashtable 里的 key-value 对进行排序(只要插入 key-value对时保持顺序即可),同时又可避免使用 TreeMap 所增加的成本 。

LinkedHashMap 需要维护元素的插入顺序,因此性能略低于 HashMap 的性能;但因为 它  以链表来维护内部顺序,所以在迭代访问 Map 里的全部元素时将有较好的性能 。 下面程序示范了 LinkedHashMap的功能:迭代输出  LinkedHashMap 的元素时,将会按添加 key-value 对的顺序输出 :

LinkedHashMapTest.java

public class LinkedHashMapTest
{
  public static void main(String[] args)
  {
    LinkedHashMap scores = new LinkedHashMap();
    scores.put("语文" , 80);
    scores.put("英文" , 82);
    scores.put("数学" , 76);
    // 调用forEach方法遍历scores里的所有key-value对
    scores.forEach((key, value) -> System.out.println(key + "-->" + value));
  }
}

API:java.util.LinkedHashMap

Properties 类

Properties 类是 Hashtable 类的子类 ,该类对象在处理属性文件时特别方便 (Windows  操作平台上的ini文件就是一种属性文件)。 Properties 类可 以把 Map对象和属性文件关联起来,从而可以把 Map 对象中的  key-value 对写入属性文件中,也可以把属性文件中的"属性名=属性值 "加载到 Map 对象中 。  由于属性文件里的属性名、属性值只能是字符串类型,所以 Properties 里 的 key、value 都是字符串类型。

 该类提供了如下三个方法来修改 Properties 里的 key 、 value 值 :

  • String getProperty(String key): 获取 Properties 中指定属性 名对应 的属性值,类似于 Map 的get(Object key)方法 。
  • String getProperty(String key, String defaultValue): 该方法与前一个方法基本相似 。 该方法多一个功能,如果 Properties 中不存在指定的 key 时,则该方法指定默认值 。
  • Object setProperty(String key, String value): 设置属 性值,类似于 Hashtable 的 put()方法 。除此之外,它还提供了两个读写属性文件的方法 。
  • void  load(InputStream inStream): 从属性文件 ( 以输入流表示)中加载 key-value  对,把加载到的key-value 对追加到 Properties 里( Properties 是 Hash table 的 子类,它不保证  key-value 对之间的次序)。
  • void store(OutputStream out, String comments): 将 Properties 中的 key-value 对输出到指定的属性文件(以输出流表示)中。

 下面程序示范了 Properties 类的用法:

PropertiesTest.java

public class PropertiesTest
{
  public static void main(String[] args)
    throws Exception
  {
    Properties props = new Properties();
    // 向Properties中增加属性
    props.setProperty("username" , "yeeku");
    props.setProperty("password" , "123456");
    // 将Properties中的key-value对保存到a.ini文件中
    props.store(new FileOutputStream("a.ini")
      , "comment line");   //①
    // 新建一个Properties对象
    Properties props2 = new Properties();
    // 向Properties中增加属性
    props2.setProperty("gender" , "male");
    // 将a.ini文件中的key-value对追加到props2中
    props2.load(new FileInputStream("a.ini") );   //②
    System.out.println(props2);
  }
}

API:java.util.Properties

SortedMap 接口和 TreeMap 实现类

图五:TreeMap继承示意图

正如 Set 接口派生出 SortedSet 子接口, SortedSet 接口有一个 TreeSet 实现类一样, Map 接口也派生出一个 SortedMap 子接口, SortedMap 接口也有一个 TreeMap 实现类 。

TreeMap 就是 一个红黑树数据结构 , 每个 key-value 对即作为红黑树的一个节点 。 TreeMap  存储key-value 对(节点)时, 需要根据 key 对节点进行排序 。 TreeMap 可以保证所有的 key-value  对处于有序状态。

图六:TreeMap存储数据结构示意图

TreeMap 也有两种排序方式:

  • 自然排序 : TreeMap 的所有 key 必须实现 Comparable 接口,而且所有的 key 应该是同一个类的对象,否则将会抛出 ClassCastException 异常 。
  • 定制排序 : 创建 TreeMap 时,传入一个 Comparator 对象, 该对象负责对 TreeMap 中的所有 key进行排序 。 采用定制排序时不要求 Map的 key 实现 Comparable 接口 。

类似于 TreeSet 中判断两个元素相等的标准. TreeMap 中判断两个 key 相等的标准是:两个 key 通过 compareTo()方法返回 0, TreeMap 即认为这两个 key 是相等的 。

与 TreeSet 类似的是. TreeMap 中也提供了 一系列根据 key 顺序访问 key-value 对的方法。

  • Map.Entry fIrstEntry(): 返回该 Map 中 最小 key 所对应的 key-value 对,如果该 Map 为 空, 则返回 null 。
  • Object fIrstKey(): 返回该 Map 中的最小 key 值,如果该 Map 为空,则返回 null 。
  • Map.Entry lastEntryO: 返回该 Map 中 最大 key 所对应的 key-value 对,如果该 Map 为空或不存在这样的 key-value对,则都返回 null 。
  • Object lastKeyO: 返回该 Map 中的最大 key 值,如果该 Map 为空或不存在这样的 key. 则都返回 null 。
  • Map.Entry  higherEntry(Object key): 返回 该 Map 中位于 key 后 一位 的 key-value 对 ( 即大于指定key  的最小 key 所对应的 key-value 对) 。 如果该 Map 为 空 ,则返回 null 。
  • Object higherKey(Object key): 返回 该 Map 中 位于 key 后一位的 key 值(即大于指定 key 的 最小key 值) 。 如果 该 Map 为 空或不存在这样 的 key-value 对,则都返回 null 。
  • Map.En町,  lowerEntry(Object key): 返回该 Map 中 位于 key 前一位的 key-value 对 ( 即小于指定key  的最大 key 所对应的 key-value 对 ) 。 如果该 Map 为 空或不存在这样 的 key-value 对,则都返回 null 。
  • Object lowerKey(Object key): 返回该 Map 中位于 key 前一位的 key 值(即小于指定 key 的最大
    key 值) 。 如果 该 Map 为 空或不存在这样的 key. 则都返 回 null 。
  • NavigableMap  subMap(Object 台omKey, boolean fromInclusive, Object toKey, boolean  toInclusive):返回该 Map 的子 Map. 其 key 的范围是从 fromKey (是否包括取决于第二个参数) 到 toKey  (是否包括取决于第四个参数) 。
  • SortedMap subMap(Object fromKey, Object toKey): 返回该 Map 的子 Map. 其 key 的 范围是从fromKey (包括)到 toKey (不包括) 。
  • SortedMap tailMap(Object fromKey): 返回该 Map 的子 Map. 其 key 的 范围是大于fomKey (包括)的所有 key 。
  • NavigableMap tailMap(Object fromKey, boolean inclusive): 返回该 Map 的子 Map. 其 key 的范围是大于 fromKey (是否包括取决于第二个参数)的所有 key 。
  • SortedMap headMap(Object toKey): 返 回该 Map 的子 Map 。其 key 的范围是小于 toKey (不包括)的所有 key 。
  • NavigableMap headMap(Object toKey,boolean inclusive): 返回 该 Map 的子 Map。其 key 的范围是小于 toKey (是否包括取决于第二个参数) 的所有 key 。

 下面以自然排序为例,介绍 TreeMap 的基本用法:

TreeMapTest.java

class R implements Comparable
{
  int count;
  public R(int count)
  {
    this.count = count;
  }
  public String toString()
  {
    return "R[count:" + count + "]";
  }
  // 根据count来判断两个对象是否相等。
  public boolean equals(Object obj)
  {
    if (this == obj)
      return true;
    if (obj != null && obj.getClass() == R.class)
    {
      R r = (R)obj;
      return r.count == this.count;
    }
    return false;
  }
  // 根据count属性值来判断两个对象的大小。
  public int compareTo(Object obj)
  {
    R r = (R)obj;
    return count > r.count ? 1 :
      count < r.count ? -1 : 0;
  }
}
public class TreeMapTest
{
  public static void main(String[] args)
  {
    TreeMap tm = new TreeMap();
    tm.put(new R(3) , "轻量级Java EE企业应用实战");
    tm.put(new R(-5) , "疯狂Java讲义");
    tm.put(new R(9) , "疯狂Android讲义");
    System.out.println(tm);
    // 返回该TreeMap的第一个Entry对象
    System.out.println(tm.firstEntry());
    // 返回该TreeMap的最后一个key值
    System.out.println(tm.lastKey());
    // 返回该TreeMap的比new R(2)大的最小key值。
    System.out.println(tm.higherKey(new R(2)));
    // 返回该TreeMap的比new R(2)小的最大的key-value对。
    System.out.println(tm.lowerEntry(new R(2)));
    // 返回该TreeMap的子TreeMap
    System.out.println(tm.subMap(new R(-1) , new R(4)));
  }
}

API:java.util.TreeMap

API:java.util.SortedMap

IdentityHashMap 实现类

这个 Map 实现类的实现机制与 HashMap 基本相似,但它在处理两个 key 相等时比较独特:在IdentityHashMap  中,当且仅当两个 key 严格相等 (key1 == key2) 时, IdentityHashMap 才认为两个 key相等:对于普通的  HashMap 而言,只要 key1和 key2 通过 equals()方法比较返回 true ,且它们的 hashCode值相等即可。

在实现对象遍历算法(如对象串行化)时, 这个类非常有用, 可以用来跟踪每个对象的遍历状况。

IdentityHashMapTest.java

public class IdentityHashMapTest
{
  public static void main(String[] args)
  {
    IdentityHashMap ihm = new IdentityHashMap();
    // 下面两行代码将会向IdentityHashMap对象中添加两个key-value对
    ihm.put(new String("语文") , 89);
    ihm.put(new String("语文") , 78);
    // 下面两行代码只会向IdentityHashMap对象中添加一个key-value对
    ihm.put("java" , 93);
    ihm.put("java" , 98);
    System.out.println(ihm);
  }
}

API:java.util.IdentityHashMap

EnumMap 实现类

EnumMap 是一个与枚举类一起使用的 M叩实现, EnumMap 中的所有 key 都必须是单个枚举类的枚举值 。 创建 EnumMap 时必须显式或隐式指定它对应的枚举类。 EnumMap 具有如下特征。

  • Enur出1ap 在内部以数组形式保存,所以这种实现形式非常紧凑、高效。
  • EnumMap 根据 key 的自然顺序(即枚举值在枚举类中的定义顺序)来维护 key-value 对的顺序。当程序通过 keySet() 、 entrySet() 、 values()等方法遍历 EnumMap 时可以看到这种顺序 。
  • EnumMap  不允许使用 null 作为 key , 但允许使用 null 作为 value 。如果试图使用 null 作为 key时将抛出  NullPointerException 异常。如果只是查询是否包含值为 null 的 key,或只是删除值为null 的 key  ,都不会抛出异常。

 与创建普通的 Map 有所区别的是,创建 EnumMap 时必须指定一个枚举类,从而将该 EnurnMap 和指定枚举类关联起来 :

EnumMapTest.java

enum Season
{
  SPRING,SUMMER,FALL,WINTER
}
public class EnumMapTest
{
  public static void main(String[] args)
  {
    // 创建EnumMap对象,该EnumMap的所有key都是Season枚举类的枚举值
    EnumMap enumMap = new EnumMap(Season.class);
    enumMap.put(Season.SUMMER , "夏日炎炎");
    enumMap.put(Season.SPRING , "春暖花开");
    System.out.println(enumMap);
  }
}

API:java.util.EnumMap

各 Map 实现类的性能分析

对于 Map 的常用实现类而言 , 虽然 HashMap 和 Hashtable 的实现机制几乎一样 ,但由于 Hashtable是一个古老的、线程安全的集合,因此 HashMap 通常比 Hashtable 要快 。

TreeMap 通常比 HashMap 、 Hashtable 要慢( 尤其在插入、删除 key-value 对时更慢),因为  TreeMap底层采用红黑树来管理 key-value 对(红黑树的每个节点就是一个 key-value 对) 。使用 TreeMap  有一个好处: TreeMap 中的 key-value 对总是处于有序状态 ,无须专门进行排序操作 。当 TreeMap 被填充之后,就可以调用  keySetO ,取得由 key 组成的 Set,然后使用 toAηayO方法生成 key的数组,接下来使用Arrays 的  binarySearchO方法在己排序的数组中快速地查询对象。

对于一般的应用场景 , 程序应该多考虑使用 HashMap ,因为 HashMap 正是为快速查询设计的(HashMap  底层其实也是采用数组来存储 key-value 对 ) 。 但如果程序需要一个总是排好序的 Map 时,则可以考虑使用 TreeMap 。

LinkedHashMap 比 HashMap 慢一 点,因为它需要维护链表来保持 Map 中 key-value 时的 添加顺序 。

EnumMap 的性能最好 ,但它只能使用同一个枚举类的枚举值作为 key 。


参考:

【1】:《Java疯狂讲义》

【2】:《Java核心技术 卷 一》

【3】:Java技术驿站:【死磕 Java 集合】— 总结篇

【4】:方志朋的专栏:Java基础:Java容器之HashMap

【5】:方志朋的专栏:Java基础:JAVA Hashmap的死循环及Java8的修复

【6】:廖雪峰的官方网站:使用Properties

【7】:Java技术驿站:【死磕 Java 集合】— TreeMap源码分析(一)

【8】:廖雪峰的官方网站:使用EnumMap


目录
相关文章
|
11天前
|
存储 Java 容器
Java一分钟之-高级集合框架:LinkedList与TreeSet
【5月更文挑战第17天】这篇博客对比了Java集合框架中的LinkedList和TreeSet。LinkedList是双向链表,适合中间插入删除,但遍历效率低且占用空间大;TreeSet基于红黑树,保证元素有序且不重复,插入删除速度较LinkedList慢但查找快。选择时需根据操作需求和性能考虑。
21 2
|
7天前
|
存储 Java 容器
Java一分钟之-高级集合框架:LinkedList与TreeSet
【5月更文挑战第21天】本文对比了Java集合框架中的LinkedList和TreeSet。LinkedList是双向链表,实现List接口,适合中间插入删除,但遍历效率低;TreeSet基于红黑树,实现Set接口,保证元素有序且无重复,插入删除速度较LinkedList慢,但查找排序快。选择时应根据具体需求考虑操作频率和排序需求。
20 1
|
13天前
|
存储 安全 算法
【常见集合】Java 常见集合重点解析
【常见集合】Java 常见集合重点解析
27 0
|
1天前
|
存储 安全 Java
JAVA :集合
JAVA :集合
17 0
|
1天前
|
Java 容器
Java集合类ArrayList应用 | 二维数组的集合类表示与杨辉三角实现
这是一个关于LeetCode第118题“杨辉三角”的问题解答摘要。题目要求生成一个杨辉三角的前n行,其中每一行都是由前一行的元素按规则生成的。杨辉三角的规律是:每一行的第一个和最后一个数是1,其他数是其上方两数之和。
17 4
|
1天前
|
Java
Java集合类ArrayList应用 | 如何在字符串s1中删除有在字符串s2出现的字符?
这是一个关于Java编程面试题的摘要,题目要求从字符串s1中删除s2中存在的字符。解题思路包括使用ArrayList或StringBuilder实现。ArrayList实现时,遍历s1,如果字符不在s2中,则添加到ArrayList;StringBuilder实现有两种方法,一是新建StringBuilder并追加s1,然后遍历删除s2中的字符,二是直接在原地修改s1的StringBuilder对象。代码示例中展示了这些方法。
20 3
|
4天前
|
存储 算法 Java
Java集合类深度解析与实践应用
Java集合类深度解析与实践应用
236 1
|
4天前
|
Java 程序员
JAVA集合框架详解与实战
这篇文档介绍了Java集合框架,包括Collection、List、Set和Queue接口及其常用实现类。List允许重复元素,如ArrayList和LinkedList;Set不允许重复,如HashSet和TreeSet;Queue支持队列操作,如LinkedList。文章通过代码示例展示了这些接口的使用方法,强调了集合框架在实际开发中的重要性及选择合适集合类型以优化代码的必要性。
|
6天前
|
存储 Java
【JAVA学习之路 | 进阶篇】集合框架概述
【JAVA学习之路 | 进阶篇】集合框架概述
|
9天前
|
安全 Java 容器
Java一分钟之-并发编程:线程安全的集合类
【5月更文挑战第19天】Java提供线程安全集合类以解决并发环境中的数据一致性问题。例如,Vector是线程安全但效率低;可以使用Collections.synchronizedXxx将ArrayList或HashMap同步;ConcurrentHashMap是高效线程安全的映射;CopyOnWriteArrayList和CopyOnWriteArraySet适合读多写少场景;LinkedBlockingQueue是生产者-消费者模型中的线程安全队列。注意,过度同步可能影响性能,应尽量减少共享状态并利用并发工具类。
24 2