美文网首页Java 杂谈
Java 集合框架_AbstractMap

Java 集合框架_AbstractMap

作者: wo883721 | 来源:发表于2017-12-24 14:30 被阅读58次

    AbstractMap类是Map接口的子类,实现了Map接口大部分方法,它的子类只需要实现Set<Entry<K,V>> entrySet() 返回一个键值对的集合,就可以使用Map集合的功能了。

    一.AbstractMap抽样类

    1.1 添加方法

        public V put(K key, V value) {
            throw new UnsupportedOperationException();
        }
    

    直接抛出异常,如果子类不复写这个方法,那么它是一个不可修改的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());
        }
    

    遍历Map集合m,通过它的entrySet()方法得到可迭代的Set集合,然后将每个键值对存放到本Map集合中。

    1.2 删除方法

        public V remove(Object key) {
            // 得到键值对的迭代器
            Iterator<Entry<K,V>> i = entrySet().iterator();
            Entry<K,V> correctEntry = null;
            // 根据key是否为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;
            // 如果找这个键值对correctEntry,删除它,并返回它的value值
            if (correctEntry !=null) {
                oldValue = correctEntry.getValue();
                i.remove();
            }
            return oldValue;
        }
    

    通过entrySet().iterator()方法,得到键值对的迭代器,然后遍历键值对,找到与key值相等的键值对,删除它,并返回对应的value值,如果没找到,就返回null。

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

    调用entrySet集合的clear()方法。

    1.3 查找元素

        public boolean containsKey(Object key) {
            // 得到键值对的迭代器
            Iterator<Map.Entry<K,V>> i = entrySet().iterator();
            // 根据key是否为null,分成两部分
            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;
        }
    

    通过entrySet().iterator()方法,得到键值对的迭代器,然后遍历键值对,找到与key值相等的键值对,返回true,否则返回false。

        public boolean containsValue(Object value) {
            // 得到键值对的迭代器
            Iterator<Entry<K,V>> i = entrySet().iterator();
            // 根据value是否为null,分成两部分,
            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;
        }
    

    通过entrySet().iterator()方法,得到键值对的迭代器,然后遍历键值对,找到与value值相等的键值对,返回true,否则返回false。

       public V get(Object key) {
            // 得到键值对的迭代器
            Iterator<Entry<K,V>> i = entrySet().iterator();
            // 根据key是否为null,分成两部分,
            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;
        }
    

    通过entrySet().iterator()方法,得到键值对的迭代器,然后遍历键值对,找到与key值相等的键值对,并返回对应的value值,如果没找到,就返回null。
    1.4 遍历Map集合。
    我们知道Map接口可以返回三个集合,分别是key值组成的Set<K>集合,value值组成的Collection<V>集合,以及键值对组成的Set<Map.Entry<K, V>>集合。

    其实这里面最重要的是键值对组成的Set集合,因为其他两个集合是可以通过这个集合得到。

        public Set<K> keySet() {
            // 使用keySet变量做缓存用的,这样只有第一次时需要遍历entrySet()集合。
            Set<K> ks = keySet;
            if (ks == null) {
                // 创建一个Set集合,对它的操作都调用Map集合对应方法。
                ks = new AbstractSet<K>() {
                    public Iterator<K> iterator() {
                        // 创建一个迭代器,利用 entrySet().iterator()的迭代器来实现本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() {
            // 使用values变量做缓存用的,防止每次都遍历创建
            Collection<V> vals = values;
            if (vals == null) {
                // 创建一个Collection集合,对它的操作都调用Map集合对应方法。
                vals = new AbstractCollection<V>() {
                    public Iterator<V> iterator() {
                        // 创建一个迭代器,利用 entrySet().iterator()的迭代器来实现本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;
        }
    

    AbstractMap的内部类 SimpleEntry

    SimpleEntry实现了Map.Entry接口,表示一个简单地键值对类。它有两个成员属性key、value来存储键值对。

        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;
    
            // 构造函数时,就传入key值和value值
            public SimpleEntry(K key, V value) {
                this.key   = key;
                this.value = value;
            }
    
            // 或者使用另一个entry来初始化key值和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;
            }
    
            // 替换value值,并返回原来的oldValue值
            public V setValue(V value) {
                V oldValue = this.value;
                this.value = value;
                return oldValue;
            }
    
            // 当key值与value值都相等时,就说明两个entry值相等
            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());
            }
    
            // 保证两个相等的entry,它们的hashCode值必须也相同
            public int hashCode() {
                return (key   == null ? 0 :   key.hashCode()) ^
                       (value == null ? 0 : value.hashCode());
            }
    
            public String toString() {
                return key + "=" + value;
            }
    
        }
    

    AbstractMap的内部类 SimpleImmutableEntry

    SimpleImmutableEntry表示一个不可修改键值对Entry类,也就是说它的setValue(V value)方法会直接抛出异常,其他方法与SimpleEntry类一样。

        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;
    
            // 构造函数时,就传入key值和value值
            public SimpleImmutableEntry(K key, V value) {
                this.key   = key;
                this.value = value;
            }
    
            // 当key值与value值都相等时,就说明两个entry值相等
            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;
            }
    
            // 因为是不可修改键值对Entry类,所以setValue方法直接抛出异常
            public V setValue(V value) {
                throw new UnsupportedOperationException();
            }
    
            // 当key值与value值都相等时,就说明两个entry值相等
            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());
            }
    
            // 保证两个相等的entry,它们的hashCode值必须也相同
            public int hashCode() {
                return (key   == null ? 0 :   key.hashCode()) ^
                       (value == null ? 0 : value.hashCode());
            }
    
            public String toString() {
                return key + "=" + value;
            }
    
        }
    

    总结

    AbstractMap抽样类

    1. 强制子类复写Set<Entry<K,V>> entrySet()方法。
    2. V put(K key, V value):直接抛出异常,如果不复写这个方法,那么集合是不能添加数据的。
    3. void putAll(Map<? extends K, ? extends V> m):是遍历集合,然后调用put方法,将元素添加到集合中,所以也会抛出异常。
    4. V remove(Object key):调用entrySet集合迭代器的remove()实现的,并返回移除的value值。
    5. void clear():调用entrySet集合迭代器的clear()方法实现的。
    6. boolean containsKey(Object key):通过entrySet集合迭代器来遍历Map集合,查找key值相同元素。
    7. containsValue(Object value):通过entrySet集合迭代器来遍历Map集合,查找value值相同元素。
    8. V get(Object key):通过entrySet集合迭代器来遍历Map集合,查找key值相同键值对元素,并返回value值。如果没找到就返回null。
    9. Set<K> keySet():创建一个Set集合,实现都是调用entrySet集合对应方法。
      10.Collection<V> values():创建一个Collection集合,实现都是调用entrySet集合对应方法。

    AbstractMap的内部类 SimpleEntry和SimpleImmutableEntry

    都是实现了Map.Entry接口,表示一个简单地键值对类。它有两个成员属性key、value来存储键值对。
    唯一不同的是SimpleImmutableEntry表示一个不可修改键值对Entry类,,也就是说它的setValue(V value)方法会直接抛出异常。

    相关文章

      网友评论

        本文标题:Java 集合框架_AbstractMap

        本文链接:https://www.haomeiwen.com/subject/psstgxtx.html