Java 集合系列（13）： AbstractMap抽象类源码

最新推荐文章于 2021-03-19 09:18:17 发布
最新推荐文章于 2021-03-19 09:18:17 发布
阅读量198 收藏
点赞数
分类专栏： 集合框架 文章标签： AbstractMap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oqkdws/article/details/79998300
版权 
package java.util;
import java.util.Map.Entry;

/**
 * @param <K> the type of keys maintained by this map
 * @param <V> the type of mapped values
 *
 * @author  Josh Bloch
 * @author  Neal Gafter
 * @see Map
 * @see Collection
 * @since 1.2
 */

   //抽象类,实现Map<K,V>方法  
public abstract class AbstractMap<K,V> implements Map<K,V> {
    
	/**
     * 构造函数（用于子类构造函数的调用，通常是隐式的）
     */
    protected AbstractMap() {
    }

    // Query Operations(查询操作)

    public int size() {
        return entrySet().size();
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    /**
     * 如果此映射将一个或多个键映射到指定值，则返回 true,允许为value为null值
     * @throws ClassCastException   
     * @throws NullPointerException
     */
    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;
    }

    /**
     * 如果此映射包含指定键的映射关系，则返回 true，允许为value为null值。
     *
     * @throws ClassCastException   
     * @throws NullPointerException 
     */
    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;
    }

    /**
     * 如果此映射包含指定键的映射关系，则返回 true。 
     *
     * @throws ClassCastException            
     * @throws NullPointerException         
     */
    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;
    }


    // Modification Operations(修改操作)

    
    //将指定的值与此映射中的指定键关联  
    //要实现可修改的映射，必须另外重写此类的 put 方法  
    public V put(K key, V value) {
        throw new UnsupportedOperationException();
    }

    /**
     * 如果存在一个键的映射关系，则将其从此映射中移除  
     *
     * @throws UnsupportedOperationException 
     * @throws ClassCastException            
     * @throws NullPointerException          
     */
    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;
    }


    // Bulk Operations(批量操作)

    /**
     * 将指定地图的所有映射复制到此映射（可选操作）
     * 
     * @throws UnsupportedOperationException 
     * @throws ClassCastException            
     * @throws NullPointerException          
     * @throws IllegalArgumentException      
     */
    public void putAll(Map<? extends K, ? extends V> m) {
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            put(e.getKey(), e.getValue());
    }

    
    public void clear() {
        entrySet().clear();
    }


    // Views (视图)

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

    
    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;
    }

   
    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;
    }

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


    // Comparison and hashing (比较和散列)

    
    public boolean equals(Object o) {
        if (o == this)       //比较地址
            return true;

        if (!(o instanceof Map))  //意思是不属于Map类型
            return false;
        Map<?,?> m = (Map<?,?>) o;
        if (m.size() != size())   //是Map类型但是长度不一样
            return false;

        //比较里面的Entry<K,V>是不是一样
        try {
            Iterator<Entry<K,V>> i = entrySet().iterator();
            while (i.hasNext()) {
                Entry<K,V> e = i.next();
                K key = e.getKey();
                V value = e.getValue();
                if (value == null) {
                    if (!(m.get(key)==null && m.containsKey(key)))
                        return false;
                } else {
                    if (!value.equals(m.get(key)))
                        return false;
                }
            }
        } catch (ClassCastException unused) {
            return false;
        } catch (NullPointerException unused) {
            return false;
        }

        return true;
    }

    //Map<K,V>的hash值为每个映射的hash总和  
    public int hashCode() {
        int h = 0;
        Iterator<Entry<K,V>> i = entrySet().iterator();
        while (i.hasNext())
            h += i.next().hashCode();
        return h;
    }

    
    public String toString() {
        Iterator<Entry<K,V>> i = entrySet().iterator();
        if (! i.hasNext())
            return "{}";

        StringBuilder sb = new StringBuilder();
        sb.append('{');
        for (;;) {
            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(' ');
        }
    }

    //返回此 AbstractMap 实例的浅表副本：不复制键和值本身。 
    protected Object clone() throws CloneNotSupportedException {
        AbstractMap<?,?> result = (AbstractMap<?,?>)super.clone();
        result.keySet = null;
        result.values = null;
        return result;
    }

    //检查当o1不是null时，o1是不是和o2是equals
    private static boolean eq(Object o1, Object o2) {
        return o1 == null ? o2 == null : o1.equals(o2);
    }

    /**
     * SimpleEntry实现了Map类中的Entry接口， 
     * 另外也实现了Serializable接口，可序列化 
     *
     * @since 1.6
     */
    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;
        }

        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;
        }

        
        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());
        }

      
        public int hashCode() {
            return (key   == null ? 0 :   key.hashCode()) ^ //异或,逻辑运算符
                   (value == null ? 0 : value.hashCode());
        }

       
        public String toString() {
            return key + "=" + value;
        }

    }

    /**
     * SimpleEntry实现了Map类中的Entry接口， 
     * 另外也实现了Serializable接口，可序列化  
     *
     * @since 1.6
     */
    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;
        }

        
        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();
        }

        
        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());
        }

        
        public int hashCode() {
            return (key   == null ? 0 :   key.hashCode()) ^
                   (value == null ? 0 : value.hashCode());
        }

       
        public String toString() {
            return key + "=" + value;
        }

    }

}

点滴~
关注
专栏目录
Map容器的Key、Value是否可以为null问题
Auto1123735786的博客
06-18 7072
Map接口下实现的几个常用类： HashMap、TreeMap、ConcurrentHashMap、Hashtable 这几个类均有put()方法，可以给这些容器中添加元素对象；但是，key和value是否可以为空呢？ 这个图说明HashMap的key和value都允许为null；而Hashtabe、ConcurrentHashMap是都不允许的，TreeMap允许value为null；现在我们通过IDEA查看他们的源代码有何不同； 1.首先是HashMap： 下面是源码部分： public V put(
java容器 抽象类AbstractMap源码分析
许诗宇的博客
09-16 204
目录 简介 查询 size,isEmpty,containsKey,containsValue 增删改查 get,put,remove 批量操作 putAll,clear 两个字段 keySet，values keySet,values方法的内部类 通用方法 equals,hashCode,toString,clone,eq 内部类 SimpleEntry 内部类 Sim...
java集合的抽象是什么_Java集合-02集合抽象类
weixin_42514654的博客
02-26 187
Collection简介Collcetion定义(java version:1.8.0_111)public interface Collection extends Iterable{boolean add(E e);boolean addAll(Collection extends E> c);boolean remove(Object o);void clear();Iterator ...
JAVA集合框架之AbstractCollection抽象类和AbstractList抽象类
lijunfeng的博客
12-12 766
Vector和ArrayList继承自AbstractList抽象类，AbstractList又继承自AbstractCollection抽象类
Java集合框架之抽象基类
跬步至以千里的博客
11-05 1110
为了使具体集合的定义更加简单和规范，Java集合框架中给出了一套抽象基类，只要继承该抽象基类就能轻松定义出自己的具体集合类，其中抽象基类包括： AbstractCollection AbstractList AbstractQueue AbstractSequentialList AbstractSet AbstractMap 注意：AbstractQueue的实现类都在java.util.co...
Java集合之AbstractList抽象类
Hello_zihan的博客
11-01 1366
//此类提供 List 接口的骨干实现，以最大限度地减少实现"随机访问"数据存储（如数组）支持的该接口所需的工作。 //对于连续的访问数据（如链表），应优先使用 AbstractSequentialList，而不是此类 jdk1.7 java.util public abstract class AbstractList extends AbstractColle
java集合AbstractMap_Java 集合中的 AbstractMap 抽象类
weixin_33304613的博客
02-26 94
Java 集合中的 AbstractMap 抽象类jdk1.8.0_144AbstractMap 抽象类实现了一些简单且通用的方法, 本身并不难但在这个抽象类中有两个方法非常值得关注, keySet 和 values 方法源码的实现可以说是教科书式的典范抽象类通常作为一种骨架实现, 为各自子类实现公共的方法上一篇我们讲解了 Map 接口, 此篇对 AbstractMap 抽象类进行剖析研究Java...
Java集合类源码解析：AbstractMap
weixin_30296405的博客
11-13 72
目录 引言 源码解析 抽象函数entrySet() 两个集合视图 操作方法 两个子类 参考： 引言 今天学习一个Java集合的一个抽象类 AbstractMap ，AbstractMap 是M...
java abstractmap,详解Java中AbstractMap抽象类
weixin_39851914的博客
03-19 298
jdk1.8.0_144 下载地址：https://www.jb51.net/softs/551512.htmlAbstractMap抽象类实现了一些简单且通用的方法，本身并不难。但在这个抽象类中有两个方法非常值得关注，keySet和values方法源码的实现可以说是教科书式的典范。抽象类通常作为一种骨架实现，为各自子类实现公共的方法。上一篇我们讲解了Map接口，此篇对AbstractMap抽象类...
Java集合类：AbstractMap
10-17 1078
文章目录引言源码解析抽象函数entrySet()两个集合视图操作方法两个子类感谢参考： 引言 今天学习一个Java集合的一个抽象类 AbstractMap ，AbstractMap 是Map接口的 实现类之一，也是HashMap、TreeMap、ConcurrentHashMap 等的父类，它提供了Map 接口中方法的基本实现（关于Map接口有疑惑的同学可参考 Java根接口：Collectio...
详解Java中AbstractMap抽象类
08-27
AbstractMap抽象类是Java集合框架中的一个重要组件，为Map接口提供了一个骨架实现。它提供了一些简单且通用的方法，但其中有两个方法非常值得关注，即keySet和values方法。这些方法的源码实现可以说是教科书式的典范...
【深入解析Java集合】：ArrayList与LinkedList源码级差异分析
[【深入解析Java集合】：ArrayList与LinkedList源码级差异分析](https://slideplayer.fr/slide/16498320/96/images/11/Liste+cha%C3%AEn%C3%A9e+simple+Op%C3%A9rations%3A+Insertion+au+d%C3%A9but+de+la+liste.jpg...
Map接口和AbstractMap抽象类详解
千磨万击还坚韧，任尔东西南北风
07-09 987
为了更好的理解JDK的哈希表实现，首先研究Map接口和AbstractMap抽象类，打好基础很重要~
源码看JAVA【十八】AbstractMap
只因有你，在路上。。。
03-02 240
1、AbstractMap抽象类，实现Map接口，提供了下属Map实现的通用模板，给定了Map实现的框架。后续定义的Map可以很快实现。 2、AbstractMap的基础数据操作是基于entrySet的操作。因为实际的数据保存于Node&lt;K,V&gt;[] table;并实际通过entrySet封装的对象进行实际的数据管理。 但是也没有具体实现，需要根据实现类来继承。 public ...
Java 集合系列（7）：Spliterator并行遍历迭代器
猪猪
04-17 1287
package java.util; import java.util.function.Consumer; import java.util.function.DoubleConsumer; import java.util.function.IntConsumer; import java.util.function.LongConsumer; /** * Spliterator是一个可...
Java 集合系列（6）： Predicate接口源码 && Consumer接口源码
猪猪
04-17 572
package java.util.function; import java.util.Objects; /** * Predicate功能判断输入的对象是否符合某个条件 * @since 1.8 */ @FunctionalInterface public interface Predicate&lt;T&gt; { //Predicate函数编程 b...
Java 集合系列（12）： Deque接口源码
猪猪
04-17 443
package java.util; /** *双向队列 *队头：可以插入可以删除 *队尾：可以插入可以删除 *继承Queue接口 * * @author Doug Lea * @author Josh Bloch * @since 1.6 * @param &lt;E&gt; the type of elements held in this collection ...
Java 集合系列（16）：TreeMap类源码
猪猪
04-20 341
1.特征分析TreeMap是基于NavigableMap的红黑树的实现。默认排序方式：对key升序排序。TreeMap是非线程同步的。支持浅拷贝，序列化红黑树put节点时，分有无比较器分开讨论，这主要是从性能角度考虑的。代理模式：定义在subMap中的方法，将其行为委托给了NavigableMap来实现，代理模式的使用,消除了需要对Iterator方法进行类型检查的丑陋。2.源码分析简单介绍pac...
Java 集合系列（15）：NavigableMap类源码
猪猪
04-18 274
package java.util; /** * * @author Doug Lea * @author Josh Bloch * @param &lt;K&gt; the type of keys maintained by this map * @param &lt;V&gt; the type of mapped values * @since 1.6 */ //继承了S...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值