AbstractMap详解

妖狐艹你老母 2024-04-21 19:10 57阅读 0赞

> Abstract 内容很简单，但是中间还是有一些细节需要注意

学习了 Map 接口源码后，开始下一步 **AbstractMap**

首先我们先回顾一下Map 的族谱

### 1、Map 族谱 ###

![img][]

从图谱中可以明显的看出 **AbstractMap** 扮演了一个很重要的角色。

下面我们来看看 **AbsctractMap** 中到底有哪些东西吧

### 2、接口定义 ###

// 包：java.util
     package java.util;
     import java.util.Map.Entry;
     
     public abstract class AbstractMap<K,V> implements Map<K,V> {
        }

### 3、属性字段 ###

在 **AbstractMap** 类中，一共只有两个字段 keySet 、values

transient Set<K>        keySet;
         transient Collection<V> values;

按照基本知识，这两个字段是不可被序列化的

> 不可序列化：被 static 修饰、被 transient 修饰的字段

### 4、内部类 ###

开始之前我们还是简单回顾一下 **Entry<K,V>**

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">类型</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>K getKey()</strong></td> 
   <td align="left">abstract</td> 
   <td align="left">获得键</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>V getValue()</strong></td> 
   <td align="left">abstract</td> 
   <td align="left">获得值</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>V setValue(V value)</strong></td> 
   <td align="left">abstract</td> 
   <td align="left">设置值</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>boolean equals(Object o)</strong></td> 
   <td align="left">abstract</td> 
   <td align="left">判断与另一个对象是否相等</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>int hashCode()</strong></td> 
   <td align="left">abstract</td> 
   <td align="left">获取 Hash 值</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>&lt;K extends Comparable&lt;? super K&gt;, V&gt; Comparator&lt;Map.Entry&lt;K,V&gt;&gt; comparingByKey()</strong></td> 
   <td align="left">static</td> 
   <td align="left">根据键比较大小，要求键的类型继承 Comparable</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>&lt;K, V extends Comparable&lt;? super V&gt;&gt; Comparator&lt;Map.Entry&lt;K,V&gt;&gt; comparingByValue()</strong></td> 
   <td align="left">static</td> 
   <td align="left">根据值比较大小，要求值的类型继承 Comparable</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>&lt;K, V&gt; Comparator&lt;Map.Entry&lt;K, V&gt;&gt; comparingByKey(Comparator&lt;? super K&gt; cmp)</strong></td> 
   <td align="left">static</td> 
   <td align="left">自定义比较器，根据键比较大小</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>&lt;K, V&gt; Comparator&lt;Map.Entry&lt;K, V&gt;&gt; comparingByValue(Comparator&lt;? super V&gt; cmp)</strong></td> 
   <td align="left">static</td> 
   <td align="left">自定义比较器，根据值比较大小</td> 
  </tr> 
 </tbody> 
</table>

#### 4.1 SimpleEntry ####

这一个类是继承了 Map 中的 内部接口 Entry<K,V>

而这里的 SimpleEntry<K,V> 不仅继承了 Map.Entry<K,V> ，还继承了 序列化的接口

##### 4.1.1 构造方法 #####

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>SimpleEntry(K key, V value)</strong></td> 
   <td align="left">通过键值对初始化对象</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>SimpleEntry(Entry&lt;? extends K, ? extends V&gt; entry)</strong></td> 
   <td align="left">通过继承了Map.Entry&lt;K,V&gt; 的类来初始化，获取其中的 K，V 进行初始化</td> 
  </tr> 
 </tbody> 
</table>

##### 4.1.2 普通方法 #####

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>K getKey()</strong></td> 
   <td align="left">获取键</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>V getValue()</strong></td> 
   <td align="left">获取值</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>V setValue(V value)</strong></td> 
   <td align="left">设置新的值，并且返回旧值</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>boolean equals(Object o)</strong></td> 
   <td align="left">如果对象是 Map.Entry&lt;K,V&gt; 的实现类，分别比较两个类的键、值是否相同</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>int hashCode()</strong></td> 
   <td align="left">计算该对象的 hash 值</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>String toString()</strong></td> 
   <td align="left">将该对象转化为字符串</td> 
  </tr> 
 </tbody> 
</table>

##### 源码 #####

public static class SimpleEntry<K,V>
             implements Entry<K,V>, java.io.Serializable
         {
        
             private static final long serialVersionUID = -8499721149061103585L;
     
             // 不可变引用
             private final K key;
             private V value;
     
             /** 通过指定键值对初始化对象 */
             public SimpleEntry(K key, V value) {
        
                 this.key   = key;
                 this.value = value;
             }
     
             /** 通过继承了Map.Entry<K,V> 的类来初始化，获取其中的 K，V 进行初始化 */
             public SimpleEntry(Entry<? extends K, ? extends V> entry) {
        
                 this.key   = entry.getKey();
                 this.value = entry.getValue();
             }
     
            /** 获取键 */
             public K getKey() {
        
                 return key;
             }
             
             /** 获取值 */
             public V getValue() {
        
                 return value;
             }
     
             /** 设置新的值，并且返回旧值 */
             public V setValue(V value) {
        
                 V oldValue = this.value;
                 this.value = value;
                 return oldValue;
             }
     
             /** 如果对象是 Map.Entry<K,V> 的实现类，分别比较两个类的键、值是否相同 */
             public boolean equals(Object o) {
        
                 if (!(o instanceof Map.Entry))
                     return false;
                 Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                 return eq(key, e.getKey()) && eq(value, e.getValue());
             }
     
             /** 计算该对象的 hash 值 */
             public int hashCode() {
        
                 return (key   == null ? 0 :   key.hashCode()) ^
                        (value == null ? 0 : value.hashCode());
             }
     
             /** 将对象转换为字符串，为方便输出 */
             public String toString() {
        
                 return key + "=" + value;
             }
         }

#### 4.2 SimpleImmutableEntry ####

##### 4.2.1 接口定义 #####

同 SimpleEntry 一样，都继承了 Map.Entry<K,V> 和 序列化接口

public static class SimpleImmutableEntry<K,V>
             implements Entry<K,V>, java.io.Serializable{
        }

##### 4.2.2 构造方法 #####

<table> 
 <thead> 
  <tr> 
   <th align="left"><strong>方法</strong></th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>SimpleImmutableEntry(K key, V value)</strong></td> 
   <td align="left">通过键值对初始化对象</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>SimpleImmutableEntry(Entry&lt;? extends K, ? extends V&gt; entry)</strong></td> 
   <td align="left">通过继承了Map.Entry&lt;K,V&gt; 的类来初始化，获取其中的 K，V 进行初始化</td> 
  </tr> 
 </tbody> 
</table>

##### 4.2.3 普通方法 #####

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>K getKey()</strong></td> 
   <td align="left">获取键</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>V getValue()</strong></td> 
   <td align="left">获取值</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>V setValue(V value)</strong></td> 
   <td align="left">这里并不能使用这个方法，调用这个方法将会直接抛出错误</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>boolean equals(Object o)</strong></td> 
   <td align="left">如果对象是 Map.Entry&lt;K,V&gt; 的实现类，分别比较两个类的键、值是否相同</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>int hashCode()</strong></td> 
   <td align="left">计算该对象的 hash 值</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>String toString()</strong></td> 
   <td align="left">将该对象转化为字符串</td> 
  </tr> 
 </tbody> 
</table>

##### 源码 #####

public static class SimpleImmutableEntry<K,V>
             implements Entry<K,V>, java.io.Serializable
         {
        
             private static final long serialVersionUID = 7138329143949025153L;
     
             // 不可变引用键值对
             private final K key;
             private final V value;
     
             /** 通过键值对初始化对象 */
             public SimpleImmutableEntry(K key, V value) {
        
                 this.key   = key;
                 this.value = value;
             }
     
             /** 通过继承了Map.Entry<K,V> 的类来初始化，获取其中的 K，V 进行初始化 */
             public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {
        
                 this.key   = entry.getKey();
                 this.value = entry.getValue();
             }
     
             /** 获取键 */
             public K getKey() {
        
                 return key;
             }
     
             /** 获取值 */
             public V getValue() {
        
                 return value;
             }
     
             /** 这里并不能使用这个方法，调用这个方法将会直接抛出错误 */
             public V setValue(V value) {
        
                 throw new UnsupportedOperationException();
             }
     
             /** 如果对象是 Map.Entry<K,V> 的实现类，分别比较两个类的键、值是否相同 */
             public boolean equals(Object o) {
        
                 if (!(o instanceof Map.Entry))
                     return false;
                 Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                 return eq(key, e.getKey()) && eq(value, e.getValue());
             }
     
             /** 计算该对象的 hash 值 */
             public int hashCode() {
        
                 return (key   == null ? 0 :   key.hashCode()) ^
                        (value == null ? 0 : value.hashCode());
             }
         
             /** 将该对象转化为字符串，多用于打印对象 */
             public String toString() {
        
                 return key + "=" + value;
             }
     
         }

#### 4.3 思考 ####

> Question:可以看到SimpleEntry 和 SimpleImmutableEntry 几乎是 95%相似的，为什么要写这么写？
> 
> 1、从方法区别上来看， **SimpleEntry** 是可变值，**SimpleImmutableEntry** 是值不可变的，也就是 SimpleEntry 的值可变
> 
> 2、从内部字段来看，**SimpleEntry** 只有键不可变， **SimpleImmutableEntry** 键值都不可变
> 
>     // SimpleEntry
>              private K key;
>              private final V value;
>              // SimpleImmutableEntry
>              private final K key;
>              private final V value;
>      /** 错误；
>          final Integer a = 1;
>           a = 2;
>      */

### 5、静态方法-eq ###

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">eq(Object o1, Object o2)</td> 
   <td align="left">如果两个对象都不为空，判断两个兑对象是否相等</td> 
  </tr> 
 </tbody> 
</table>

/** 如果两个对象都不为空，判断两个兑对象是否相等 */
         private static boolean eq(Object o1, Object o2) {
        
             return o1 == null ? o2 == null : o1.equals(o2);
         }

### 6、抽象方法-entrySet ###

entrySet 一般用于迭代的，将其中的数据取出

<table> 
 <thead> 
  <tr> 
   <th align="left"><strong>方法</strong></th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>Set&lt;Entry&lt;K,V&gt;&gt; entrySet()</strong></td> 
   <td align="left">将 Map 中的每一对键值对，存入Set中，常用于遍历</td> 
  </tr> 
 </tbody> 
</table>

public abstract Set<Entry<K,V>> entrySet();

### 7、普通方法 ###

#### 7.1 添加键值对 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>V put(K key, V value)</strong></td> 
   <td align="left">直接抛出异常，不可通过此方法新增键值对</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>void putAll(Map&lt;? extends K, ? extends V&gt; m)</strong></td> 
   <td align="left">将传入 Map 集合中的所有键值对添加到该 Map</td> 
  </tr> 
 </tbody> 
</table>

##### 7.1.1 put(K key, V value) #####

/** 直接抛出异常，不可通过此方法新增键值对 */
         public V put(K key, V value) {
        
             throw new UnsupportedOperationException();
         }

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

/** 将传入 Map 集合中的所有键值对添加到该 Map */
         public void putAll(Map<? extends K, ? extends V> m) {
        
             for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
                 put(e.getKey(), e.getValue());
         }

#### 7.2 获取数据 ####

<table> 
 <thead> 
  <tr> 
   <th align="left"><strong>说明</strong></th> 
   <th align="left">方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>V get(Object key)</strong></td> 
   <td align="left">通过键获取值</td> 
  </tr> 
 </tbody> 
</table>

/** 通过键获取值 */
         public V get(Object key) {
        
             // 将键值对存储到 Set 中，将其迭代
             Iterator<Entry<K,V>> i = entrySet().iterator();
             // 寻找键为null的值
             if (key == null) {
        
                 while (i.hasNext()) {
        
                     Entry<K,V> e = i.next();
                     if (e.getKey() == null)
                         return e.getValue();
                 }
             } else {
            //寻找 键不为 null 的的值
                 while (i.hasNext()) {
        
                     Entry<K,V> e = i.next();
                     if (key.equals(e.getKey()))
                         return e.getValue();
                 }
             }
             return null;
         }

#### 7.3 移除元素 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>V remove(Object key)</strong></td> 
   <td align="left">根据键值移除键值对，并且返回键对应的值</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>void clear()</strong></td> 
   <td align="left">清除 Map 中的所有的键值对</td> 
  </tr> 
 </tbody> 
</table>

##### 7.3.1 remove(Object key) #####

/** 根据键值移除键值对，并且返回键对应的值 */
         public V remove(Object key) {
        
             Iterator<Entry<K,V>> i = entrySet().iterator();
             Entry<K,V> correctEntry = null;
             if (key==null) {
        
                 while (correctEntry==null && i.hasNext()) {
        
                     Entry<K,V> e = i.next();
                     if (e.getKey()==null)
                         correctEntry = e;
                 }
             } else {
        
                 while (correctEntry==null && i.hasNext()) {
        
                     Entry<K,V> e = i.next();
                     if (key.equals(e.getKey()))
                         correctEntry = e;
                 }
             }
     
             V oldValue = null;
             if (correctEntry !=null) {
        
                 oldValue = correctEntry.getValue();
                 i.remove();
             }
             return oldValue;
         }

##### 7.3.2 clear() #####

/** 清除 Map 中的所有的键值对 */
         public void clear() {
        
             entrySet().clear();
         }

#### 7.4 对 Map 操作 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>int size()</strong></td> 
   <td align="left">获取 Map 中键值对的数量</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>Object clone()</strong></td> 
   <td align="left">将 Map 克隆，并将其中的 keySet 和 记录所有值得 values 集合清空</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>boolean isEmpty()</strong></td> 
   <td align="left">判断 Map 里面有没有东西</td> 
  </tr> 
 </tbody> 
</table>

##### 7.4.1 size() #####

/** 获取 Map 中键值对的数量 */
         public int size() {
        
             return entrySet().size();
         }

##### 7.4.2 clone() #####

/** 将 Map 克隆，并将其中的 keySet 和 记录所有值得 values 集合清空 */
         protected Object clone() throws CloneNotSupportedException {
        
             AbstractMap<?,?> result = (AbstractMap<?,?>)super.clone();
             result.keySet = null;
             result.values = null;
             return result;
         }

##### 7.4.3 sEmpty() #####

/** 判断 Map 里面有没有东西 */
         public boolean isEmpty() {
        
             return size() == 0;
         }

#### 7.5 为迭代而生 ★ ####

> 这两个方法的具体实现是典型的

抽象方法中 entrySet 同样也是，只不过这里没有实现

<table> 
 <thead> 
  <tr> 
   <th align="left">说明</th> 
   <th align="left">方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>Set keySet()</strong></td> 
   <td align="left">keySet() 方法是将 Map 中所有的键存储到一个 Set 集合中</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>Collection values()</strong></td> 
   <td align="left">将 Map 中的内容存储到 Collection 集合 中，进行返回</td> 
  </tr> 
 </tbody> 
</table>

##### 7.5.1 keySet #####

使用场景：遍历的时候，通过遍历Set 取出其中的 Key ，再通过 key 获取 Value

public Set<K> keySet() {
        
             Set<K> ks = keySet;
             if (ks == null) {
        
                 ks = new AbstractSet<K>() {
        
                     public Iterator<K> iterator() {
        
                         return new Iterator<K>() {
        
                             private Iterator<Entry<K,V>> i = entrySet().iterator();
     
                             public boolean hasNext() {
        
                                 return i.hasNext();
                             }
     
                             public K next() {
        
                                 return i.next().getKey();
                             }
     
                             public void remove() {
        
                                 i.remove();
                             }
                         };
                     }
     
                     public int size() {
        
                         return AbstractMap.this.size();
                     }
     
                     public boolean isEmpty() {
        
                         return AbstractMap.this.isEmpty();
                     }
     
                     public void clear() {
        
                         AbstractMap.this.clear();
                     }
     
                     public boolean contains(Object k) {
        
                         return AbstractMap.this.containsKey(k);
                     }
                 };
                 keySet = ks;
             }
             return ks;
         }

##### 7.5.2 values #####

/** 将 Map  中的内容存储到 Collection 中，进行返回 */
         public Collection<V> values() {
        
             Collection<V> vals = values;
             if (vals == null) {
        
                 vals = new AbstractCollection<V>() {
        
                     public Iterator<V> iterator() {
        
                         return new Iterator<V>() {
        
                             private Iterator<Entry<K,V>> i = entrySet().iterator();
     
                             public boolean hasNext() {
        
                                 return i.hasNext();
                             }
     
                             public V next() {
        
                                 return i.next().getValue();
                             }
     
                             public void remove() {
        
                                 i.remove();
                             }
                         };
                     }
     
                     public int size() {
        
                         return AbstractMap.this.size();
                     }
     
                     public boolean isEmpty() {
        
                         return AbstractMap.this.isEmpty();
                     }
     
                     public void clear() {
        
                         AbstractMap.this.clear();
                     }
     
                     public boolean contains(Object v) {
        
                         return AbstractMap.this.containsValue(v);
                     }
                 };
                 values = vals;
             }
             return vals;
         }

#### 7.6 查询 Map 是否有对应的 Key/Value ####

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>boolean containsKey(Object key)</strong></td> 
   <td align="left">判断 Map 中是否有该键</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>boolean containsValue(Object value)</strong></td> 
   <td align="left">判断 Map 中是否有该值</td> 
  </tr> 
 </tbody> 
</table>

##### 7.6.1 containsKey(Object key) #####

/** 判断 Map 中是否有该键 */
         public boolean containsKey(Object key) {
        
             Iterator<Map.Entry<K,V>> i = entrySet().iterator();
             if (key==null) {
        
                 while (i.hasNext()) {
        
                     Entry<K,V> e = i.next();
                     if (e.getKey()==null)
                         return true;
                 }
             } else {
        
                 while (i.hasNext()) {
        
                     Entry<K,V> e = i.next();
                     if (key.equals(e.getKey()))
                         return true;
                 }
             }
             return false;
         }

##### 7.6.2 containsValue(Object value) #####

/** 判断 Map 中是否有该值 */
         public boolean containsValue(Object value) {
        
             Iterator<Entry<K,V>> i = entrySet().iterator();
             if (value==null) {
        
                 while (i.hasNext()) {
        
                     Entry<K,V> e = i.next();
                     if (e.getValue()==null)
                         return true;
                 }
             } else {
        
                 while (i.hasNext()) {
        
                     Entry<K,V> e = i.next();
                     if (value.equals(e.getValue()))
                         return true;
                 }
             }
             return false;
         }

[img]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/21/8c687cf7841c43a3baf32a67ee9dad50.png