标签：

LrcCache是android的utils包里面的一个类，用来实现缓存防止OOM的一个工具类，用途非常广泛。

关于LRU算法：Least Recently Used最近最少使用算法，在操作系统中，对内存的访问满足局部性原理，于是LRU用在缺页中断发生时的置换算法，将内存中的最近最长未使用的页面置换到磁盘，可以实现的方式可以为维护一个链表，当访问一个页面是，将该页面移动至表头（尾），发生缺页时取链表最后（前）的页面置换，这样存在问题是读取某个页面的复杂度太高，于是可以考虑将其进行hash，这样读取速度会提高，于是用到了LinkedHashMap这种数据结构。

android实现的LruCache类主要使用来进行内存缓存的，维护所用资源的强引用，当内存超过设定的缓存值时，将好久未使用的资源从内存删除。

下面基本上没有太多的文字，所有的解释都详细的列在代码里面

HashMap

http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/7-b147/java/util/HashMap.java

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable{
    // 默认初始容量16
    static final int DEFAULT_INITIAL_CAPACITY = 16;
    // 最大容量2^30
    static final int MAXIMUM_CAPACITY = 1 << 30;
    // 默认加载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    // hash映射的数组槽
    transient Entry[] table;
    // 元素个数
    transient int size;
    // 阈值 = 加载因子 * 容量
    int threshold;

    // 加载因子
    final float loadFactor;

    // 修改次数，判断迭代期间容器被修改，不然抛出ConcurrentModificationException
    transient int modCount;

    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
        // 参数调整
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);

        // 找到大于initialCapacity的最小的2次幂
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        // 设置阈值
        threshold = (int)(capacity * loadFactor);
        // 定义数组，大小为capacity
        table = new Entry[capacity];
        // 这里是空的实现，实际让其子类覆写该方法
        init();
    }

    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    // 默认情况下默认的加载因子，默认的容量16
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

    // 从已存在的Map创建HashMap
    public HashMap(Map<? extends K, ? extends V> m) {
        // 容量为Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,DEFAULT_INITIAL_CAPACITY)，默认的加载因子
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,  DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        // 遍历m将其元素添加到hashmap中
        putAllForCreate(m);
    }

    void init() {
    }

    // hash算法
    // 可以将1变的松散，可以减少冲突
    static int hash(int h) {
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    // 根据hash值获得在我们维护的数组的索引
    // 即取hash值的小于length的部分，这样才能将其限定在数组大小的范围里面，这样的处理也会带来冲突
    static int indexFor(int h, int length) {
        return h & (length-1);
    }

    public int size() {
        return size;
    }

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

    // 根据键获取值
    public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }

    // 键为null的Entry都放在第0个槽中，相当于null经过hash后为0
    private V getForNullKey() {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

    public boolean containsKey(Object key) {
        return getEntry(key) != null;
    }

    // 返回对应键的Entry，若不存在返回null
    final Entry<K,V> getEntry(Object key) {
        // 计算key的hash值
        int hash = (key == null) ? 0 : hash(key.hashCode());
        // 根据hash值获取其存放的槽，即indexFor函数的作用
        // 遍历这个槽上的链表
        for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
            Object k;
            // hash值一样且键一样（同一个内存地址或者值相同）即返回。
            if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }


    // 添加键值对
    public V put(K key, V value) {
        // 如果键为null，那么存放在第0个槽上
        if (key == null)
            return putForNullKey(value);
        // 获得键的hash值
        int hash = hash(key.hashCode());
        // 根据hash值得到保存在我们维护的数组中的那个下标处
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                // 已存在，修改
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                // 将旧的值返回
                return oldValue;
            }
        }

        modCount++;
        // 不存在则添加
        addEntry(hash, key, value, i);
        return null;
    }

    // 添加键位null的键值对
    private V putForNullKey(V value) {
        // 键位null的放在第0个槽
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                // 已存在则替换
                V oldValue = e.value;
                e.value = value;
                // 被子类覆盖
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        //　不存在，添加
        addEntry(0, null, value, 0);
        return null;
    }

    // 和put类似，用在构造函数、clone
    private void putForCreate(K key, V value) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);

        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                e.value = value;
                return;
            }
        }
        createEntry(hash, key, value, i);
    }

    // 遍历map添加到新建的hashmap中
    private void putAllForCreate(Map<? extends K, ? extends V> m) {
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            putForCreate(e.getKey(), e.getValue());
    }

    // 扩容
    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        // 旧的容量已经达到最大了，调整阈值即可
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        // 用新的容量创建新数组
        Entry[] newTable = new Entry[newCapacity];
        // 并将原数组里面的hash表全部搬移到新的数组槽中
        transfer(newTable);
        // 将维护的数组引用重新赋值
        table = newTable;
        // 调整阈值
        threshold = (int)(newCapacity * loadFactor);
    }

    // 将原数组table里面的hash表全部搬移到新的数组槽中填充newTable
    void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        // 遍历数组的每个槽，每个槽中在一次遍历链表
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

    // 
    public void putAll(Map<? extends K, ? extends V> m) {
        // map元素个数为0，什么也不用做
        int numKeysToBeAdded = m.size();
        if (numKeysToBeAdded == 0)
            return;
        // 如果待复制的元素个数大于阈值，需要扩容
        if (numKeysToBeAdded > threshold) {
            // 目标容量为满足当前设置的加载因子情况下的容量
            int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
            // 参数调整
            if (targetCapacity > MAXIMUM_CAPACITY)
                targetCapacity = MAXIMUM_CAPACITY;
            int newCapacity = table.length;
            // 找到大于targetCapacity的最小2的n次幂
            while (newCapacity < targetCapacity)
                newCapacity <<= 1;
            if (newCapacity > table.length)
                // 扩容为新的容量
                resize(newCapacity);
        }

        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            put(e.getKey(), e.getValue());
    }

    public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

    // 移除key所对应的键值对
    // 和removeMapping类似，只是在判断相等时有点区别
    final Entry<K,V> removeEntryForKey(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;

        while (e != null) {
            Entry<K,V> next = e.next;
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;
                size--;
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next;
                // 依然在删除该键值对时调用，留给LinkedHashMap，因为可能会在访问hashmap时重新整理链表的指向关系
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }
        return e;
    }

    // 移除键值对
    final Entry<K,V> removeMapping(Object o) {
        // 传递参数不是Entry的子类，什么也不做
        if (!(o instanceof Map.Entry))
            return null;

        Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
        Object key = entry.getKey();
        // 获取要删除的键值对的键的哈希值
        int hash = (key == null) ? 0 : hash(key.hashCode());
        // 根据hash值得到保存在我们维护的数组中的那个下标处
        int i = indexFor(hash, table.length);
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;

        while (e != null) {
            Entry<K,V> next = e.next;
            if (e.hash == hash && e.equals(entry)) {
                // hash值相同并且entry内容一样，即找到了
                modCount++;
                size--;
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next;
                // 空的实现，给LinkedHashMap实现，在删除键值对后执行
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }
        return e;
    }

    public void clear() {
        modCount++;
        Entry[] tab = table;
        for (int i = 0; i < tab.length; i++)
            tab[i] = null;
        size = 0;
    }

    // 判断是否包含值为value的键值对
    public boolean containsValue(Object value) {
        if (value == null)
            return containsNullValue();

        Entry[] tab = table;
        for (int i = 0; i < tab.length ; i++)
            for (Entry e = tab[i] ; e != null ; e = e.next)
                if (value.equals(e.value))
                    return true;
        return false;
    }

    // 判断是否有值为null的键值对
    private boolean containsNullValue() {
        Entry[] tab = table;
        // 依次迭代数组和每个数组槽所对应的链表
        for (int i = 0; i < tab.length ; i++)
            for (Entry e = tab[i] ; e != null ; e = e.next)
                if (e.value == null)
                    return true;
        return false;
    }

    public Object clone() {
        HashMap<K,V> result = null;
        try {
            result = (HashMap<K,V>)super.clone();
        } catch (CloneNotSupportedException e) {
            // assert false;
        }
        result.table = new Entry[table.length];
        result.entrySet = null;
        result.modCount = 0;
        result.size = 0;
        result.init();
        result.putAllForCreate(this);
        return result;
    }

    // hashmap的底层节点结构
    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        final int hash;

        Entry(int h, K k, V v, Entry<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;
        }

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

        public final String toString() {
            return getKey() + "=" + getValue();
        }

        /*******两个空的方法，分别在添加和删除时调用，用以子类实现访问该容器时做一些其他操作*******/
        void recordAccess(HashMap<K,V> m) {
        }
        void recordRemoval(HashMap<K,V> m) {
        }
    }

    // 添加一个Entry到bucketIndex槽的位置
    void addEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        // 下面这句简单的表述实际上创建了一个Entry节点，下一个节点是e
        // 也就是说数组索引所在位置，然后在调整数组索引处为新创建的节点，即链表的头插法
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        // 元素个数超过了阈值，进行扩容为原来的两倍
        if (size++ >= threshold)
            resize(2 * table.length);
    }

    // 逻辑和addEntry一模一样，只是少了扩容的判断，该函数用在构造函数里拷贝另一个map的值
    // 此前已经调整了容量，因此不会出现扩容的情况
    void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }

    // 迭代器部分
    private abstract class HashIterator<E> implements Iterator<E> {
        Entry<K,V> next;        // next entry to return
        // 迭代器的fast-fail机制，迭代期间不允许修改容器
        int expectedModCount;   // For fast-fail
        int index;              // current slot
        Entry<K,V> current;     // current entry

        HashIterator() {
            expectedModCount = modCount;
            if (size > 0) { // advance to first entry
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }

        public final boolean hasNext() {
            return next != null;
        }

        final Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();

            if ((next = e.next) == null) {
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
            current = e;
            return e;
        }

        public void remove() {
            if (current == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Object k = current.key;
            current = null;
            HashMap.this.removeEntryForKey(k);
            expectedModCount = modCount;
        }
    }

    private final class ValueIterator extends HashIterator<V> {
        public V next() {
            return nextEntry().value;
        }
    }

    private final class KeyIterator extends HashIterator<K> {
        public K next() {
            return nextEntry().getKey();
        }
    }

    private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
        public Map.Entry<K,V> next() {
            return nextEntry();
        }
    }

    // Subclass overrides these to alter behavior of views' iterator() method
    Iterator<K> newKeyIterator()   {
        return new KeyIterator();
    }
    Iterator<V> newValueIterator()   {
        return new ValueIterator();
    }
    Iterator<Map.Entry<K,V>> newEntryIterator()   {
        return new EntryIterator();
    }

    // Views
    // hasp里面的entry所对应的Set
    private transient Set<Map.Entry<K,V>> entrySet = null;

    // 键对应的Set
    public Set<K> keySet() {
        Set<K> ks = keySet;
        return (ks != null ? ks : (keySet = new KeySet()));
    }

    private final class KeySet extends AbstractSet<K> {
        public Iterator<K> iterator() {
            return newKeyIterator();
        }
        public int size() {
            return size;
        }
        public boolean contains(Object o) {
            return containsKey(o);
        }
        public boolean remove(Object o) {
            return HashMap.this.removeEntryForKey(o) != null;
        }
        public void clear() {
            HashMap.this.clear();
        }
    }


    public Collection<V> values() {
        Collection<V> vs = values;
        return (vs != null ? vs : (values = new Values()));
    }

    // 值的集合
    private final class Values extends AbstractCollection<V> {
        public Iterator<V> iterator() {
            return newValueIterator();
        }
        public int size() {
            return size;
        }
        public boolean contains(Object o) {
            return containsValue(o);
        }
        public void clear() {
            HashMap.this.clear();
        }
    }

    public Set<Map.Entry<K,V>> entrySet() {
        return entrySet0();
    }

    private Set<Map.Entry<K,V>> entrySet0() {
        Set<Map.Entry<K,V>> es = entrySet;
        return es != null ? es : (entrySet = new EntrySet());
    }

    private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public Iterator<Map.Entry<K,V>> iterator() {
            return newEntryIterator();
        }
        public boolean contains(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<K,V> e = (Map.Entry<K,V>) o;
            Entry<K,V> candidate = getEntry(e.getKey());
            return candidate != null && candidate.equals(e);
        }
        public boolean remove(Object o) {
            return removeMapping(o) != null;
        }
        public int size() {
            return size;
        }
        public void clear() {
            HashMap.this.clear();
        }
    }

    // 序列化部分
    private void writeObject(java.io.ObjectOutputStream s)
        throws IOException
    {
        Iterator<Map.Entry<K,V>> i =
            (size > 0) ? entrySet0().iterator() : null;

        // Write out the threshold, loadfactor, and any hidden stuff
        s.defaultWriteObject();

        // Write out number of buckets
        s.writeInt(table.length);

        // Write out size (number of Mappings)
        s.writeInt(size);

        // Write out keys and values (alternating)
        if (i != null) {
            while (i.hasNext()) {
                Map.Entry<K,V> e = i.next();
                s.writeObject(e.getKey());
                s.writeObject(e.getValue());
            }
        }
    }

    private static final long serialVersionUID = 362498820763181265L;

    /**
     * Reconstitute the <tt>HashMap</tt> instance from a stream (i.e.,
     * deserialize it).
     */
    private void readObject(java.io.ObjectInputStream s)
         throws IOException, ClassNotFoundException
    {
        // Read in the threshold, loadfactor, and any hidden stuff
        s.defaultReadObject();

        // Read in number of buckets and allocate the bucket array;
        int numBuckets = s.readInt();
        table = new Entry[numBuckets];

        init();  // Give subclass a chance to do its thing.

        // Read in size (number of Mappings)
        int size = s.readInt();

        // Read the keys and values, and put the mappings in the HashMap
        for (int i=0; i<size; i++) {
            K key = (K) s.readObject();
            V value = (V) s.readObject();
            putForCreate(key, value);
        }
    }

    // These methods are used when serializing HashSets
    int   capacity()     { return table.length; }
    float loadFactor()   { return loadFactor;   }
}

LinkedHashMap

http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/7-b147/java/util/LinkedHashMap.java

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>{
    private static final long serialVersionUID = 3801124242820219131L;
    // 带头结点的双向循环链表 的头
    private transient Entry<K,V> header;
    // 取值代表使用的方式：false链表按照添加顺序组织，true按照使用顺序组织
    private final boolean accessOrder;

    // 在构造方法中accessOrder均被初始化为false
    public LinkedHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
        accessOrder = false;
    }
    public LinkedHashMap(int initialCapacity) {
        super(initialCapacity);
        accessOrder = false;
    }
    public LinkedHashMap() {
        super();
        accessOrder = false;
    }
    public LinkedHashMap(Map<? extends K, ? extends V> m) {
        super(m);
        accessOrder = false;
    }
    public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }
    // 复写父类的init方法，该方法在父类的构造方法里面调用
    void init() {
        // 初始化链表头结点header
        // 该头结点数字无意义。
        header = new Entry<>(-1, null, null, null);
        // 双向循环链表
        header.before = header.after = header;
    }

    // hashmap里面的该函数的意义是：将原数组table里面的hash表全部搬移到新的数组槽中填充newTable
    // 由于已经将所有元素用链表连起来了所以是用链表来赋值更加快速
    // 
    void transfer(HashMap.Entry[] newTable) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e = header.after; e != header; e = e.after) {
            int index = indexFor(e.hash, newCapacity);
            e.next = newTable[index];
            newTable[index] = e;
        }
    }

    // 判断是否含有某个value
    // 直接遍历链表会有更好的时间复杂度
    public boolean containsValue(Object value) {
        // Overridden to take advantage of faster iterator
        if (value==null) {
            for (Entry e = header.after; e != header; e = e.after)
                if (e.value==null)
                    return true;
        } else {
            for (Entry e = header.after; e != header; e = e.after)
                if (value.equals(e.value))
                    return true;
        }
        return false;
    }

    public V get(Object key) {
        Entry<K,V> e = (Entry<K,V>)getEntry(key);
        if (e == null)
            return null;
        // 访问即有可能要改变他在链表中的位置
        e.recordAccess(this);
        return e.value;
    }

    public void clear() {
        super.clear();
        header.before = header.after = header;
    }

    // linkedHashMap的节点
    private static class Entry<K,V> extends HashMap.Entry<K,V> {
        // 比起hashmap的节点多了两个指针，一个指向前一个节点一个指向后一个节点
        Entry<K,V> before, after;

        Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
            super(hash, key, value, next);
        }

        // 从链表中移除本身节点，仅仅指的是修改指针指向
        private void remove() {
            before.after = after;
            after.before = before;
        }

        // 从链表中添加本节点至existingEntry的前面
        private void addBefore(Entry<K,V> existingEntry) {
            after  = existingEntry;
            before = existingEntry.before;
            before.after = this;
            after.before = this;
        }

       // 覆盖父类的方法
        void recordAccess(HashMap<K,V> m) {
            LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
            // 如果accessOrder为false什么都不做
            if (lm.accessOrder) {
                lm.modCount++;
                // 从链表中移除
                remove();
                // 将该节点添加到链表header的前面，也就是将其添加到链表末尾（header不变）
                addBefore(lm.header);
                //前两步其实就是移动该节点到连飙头，因为他刚被访问过
            }
        }
        // 覆盖父类的方法，删除键值对时同时从链表中移除
        void recordRemoval(HashMap<K,V> m) {
            remove();
        }
    }
    // 迭代器部分
    private abstract class LinkedHashIterator<T> implements Iterator<T> {
        Entry<K,V> nextEntry    = header.after;
        Entry<K,V> lastReturned = null;

        int expectedModCount = modCount;

        public boolean hasNext() {
            return nextEntry != header;
        }

        public void remove() {
            if (lastReturned == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();

            LinkedHashMap.this.remove(lastReturned.key);
            lastReturned = null;
            expectedModCount = modCount;
        }

        Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (nextEntry == header)
                throw new NoSuchElementException();

            Entry<K,V> e = lastReturned = nextEntry;
            nextEntry = e.after;
            return e;
        }
    }

    private class KeyIterator extends LinkedHashIterator<K> {
        public K next() { return nextEntry().getKey(); }
    }

    private class ValueIterator extends LinkedHashIterator<V> {
        public V next() { return nextEntry().value; }
    }

    private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {
        public Map.Entry<K,V> next() { return nextEntry(); }
    }

    // These Overrides alter the behavior of superclass view iterator() methods
    Iterator<K> newKeyIterator()   { return new KeyIterator();   }
    Iterator<V> newValueIterator() { return new ValueIterator(); }
    Iterator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator(); }

    // 添加键值对
    void addEntry(int hash, K key, V value, int bucketIndex) {
        createEntry(hash, key, value, bucketIndex);

        // Remove eldest entry if instructed, else grow capacity if appropriate
        Entry<K,V> eldest = header.after;
        // 判断最旧的，也就是在链表头部的节点是否需要被删除
        if (removeEldestEntry(eldest)) {
            removeEntryForKey(eldest.key);
        } else {
            if (size >= threshold)
                resize(2 * table.length);
        }
    }

    // 比起hashmap中的createEntry方法，增加了修改链表
    void createEntry(int hash, K key, V value, int bucketIndex) {
        HashMap.Entry<K,V> old = table[bucketIndex];
        Entry<K,V> e = new Entry<>(hash, key, value, old);
        table[bucketIndex] = e;
        // 添加一个键值对时，总要将其链接到维护的链表结尾
        e.addBefore(header);
        size++;
    }

    /******LinkedHashMap暴露的方法，可以用起来实现LRU算法*****/
    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }
}

LruCache

public class LruCache<K, V> {
    // LRC算法底层由LinkedHashMap实现
    private final LinkedHashMap<K, V> map;

    // 缓存的数量大小，可以使元素个数、字节数等等任何想要的
    private int size;
    // 缓存的最大值
    private int maxSize;

    private int putCount;
    private int createCount;
    // 由于缓存空间满了被逐出的次数
    private int evictionCount;
    // 从缓存取命中次数
    private int hitCount;
    // 为在缓存中找到的次数，即失败次数
    private int missCount;

    public LruCache(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }
        this.maxSize = maxSize;
        this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
    }

    // 
    public void resize(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }

        synchronized (this) {
            this.maxSize = maxSize;
        }
        trimToSize(maxSize);
    }

    // 
    public final V get(K key) {
        if (key == null) {
            // 不允许出现null的键和HashMap不一样
            throw new NullPointerException("key == null");
        }

        V mapValue;
        synchronized (this) {
            mapValue = map.get(key);
            if (mapValue != null) {
                // 每get成功一次hitCount就自加一次，表示命中次数
                hitCount++;
                // 如果该键对应的值存在，返回之。
                return mapValue;
            }
            missCount++;
        }
        // 否则，创建该键值对，默认值为null
        V createdValue = create(key);
        if (createdValue == null) {
            return null;
        }

        synchronized (this) {
            createCount++;
            // 将创建的value添加到map
            mapValue = map.put(key, createdValue);

            if (mapValue != null) {
                // mapValue部位空，表示本线程在put之前已经被别的线程put了一个值，即产生了冲突
                // 此时我们扔掉刚创建的value，而是使用其他地方产生的value
                map.put(key, mapValue);
            } else {
                // 将其放进map中的同时缓存的size增加
                size += safeSizeOf(key, createdValue);
            }
        }

        if (mapValue != null) {
            entryRemoved(false, key, createdValue, mapValue);
            return mapValue;
        } else {
            // 根据maxSize修改map，因为有可能由于此次的put操作使得容量超过最大值，具体的修改方式在子函数中
            trimToSize(maxSize);
            return createdValue;
        }
    }

    // 和get基本一样
    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) {
                // 返回值部位null，说明之前该键对应的有值，即使替换，因此占用空间减去之前元素
                size -= safeSizeOf(key, previous);
            }
        }

        if (previous != null) {
            // 移除元素时调用
            entryRemoved(false, key, previous, value);
        }

        trimToSize(maxSize);
        return previous;
    }

    // 根据maxSize增删map
    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;
                }
                // 否则，取出最近最长未使用的元素，也就是链表最前面的一个
                // v5.0.1版本的utils包提供的感觉有问题。
                /*Map.Entry<K, V> toEvict = null;
                for (Map.Entry<K, V> entry : map.entrySet()) {
                    // 循环直到最后一个???
                    toEvict = entry;
                }

                if (toEvict == null) {
                    break;
                }
                */
                // V4 包里面的实现https://github.com/android/platform_frameworks_support/blob/master/v4/java/android/support/v4/util/LruCache.java
                Map.Entry<K, V> toEvict = map.entrySet().iterator().next();
                // 然而google已经提供的LinkedHashMap中就有一个函数获得eldest的元素，于是有些版本（）4.4.2的写法比较好理解
                key = toEvict.getKey();
                value = toEvict.getValue();
                // 移除该元素
                map.remove(key);
                // 并将占用空间减少
                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;
        synchronized (this) {
            previous = map.remove(key);
            if (previous != null) {
                size -= safeSizeOf(key, previous);
            }
        }

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

        return previous;
    }

    // true if the entry is being removed to make space, false if the removal was caused by a put or remove.
    /****** 可以覆盖进行其他操作 ******/
    protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {}

    // 当需要的元素不存在时执行，可以自行覆盖 
    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;
    }

    // 返回一个值表示占用的空间
    /****** 需要覆盖对不同的元素（键值对）进行不同的处理 ******/
    protected int sizeOf(K key, V value) {
        return 1;
    }

    // 逐出所有的元素，参数为-1，只要里面还有元素就会大于-1，于是要全部移除
    public final void evictAll() {
        trimToSize(-1); // -1 will evict 0-sized elements
    }

    public synchronized final int size() {
        return size;
    }

    public synchronized final int maxSize() {
        return maxSize;
    }

    public synchronized final int hitCount() {
        return hitCount;
    }

    public synchronized final int missCount() {
        return missCount;
    }

    public synchronized final int createCount() {
        return createCount;
    }

    public synchronized final int putCount() {
        return putCount;
    }

    public synchronized final int evictionCount() {
        return evictionCount;
    }

    public synchronized final Map<K, V> snapshot() {
        return new LinkedHashMap<K, V>(map);
    }

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

android 4.4.2中的LinkedHashMap直接提供了获得最旧元素的方法

/**
     * 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在jdk的不同版本变化较大，并且和android包中的实现也有一些差异。

以上。

碎觉！

从HashMap到LrcCache的源码分析

标签：

原文地址：http://blog.csdn.net/cauchyweierstrass/article/details/50472616