java.util.*中AbstractMap 源代码详解

港控/mmm° 2022-11-29 11:42 38阅读 0赞

### java.util.\*中AbstractMap 源代码详解 ###

*   *  核心方法
     *  int size()
     *  boolean isEmpty()
     *  boolean containsValue(Object value)
     *  boolean containsKey(Object key)
     *  V get(Object key)
     *  V put(K key, V value)
     *  V remove(Object key)
     *  void putAll()
     *  void clear()
     *  Set keySet()
     *  Collection values()
     *  boolean equals(Object o)
     *  int hashCode()
     *  String toString()

## 核心方法 ##

public abstract class AbstractMap<K,V> implements Map<K,V>
    
    int size() 获取集合容量大小[OK]
    boolean isEmpty() 判断对象容量大小是否为空[OK]
    boolean containsValue(Object value) 判断集合中是否包含某个值value[OK]
    boolean containsKey(Object key) 判断集合中是否包含某个键key[OK]
    V get(Object key) 根据key获取集合中存储的对象[OK]
    V put(K key, V value) 向集合对象中添加元素[OK]
    V remove(Object key) 根据key从集合对象中删除元素[OK]
    void putAll() 将一个集合对象中的元素存入另一个集合对象中[OK]
    void clear() 清空集合中的所有元素[OK]
    Set<K> keySet() 获取集合的keySet集合,里面包含所有的key[OK]
    Collection<V> values() 获取Map集合的所有value的Collection集合[OK]
    boolean equals(Object o) 比较两个集合对象是否相等[OK]
    int hashCode() 获取集合对象的HashCode值[OK]
    String toString() 获取集合对象的字符串形式{ key:value,key,value}[OK]

## int size() ##

/** * 获取集合容量大小 */
    public int size() { 
        return entrySet().size();
    }

## boolean isEmpty() ##

/** * 判断对象容量大小是否为空 */
    public boolean isEmpty() { 
        return size() == 0;
    }

## boolean containsValue(Object value) ##

/** * 判断集合中是否包含某个值value */
    public boolean containsValue(Object value) { 
    	//获取迭代器对象
        Iterator<Entry<K,V>> i = entrySet().iterator();
        //判断value是否为空
        if (value==null) { 
        	//遍历i迭代器
            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;
    }

## boolean containsKey(Object key) ##

/** * 判断集合中是否包含key */
    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;
    }

## V get(Object key) ##

/** * 根据key获取集合中的对象,如果没找到返回null */
    public V get(Object key) { 
        Iterator<Entry<K,V>> i = entrySet().iterator();
        if (key==null) { 
            while (i.hasNext()) { 
                Entry<K,V> e = i.next();
                if (e.getKey()==null)
                    return e.getValue();
            }
        } else { 
            while (i.hasNext()) { 
                Entry<K,V> e = i.next();
                if (key.equals(e.getKey()))
                    return e.getValue();
            }
        }
        return null;
    }

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

/** * 向集合对象中添加元素,交给子类去实现 */
    public V put(K key, V value) { 
        throw new UnsupportedOperationException();
    }

## V remove(Object key) ##

/** * 根据key从list集合对象中删除元素 */
    public V remove(Object key) { 
    	//获取iterator迭代器对象
        Iterator<Entry<K,V>> i = entrySet().iterator();
        //用来记录被key查找到的Entry对象
        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;
    }

## void putAll() ##

/** * 将一个集合中的所有元素,存入另一个集合中 */
    public void putAll(Map<? extends K, ? extends V> m) { 
    	//遍历Map中的所有元素
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            put(e.getKey(), e.getValue());
    }

## void clear() ##

/** * 清空集合中的所有元素 */
    public void clear() { 
        entrySet().clear();
    }

## Set keySet() ##

/** * 获取当前map的所有key的set集合(不可重复) */
    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;
    }

## Collection values() ##

/** * 获取Map集合的所有value的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;
    }

## boolean equals(Object o) ##

/** * 比较两个集合对象是否相等 */
    public boolean equals(Object o) { 
    	//判断内存地址是否一样
        if (o == this)
            return true;
    	//判断要比较对象是否为Map类型
        if (!(o instanceof Map))
            return false;
        //将Object对象强转为Map对象 
        Map<?,?> m = (Map<?,?>) o;
        //判断两个Map对象的元素个数
        if (m.size() != size())
            return false;
    
        try { 
        	//获取当前对象的迭代器对象
            Iterator<Entry<K,V>> i = entrySet().iterator();
            while (i.hasNext()) { 
            	//获取Entry对象
                Entry<K,V> e = i.next();
                K key = e.getKey();
                V value = e.getValue();
                if (value == null) { 
                	//!(m.get(key)==null如果根据key获取的value不等于null,则为true
                	//同时m包含key
                    if (!(m.get(key)==null && m.containsKey(key)))
                        return false;
                } else { 
                	//如果从m集合中根据key获取的值不等于value
                    if (!value.equals(m.get(key)))
                        return false;
                }
            }
        } catch (ClassCastException unused) { 
        	//捕获类转换异常(针对强转为Map对象)
            return false;
        } catch (NullPointerException unused) { 
            //捕获空指针异常(有多余的嫌疑)
            return false;
        }
    
        return true;
    }

## int hashCode() ##

/** * 获取集合对象的HashCode值(所有Entry对象的HashCode值加和) */
    public int hashCode() { 
        int h = 0;
        Iterator<Entry<K,V>> i = entrySet().iterator();
        while (i.hasNext())
            h += i.next().hashCode();
        return h;
    }

## String toString() ##

/** * 获取集合对象的字符串形式{key:value,key,value} */
    public String toString() { 
    	//获取Iterator迭代器对象
        Iterator<Entry<K,V>> i = entrySet().iterator();
        //如果迭代器中发现没有下一个元素
        if (! i.hasNext())
            return "{}";
    	//用来拼接toString的结果
        StringBuilder sb = new StringBuilder();
        sb.append('{');
        for (;;) { //等同于while(true)
        	//获取Entry对象
            Entry<K,V> e = i.next();
            K key = e.getKey();
            V value = e.getValue();
            sb.append(key   == this ? "(this Map)" : key);
            sb.append('=');
            sb.append(value == this ? "(this Map)" : value);
            if (! i.hasNext())
                return sb.append('}').toString();
            sb.append(',').append(' ');
        }
    }

> 学习Java的同学注意了！！！  
> 学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：543120397 我们一起学Java！