数据结构与算法-HashMap与LinkedHashMap

Java语言数据结构 同时被 3 个专栏收录
3 篇文章 0 订阅
35 篇文章 0 订阅

数据结构与算法-HashMap与LinkedHashMap

Map

基本概念

Map 一般在开发中使用非常广泛,常用的有HashMap, LinkedHashMap,TreeMap等等,由于使用的时候一般是有key和value一一对应,所以称之为Map。

百度百科 — Map 接口定义的集合又称为查找表,用于存储所谓“key-value”映射对。Key可以看成是Value 的索引,作为key的对象在集合中不可重复。
这里的数据结构可能跟具体的实现方式不一样,暂时只分析HashMap和LinkedHashMap两个类。

常见操作

put 操作 添加
get 操作 读取
remove 操作 移除

Java中常见数据结构类分析

HashMap

基本结构

    /**
     * 默认初始化大小 - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 4;

    /**
     * 最大容量设置,默认最大是2^30-1, 可以通过构造函数设置。
     * 
     * MUST be a power of two <= 1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * 默认的负载因子。当容量占到当前容量的75% 时,将会进行扩容操作。
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 一个空的链表
     */
    static final HashMapEntry<?,?>[] EMPTY_TABLE = {};

    /**
     * The table, resized as necessary. Length MUST Always be a power of two.
     */
    transient HashMapEntry<K,V>[] table = (HashMapEntry<K,V>[]) EMPTY_TABLE;

    /**
     * The number of key-value mappings contained in this map.
     */
    transient int size;

    /**
     * The next size value at which to resize (capacity * load factor).
     * @serial
     */
    // If table == EMPTY_TABLE then this is the initial capacity at which the
    // table will be created when inflated.
    int threshold;

    /**
     * The load factor for the hash table.
     *
     * @serial
     */
    // Android-Note: We always use a load factor of 0.75 and ignore any explicitly
    // selected values.
    final float loadFactor = DEFAULT_LOAD_FACTOR;

    /**
     * The number of times this HashMap has been structurally modified
     * Structural modifications are those that change the number of mappings in
     * the HashMap or otherwise modify its internal structure (e.g.,
     * rehash).  This field is used to make iterators on Collection-views of
     * the HashMap fail-fast.  (See ConcurrentModificationException).
     */
    transient int modCount;

     /** @hide */  // Android added.
    /// 基本的HashMap 存储单元 Entry 
    static class HashMapEntry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        HashMapEntry<K,V> next;  /// 当前entry 指向的下一个元素
        int hash;  // 当前元素key 经过二次hash 算出的hash码
        /**
         * Creates new entry.
         */
        HashMapEntry(int h, K k, V v, HashMapEntry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }

    }

HashMap 包含如下几个构造器:

* HashMap():构建一个初始容量为 16,负载因子为 0.75 的 HashMap。 
* HashMap(int initialCapacity):构建一个初始容量为 initialCapacity,负载因子为 0.75 的 HashMap。 
* HashMap(int initialCapacity, float loadFactor):以指定初始容量、指定的负载因子创建一个 HashMap。 

put

    /**
     * Maps the specified key to the specified value.
     *
     * @param key
     *            the key.
     * @param value
     *            the value.
     * @return the value of any previous mapping with the specified key or
     *         {@code null} if there was no such mapping.
     */
    @Override 
    public V put(K key, V value) {
        if (key == null) {
            return putValueForNullKey(value);
        }
        /// 计算该key的hash 码
        int hash = Collections.secondaryHash(key);
        HashMapEntry<K, V>[] tab = table;
        // 拿到临时的table链表

        int index = hash & (tab.length - 1);
        /// 计算index 

        ///利用for循环来,遍历HashMapEntry组成的单向链表 
        for (HashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {
            /// 找到对应的hash码相同和key 相等的位置
            if (e.hash == hash && key.equals(e.key)) {
                preModify(e);
                // 因为已经存在相同key的entry ,所以这里进行覆盖,并且返回old元素。
                V oldValue = e.value;
                e.value = value;
                return oldValue;
            }
        }

        // No entry for (non-null) key is present; create one
        modCount++;
        /// 这里如果size++ 超过hash table的极限,则进行扩容操作
        if (size++ > threshold) {
            tab = doubleCapacity();
            index = hash & (tab.length - 1);
        }
        addNewEntry(key, value, hash, index);
        return null;
    }

    /**
     * 由此可见 新加入的entry是放在了 table[index] 的位置,next 指向了 原来table[index]的位置, 也就是entry的链表头是table[index]
     */
    void addNewEntry(K key, V value, int hash, int index) {

        table[index] = new HashMapEntry<K, V>(key, value, hash, table[index]);
    }

    /**
     * key 为null ,没有hash 默认0 , 也就只有一个元素 没有next
     */
    void addNewEntryForNullKey(V value) {
        entryForNullKey = new HashMapEntry<K, V>(null, value, 0, null);
    }

看下Collections中的二次hash方法

  /**
     * Computes a hash code and applies a supplemental hash function to defend
     * against poor quality hash functions. This is critical because HashMap
     * uses power-of-two length hash tables, that otherwise encounter collisions
     * for hash codes that do not differ in lower or upper bits.
     * Routine taken from java.util.concurrent.ConcurrentHashMap.hash(int).
     * @hide
     */
    public static int secondaryHash(Object key) {
        return secondaryHash(key.hashCode());
    }

    /**
     * Applies a 追加的 hash function to a given hashCode, which defends
     * against poor quality hash functions. 
     * 这是关键的这是因为使用了二的n次方长度的hash Tables, 可以使 hash碰撞在高位或者低位的计算降到最低。
     */
    private static int secondaryHash(int h) {
        // Doug Lea's supplemental hash function
        // 这是Doug Lea 追加的hash 算法, 具体算法已经超出本文内容。
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

看一下扩容方法

/**
     * Doubles the capacity of the hash table. Existing entries are placed in
     * the correct bucket on the enlarged table. If the current capacity is,
     * MAXIMUM_CAPACITY, this method is a no-op. Returns the table, which
     * will be new unless we were already at MAXIMUM_CAPACITY.
     */
    private HashMapEntry<K, V>[] doubleCapacity() {
        HashMapEntry<K, V>[] oldTable = table;
        int oldCapacity = oldTable.length;
        /// 如果目前容量已经超过了最大容量 直接返回。
        if (oldCapacity == MAXIMUM_CAPACITY) {
            return oldTable;
        }
        int newCapacity = oldCapacity * 2;
        /// 新容量是原来的一倍,用新容量大小来创建table[]
        HashMapEntry<K, V>[] newTable = makeTable(newCapacity);
        /// 如果元素个数0 则直接返回新数组
        if (size == 0) {
            return newTable;
        }

         接下来会进行循环遍历oldtable中的所有元素,并且进行重新编码,按照newTable的位置进行重构,重新创建链表数组结构。
        for (int j = 0; j < oldCapacity; j++) {
            /*
             * Rehash the bucket using the minimum number of field writes.
             * This is the most subtle and delicate code in the class.
             */
            HashMapEntry<K, V> e = oldTable[j];
            // 按照数组索引进行index ,如果为null ,直接进入下个元素
            if (e == null) {
                continue;
            }

            int highBit = e.hash & oldCapacity;
            /// 该方法和indexFor 不同的是, e.hash & oldCapacity进行计算, 则取到的是高位
            也就是 ,要么是oldCaPacity的值,要么是0 

            HashMapEntry<K, V> broken = null;

            newTable[j | highBit] = e;
            / j|highBit 运算则表示 在原来的高位基础上, 要么是原来大小基础之上加上小于原大小的值,要么还是在原大小之内
            /// 看一个栗子;
            假如 oldCapacity = 16 , 则 e.hash & oldCapacity 之后 ,结果要么是0 ,要么是16
            10000000 00000000 00000000 00010000  16 
            10010100 11100100 00100100 00000101  n ... 
            10000000 00000000 00000000 00000000  0
            10000000 00000000 00000000 00010000  16

            如果是0  则 结果是0<= newIndex <16   因为j <oldCapacity, 所以取最大值15
            如果是16 则 结果是16<= newIndex <32

            10000000 00000000 00000000 00010000  16 
            10000000 00000000 00000000 00000101   5  
            10000000 00000000 00000000 00010101  21

            /// 计算出需要原来每个节点的链表中超出原大小,需要构建到16<=n<32中的元素,然后build新的数组链表结构
            for (HashMapEntry<K, V> n = e.next; n != null; e = n, n = n.next) {
                int nextHighBit = n.hash & oldCapacity;
                if (nextHighBit != highBit) {
                    if (broken == null)
                        newTable[j | nextHighBit] = n;
                    else
                        broken.next = n;
                    broken = e;
                    highBit = nextHighBit;
                }
            }
            if (broken != null)
                broken.next = null;
        }
        return newTable;
    }


    /**
     * Allocate a table of the given capacity and set the threshold accordingly.
     * @param newCapacity must be a power of two
     */
    private HashMapEntry<K, V>[] makeTable(int newCapacity) {
        @SuppressWarnings("unchecked") 
        /// 创建newTable 数组 以新容量
        HashMapEntry<K, V>[] newTable  = (HashMapEntry<K, V>[]) new HashMapEntry[newCapacity];
        table = newTable;
        // 极限容量设定为 n/2 + n/2^2 = 3/4 容量
        threshold = (newCapacity >> 1) + (newCapacity >> 2); // 3/4 capacity
        return newTable;
    }

get

    /**
     * 查找到对应key, Mapping的对象并返回
     *
     * @see #put(Object, Object)
     */
    public V get(Object key) {
        if (key == null)
            return getForNullKey();

        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }

    /**
     * 遍历查询key==null并返回
     */
    private V getForNullKey() {
        if (size == 0) {
            return null;
        }
        for (HashMapEntry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }


    /**
     * Returns the entry associated with the specified key in the
     * HashMap.  Returns null if the HashMap contains no mapping
     * for the key.
     */
    final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }

        int hash = (key == null) ? 0 : Collections.secondaryHash(key);
        /// 使用key的二次hash 计算出的index ,然后遍历链表达到快速查询的目的, 这里如果key ==null 的hash是0 ,对应了 putNullKey的hash值
        for (HashMapEntry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

    /**
     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        return h & (length-1);
    }

对于任意给定的对象,只要它的 hashCode() 返回值相同,那么程序调用 hash(int h) 方法所计算得到的 Hash 码值总是相同的。接下来程序会调用 indexFor(int h, int length) 方法来计算该对象应该保存在 table 数组的哪个索引处。indexFor(int h, int length) –>>> * h & (length-1)*

因为 length 总是 2 N次方

h & (length-1) 将是一个非常巧妙的设计(旧版本src里边写的是 h%length-1. 两种其实一样) :

length-1 (16-1)           10000000 00000000 00000000 00001111 
h                &        10010100 11100100 00100100 00010000
h & (length-1)   ->       10000000 00000000 00000000 00000000

所以我们假设 h=5,length=16, 那么 h & length - 1 将得到 5;如果 h=6,length=16, 那么 h & length - 1 将得到 6 ……如果 h=15,length=16, 那么 h & length - 1 将得到 15;这样保证计算得到的索引值总是位于 table 数组的索引之内。

最后我们看一下HashMap的存储结构, 来张图:
HashMap存储结构

看完之后是不是有种高屋建瓴的感觉。注意这里插入操作,不是放在了链表尾部,而是头部. 看addNewEntry方法。

LinkedHashMap

基本结构

public class LinkedHashMap<K, V> extends HashMap<K, V> {

    /**
     *  这是虚拟的循环链表
     * A dummy entry in the circular linked list of entries in the map.
     * 真正的第一个 元素是header.next , 最后一个元素则是previous
     * The first real entry is header.nxt, and the last is header.prv.
     * 如果map是空的 则自己抱自己。 
     * If the map is empty, header.nxt == header && header.prv == header.
     */
    transient LinkedEntry<K, V> header;

    /**
     * True if access ordered, false if insertion ordered.
     * 是否是按照读取的顺序来排序,这里使用
     */
    private final boolean accessOrder;

    /**
     * Constructs a new empty {@code LinkedHashMap} instance.
     */
    public LinkedHashMap() {
        init();
        accessOrder = false;
    }

    @Override 
    void init() {
        header = new LinkedEntry<K, V>();
    }

    再看一下基本结构:

    /**
     * LinkedEntry adds nxt/prv double-links to plain HashMapEntry.
     *  相比HashMapEntry 多了previous和nxt 两个字段 , 看注释可以了解到是双向循环链表
     */
    static class LinkedEntry<K, V> extends HashMapEntry<K, V> {
        /// nxt
        LinkedEntry<K, V> nxt;
        LinkedEntry<K, V> prv;

        /** Create the header entry */
        LinkedEntry() {
            super(null, null, 0, null);
            /// 自己指向自己。 
            nxt = prv = this;
        }

        /** Create a normal entry */
        LinkedEntry(K key, V value, int hash, HashMapEntry<K, V> next,
                    LinkedEntry<K, V> nxt, LinkedEntry<K, V> prv) {
            super(key, value, hash, next);
            this.nxt = nxt;
            this.prv = prv;
        }
    }

put

从上边继承结构可以看到LinkedHashMap 继承自HashMap ,当然同时也继承了父类的结构
LinkedHashMap类中没有实现put方法,而是重写了父类的addNewEntry方法,

 /**
     * Evicts eldest entry if instructed, creates a new entry and links it in
     * as head of linked list. This method should call constructorNewEntry
     * (instead of duplicating code) if the performance of your VM permits.
     *
     * <p>It may seem strange that this method is tasked with adding the entry
     * to the hash table (which is properly the province of our superclass).
     * The alternative of passing the "next" link in to this method and
     * returning the newly created element does not work! If we remove an
     * (eldest) entry that happens to be the first entry in the same bucket
     * as the newly created entry, the "next" link would become invalid, and
     * the resulting hash table corrupt.

     * 接着上边hashMap put的逻辑, 继续,找到hash & key相等重写,否则扩容或者进行添加新元素, 将需要传的key, value , hash , index 传过来之后
     */
    @Override void addNewEntry(K key, V value, int hash, int index) {

        LinkedEntry<K, V> header = this.header;

        // Remove eldest entry if instructed to do so.
        LinkedEntry<K, V> eldest = header.nxt;
        if (eldest != header && removeEldestEntry(eldest)) {
            remove(eldest.key);
        }

        // Create new entry, link it on to list, and put it into table
        LinkedEntry<K, V> oldTail = header.prv;
        LinkedEntry<K, V> newTail = new LinkedEntry<K,V>(
                key, value, hash, table[index], header, oldTail);
        table[index] = oldTail.nxt = header.prv = newTail;
        /// 将新的节点new出来,添加到原来header.prv之后和现在header.prv之前, 同时将newTail赋值给table[index] ,并将table[index].prv设置给newTail
    }

    /**
    重写父类方法, 插入null key 节点
    */
    @Override void addNewEntryForNullKey(V value) {
        LinkedEntry<K, V> header = this.header;

        // Remove eldest entry if instructed to do so.
        LinkedEntry<K, V> eldest = header.nxt;
        if (eldest != header && removeEldestEntry(eldest)) {
            remove(eldest.key);
        }

        // Create new entry, link it on to list, and put it into table
        LinkedEntry<K, V> oldTail = header.prv;
        //把newTail 插入到header 之前 ,header.prv之后
        // key 为null , hash = 0 
        LinkedEntry<K, V> newTail = new LinkedEntry<K,V>( null, value, 0, null, header, oldTail);

        entryForNullKey = oldTail.nxt = header.prv = newTail;
    }

     protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return false;
    }

get

    /**
     * Returns the value of the mapping with the specified key.
     *
     * @param key
     *            the key.
     * @return the value of the mapping with the specified key, or {@code null}
     *         if no mapping for the specified key is found.
     */
    @Override public V get(Object key) {
        /*
         * This method is overridden to eliminate the need for a polymorphic
         * invocation in superclass at the expense of code duplication.
         */
        if (key == null) {
            HashMapEntry<K, V> e = entryForNullKey;
            if (e == null)
                return null;
                /// 即使key为null 同样插入到队尾 
            if (accessOrder)
                makeTail((LinkedEntry<K, V>) e);
            return e.value;
        }

        int hash = (key == null) ? 0 : Collections.secondaryHash(key);

        HashMapEntry<K, V>[] tab = table;
        /// 根据二次哈希算法 得到index, 并循环遍历链表 找到对应的value
        for (HashMapEntry<K, V> e = tab[hash & (tab.length - 1)];
                e != null; e = e.next) {
            K eKey = e.key;
            if (eKey == key || (e.hash == hash && key.equals(eKey))) {
                /// 这一点至关重要, 如果是按照LRU排序,则进入执行,将刚刚访问的元素e断开前后链接,插入到对位,也就是Header.previous之前 
                if (accessOrder)
                    makeTail((LinkedEntry<K, V>) e);
                return e.value;
            }
        }
        return null;
    }

    /**
     * Relinks the given entry to the tail of the list. Under access ordering,
     * this method is invoked whenever the value of a  pre-existing entry is
     * read by Map.get or modified by Map.put.
     * 做个尾巴
     * 
     */
    private void makeTail(LinkedEntry<K, V> e) {
        // Unlink e 断开与e节点关联的前后
        e.prv.nxt = e.nxt;
        e.nxt.prv = e.prv;

        // Relink e as tail  
        /// 将e插入header的prv 和header.prv之间。 相当于添加了tail

        LinkedEntry<K, V> header = this.header;
        LinkedEntry<K, V> oldTail = header.prv;
        e.nxt = header;
        e.prv = oldTail;
        oldTail.nxt = header.prv = e;
        modCount++;
    }


    /**
    * 这个方法当然也是重写HashMap的, 位于put方法内,当key重复时调用。
    */
    @Override 
    void preModify(HashMapEntry<K, V> e) {
        /// 当按照访问排序时
        if (accessOrder) {
            makeTail((LinkedEntry<K, V>) e);
        }
    }

    /**
    移除node e 
    */
    @Override 
    void postRemove(HashMapEntry<K, V> e) {
        LinkedEntry<K, V> le = (LinkedEntry<K, V>) e;
        le.prv.nxt = le.nxt;
        le.nxt.prv = le.prv;
        le.nxt = le.prv = null; // Help the GC (for performance)
    }

LRUCache与LinkedHashMap

在Android开发中,有一个叫做LruCache类专门用来做图片缓存处理的。LRU 是 Least Recently Used 最近最少使用算法。
它有一个特点,当缓存的图片达到了预先设定的值的时候,那么近期使用次数最少的图片就会被回收掉。

下边我们简单说一下LRUCache的核心工作原理。

本来想简单说一下,看了一下 前后没多少行 ,干脆直接粘出来 一点一点注释。

public class LruCache<K, V> {

    // LRUCache  内部持有了LinkedHashMap 引用,泛型类型和LRUCache一一对应 。 
    private final LinkedHashMap<K, V> map;

    /** Size of this cache in units. Not necessarily the number of elements. */
    private int size;
    private int maxSize;

    private int putCount;
    private int createCount;
    private int evictionCount;
    private int hitCount;
    private int missCount;

    /**
     * @param maxSize for caches that do not override {@link #sizeOf}, **this is
     *     the maximum number of entries in the cache**. For all other caches,
     *     this is the maximum sum of the sizes of the entries in this cache.
     */
    public LruCache(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }
        this.maxSize = maxSize;
        /// 这里使用了LinkedHashMap 自定三个参数构造函数,初始化大小为0, 负载因子0.75f, 并且AccessOrder设置为true
        this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
    }

    /**
     * Returns the value for {@code key} if it exists in the cache or can be
     * created by {@code #create}. If a value was returned, it is moved to the
     * head of the queue. This returns null if a value is not cached and cannot
     * be created.
     */
    public final V get(K key) {
        /// 这里的key 不允许为null 和HashMap和LinkedHashMap不一样
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        V mapValue;
        /// 这里做了同步处理 ,也就是说是线程安全的。 
        synchronized (this) {
            mapValue = map.get(key);
            if (mapValue != null) {
            ///  命中个数++ , 返回value
                hitCount++;
                return mapValue;
            }
            // 没命中个数++ 
            missCount++;
        }

        /*
         * Attempt to create a value. This may take a long time, and the map
         * may be different when create() returns. If a conflicting value was
         * added to the map while create() was working, we leave that value in
         * the map and release the created value.
         */

        /// 正常情况下 如果不重写create方法 则不会走到这里。
        V createdValue = create(key);
        if (createdValue == null) {
            return null;
        }
        /// 如果未命中 则创建一个value , 进行put操作。。
        synchronized (this) {
            createCount++;
            mapValue = map.put(key, createdValue);

            if (mapValue != null) {
                // There was a conflict so undo that last put
                map.put(key, mapValue);
            } else {
                /// 大小加上value的大小
                size += safeSizeOf(key, createdValue);
            }
        }

        if (mapValue != null) {
            entryRemoved(false, key, createdValue, mapValue);
            return mapValue;
        } else {
            trimToSize(maxSize);
            return createdValue;
        }
    }

    /**
     * Caches {@code value} for {@code key}. The value is moved to the head of
     * the queue.
     *
     * @return the previous value mapped by {@code key}.
     */
    public final V put(K key, V value) {
        if (key == null || value == null) {
            throw new NullPointerException("key == null || value == null");
        }

        V previous;
        synchronized (this) {
            putCount++;
            size += safeSizeOf(key, value);
            previous = map.put(key, value);
            if (previous != null) {
                size -= safeSizeOf(key, previous);
            }
        }

        if (previous != null) {
            entryRemoved(false, key, previous, value);
        }
        /// 检查内存状况,看是否超标,如果超标则按照LRU算法移除,最近最久未使用的元素,以恢复内存空间。
        trimToSize(maxSize);
        return previous;
    }

    /**
     * @param maxSize the maximum size of the cache before returning. May be -1
     *     to evict even 0-sized elements.
     */
    private void trimToSize(int maxSize) {
        while (true) {
            K key;
            V value;
            /// 这里也是线程安全的
            synchronized (this) {
                if (size < 0 || (map.isEmpty() && size != 0)) {
                    throw new IllegalStateException(getClass().getName()
                            + ".sizeOf() is reporting inconsistent results!");
                }

                if (size <= maxSize) {
                    break;
                }
                /// 获取队首元素 也就是最旧没有访问的元素,
                Map.Entry<K, V> toEvict = map.eldest();
                if (toEvict == null) {
                    break;
                }

                key = toEvict.getKey();
                value = toEvict.getValue();
                /// 移除
                map.remove(key);
                /// 减掉对应的size
                size -= safeSizeOf(key, value);
                /// 移除个数++
                evictionCount++;
            }

            entryRemoved(true, key, value, null);
        }
    }

    /**
     * Removes the entry for {@code key} if it exists.
     *
     * @return the previous value mapped by {@code key}.
     */
    public final V remove(K key) {
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        V previous;
        /// 同步移除node
        synchronized (this) {
            previous = map.remove(key);
            if (previous != null) {
                /// size 减去占用的大小
                size -= safeSizeOf(key, previous);
            }
        }

        if (previous != null) {
            entryRemoved(false, key, previous, null);
        }
        return previous;
    }

    /**
     * Called for entries that have been evicted or removed. This method is
     * invoked when a value is evicted to make space, removed by a call to
     * {@link #remove}, or replaced by a call to {@link #put}. The default
     * implementation does nothing.
     *
     * <p>The method is called without synchronization: other threads may
     * access the cache while this method is executing.
     *
     * @param evicted true if the entry is being removed to make space, false
     *     if the removal was caused by a {@link #put} or {@link #remove}.
     * @param newValue the new value for {@code key}, if it exists. If non-null,
     *     this removal was caused by a {@link #put}. Otherwise it was caused by
     *     an eviction or a {@link #remove}.
     */
    protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {}

    /**
     * Called after a cache miss to compute a value for the corresponding key.
     * Returns the computed value or null if no value can be computed. The
     * default implementation returns null.
     *
     * <p>The method is called without synchronization: other threads may
     * access the cache while this method is executing.
     *
     * <p>If a value for {@code key} exists in the cache when this method
     * returns, the created value will be released with {@link #entryRemoved}
     * and discarded. This can occur when multiple threads request the same key
     * at the same time (causing multiple values to be created), or when one
     * thread calls {@link #put} while another is creating a value for the same
     * key.
     */
    protected V create(K key) {
        return null;
    }


    private int safeSizeOf(K key, V value) {
        int result = sizeOf(key, value);
        if (result < 0) {
            throw new IllegalStateException("Negative size: " + key + "=" + value);
        }
        return result;
    }

    /**
     * Returns the size of the entry for {@code key} and {@code value} in
     * user-defined units.  The default implementation returns 1 so that size
     * is the number of entries and max size is the maximum number of entries.
     *
     * <p>An entry's size must not change while it is in the cache.

     这里一般会重写, 根据实际缓存的内容来计算大小 
     如果是Image则
     ** return bitmap.getRowBytes() * bitmap.getHeight() / 1024;**

      如果不重写则默认计算个数。
     */
    protected int sizeOf(K key, V value) {
        return 1;
    }

    /**
     * Clear the cache, calling {@link #entryRemoved} on each removed entry.
     /// 清空cache
     */
    public final void evictAll() {
        trimToSize(-1); // -1 will evict 0-sized elements
    }

    /**
     * 如果没有重写sizeOf方法 则是缓存的数量
     * 如果重写过就是占用的内存大小。
     */
    public synchronized final int size() {
        return size;
    }

    /**
     * For caches that do not override {@link #sizeOf}, this returns the maximum
     * number of entries in the cache. For all other caches, this returns the
     * maximum sum of the sizes of the entries in this cache.
     */
    public synchronized final int maxSize() {
        return maxSize;
    }

    /**
     * Returns the number of times {@link #get} returned a value that was
     * already present in the cache.
     */
    public synchronized final int hitCount() {
        return hitCount;
    }

    /**
     * Returns the number of times {@link #get} returned null or required a new
     * value to be created.
     */
    public synchronized final int missCount() {
        return missCount;
    }

    /**
     * Returns the number of times {@link #create(Object)} returned a value.
     */
    public synchronized final int createCount() {
        return createCount;
    }

    /**
     * Returns the number of times {@link #put} was called.
     */
    public synchronized final int putCount() {
        return putCount;
    }
    /**
     * Returns the number of values that have been evicted.
     */
    public synchronized final int evictionCount() {
        return evictionCount;
    }

    /**
     * Returns a copy of the current contents of the cache, ordered from least
     * recently accessed to most recently accessed.
     */
    public synchronized final Map<K, V> snapshot() {
        return new LinkedHashMap<K, V>(map);
    }

    /**
    * 重写toString方法, 表述当前cache的状态, 包含最大值,命中个数,命中率,非命中个数。
    */
    @Override 
    public synchronized final String toString() {
        int accesses = hitCount + missCount;
        int hitPercent = accesses != 0 ? (100 * hitCount / accesses) : 0;
        return String.format("LruCache[maxSize=%d,hits=%d,misses=%d,hitRate=%d%%]",
                maxSize, hitCount, missCount, hitPercent);
    }
}

其中在trimToSize方法中

    /** 返回最旧的那个元素,也就是最不经常使用的那个元素, 位于队首。 header.next 
     * 
     * Returns the eldest entry in the map, or {@code null} if the map is empty.
     * @hide
     */
    public Entry<K, V> eldest() {
        LinkedEntry<K, V> eldest = header.nxt;
        return eldest != header ? eldest : null;
    }

总结

这次一共分析了三个类, 一个HashMap , LinkedHashMap , LRUCache . 用到的数据结构是顺序型存储结构和链式存储结构相结合的方式。 其中双联回环式结构的LinkedHashMap 对于线性表的使用要求很高。 至于HashMap的链表结构改为平衡树的新code 会择时间进行分析更新。同时由于个人能力不足,文章肯定有很多不足之处,欢迎批评指正。 如果有不理解的地方可以在留言区回复我们共同学习进步。

  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值