Java实现LRU算法

一。LRU算法简介

LRU（Least Recently Used）最近最久未使用算法

常见应用场景：内存管理中的页面置换算法、缓存淘汰中的淘汰策略等

二。实现理论

　　底层结构：双向链表 + HashMap ，双向链表由特定的哈希节点组成。

（1）访问节点时，将其从原来位置删除，插入到双向链表头部；

（2）更新节点时，先删除原有缓存数据（即原有节点），然后更新map映射，再将更新值作为节点插入链表头；更新后，判断容量是否超过最大内存使用量

（3）超过则执行淘汰；淘汰即删除双向链表最后一个节点，同时删除map中的映射

（4）LRU实现中有频繁的查找节点并删除，为节省时间（链表查找目标节点需要遍历），使用HashMap保存键-节点映射关系，O(1)的查找+O(1)的删除

（5）LRU实现中，要频繁的在头部插入，以及在尾部删除；因此，需要定义head、tail两个节点，方便操作

 

三。代码

package com.xl.Base;

import java.util.HashMap;
import java.util.Iterator;

/**
 *    最近最久未使用淘汰策略
 *    基于 双向链表 + 哈希表组成，其中双向链表由哈希链表节点构成
 *    封装为 LRU(K, V)
 *    对外提供 get(K)访问数据、put(K, V)更新数据、Iterator()遍历数据
 */
public class LRU<K, V> implements Iterable<K>{
    
    private Node head;
    private Node tail;
    //记录K-Node映射，便于快速查找目标数据对应节点
    private HashMap<K, Node> map;
    private int maxSize;
    
    //哈希链表节点类 Node
    private class Node{
        Node pre;
        Node next;
        K k;
        V v;
        
        //Node对外提供构造方法
        public Node(K k, V v) {
            this.k = k;
            this.v = v;
        }
    }
    
    //初始化时必须传入最大可用内存容量
    public LRU(int maxSize){
        this.maxSize = maxSize;
        //HashMap初始容量设置为 maxSize * 4/3，即达到最大可用内存时，HashMap也不会自动扩容浪费空间
        this.map = new HashMap<>(maxSize * 4 / 3);
        
        head.next = tail;
        tail.pre = head;
    }

    //获取指定数据
    private V get(K key) {
        //判断是否存在对应数据
        if(!map.containsKey(key)) {
            return null;
        }
        
        //最新访问的数据移动到链表头
        Node node = map.get(key);
        remove(node);
        addFirst(node);
        return node.v;
    }
    
    //更新旧数据或添加数据
    private void put(K key, V value) {
        //若存在旧数据则删除
        if(map.containsKey(key)) {
            Node node = map.get(key);
            remove(node);
        }
        
        //新数据对应节点插入链表头
        Node node = new Node(key, value);
        map.put(key, node);
        addFirst(node);
        
        //判断是否需要淘汰数据
        if(map.size() > maxSize) {
            removeLast();
            //数据节点淘汰后，同时删除map中的映射
            map.remove(node.k);
        }
    }
    
    //将指定节点插入链表头
    private void addFirst(Node node) {
        Node next = head.next;
        
        head.next = node;
        node.pre = head;
        
        node.next = next;
        next.pre = node;
    }
    
    //从链表中删除指定节点
    private void remove(Node node) {
        Node pre = node.pre;
        Node next = node.next;
        
        pre.next = next;
        next.pre = pre;
        
        node.next = null;
        node.pre = null;
    }
    
    //淘汰数据
    private Node removeLast() {
        //找到最近最久未使用的数据所对应节点
        Node node = tail.pre;
        
        //淘汰该节点
        remove(node);
        
        return node;
    }
    
    //通过迭代器遍历所有数据对应键
    @Override
    public Iterator<K> iterator() {
        return new Iterator<K>() {
            
            private Node cur = head.next;

            @Override
            public boolean hasNext() {
                return cur != tail;
            }

            @Override
            public K next() {
                Node node = cur;
                cur = cur.next;
                return node.k;
            }
            
        };
    }
    
}