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