手寫一個LRU工具類

LRU概述

LRU演算法，即最近最少使用演算法。其使用場景非常廣泛，像我們日常用的手機的後臺應用展示，軟體的複製貼上板等。

本文將基於演算法思想手寫一個具有LRU演算法功能的Java工具類。

結構設計

在插入資料時，需要能快速判斷是否已有相同資料。為實現該目的，可以使用hash表結構。

同時根據LRU的規則，在對已有元素進行查詢和修改操作後，該元素應該被置於首位；在增加元素時，如果超過了最大容量，則會淘汰末尾元素。為減少元素移動的時間複雜度，這裡採用雙端連結串列結構，使得移動元素到首位和刪除末尾元素的時間複雜度都為O(1)。

根據上述資料結構，可以定義元素節點內容，包含hash值，鍵K，值value，先繼節點和後繼節點。如下所示：

static class Entry<K,V> {
    final int hash;     // 雜湊值
    final K key;        // 鍵
    V value;            // 值
    Entry<K,V> before;  // 先繼節點
    Entry<K,V> after;   // 後繼節點
    Entry(int hash, K key, V value, Entry before, Entry after) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.before = before;
        this.after = after;
    }
}

雙端連結串列則需要儲存頭節點和尾節點。

其它成員變數如下：

int maxSize;            // 最大容量
Entry<K,V> head;        // 頭節點
Entry<K,V> tail;        // 尾節點
HashMap<K,V> hashMap;   // 雜湊表

在實現容器的增刪改查方法前，我們先把一些對連結串列的共用操作抽象出來，包括查詢連結串列節點、將連結串列節點移動到隊首、刪除連結串列中節點。對應方法實現如下：

// 根據key從連結串列中找對應節點
Entry<K, V> find(Object key) {
    // 遍歷連結串列找到該元素
    Entry<K,V> entry = head;
    while (entry != null) {
        if (entry.key.equals(key))
            break;
        entry = entry.after;
    }
    return entry;
}
// 將key對應的元素移至隊首
Entry<K,V> moveToFront(Object key) {
    // 遍歷連結串列找到該元素
    Entry<K,V> entry = find(key);
    // 如果找到了並且不是隊首,則將該節點移動到佇列的首部
    if (entry != null && entry != head) {
        // 如果該節點是隊尾
        if (entry == tail)
            tail = entry.before;
        // 先將該節點從連結串列中移出
        Entry<K,V> p = entry.before;
        Entry<K,V> q = entry.after;
        p.after = q;
        if (q != null)
            q.before = p;
        // 然後將該節點作為新的head
        entry.before = null;
        entry.after = head;
        head = entry;
    }
    return entry;
}
// 將key對應的元素從雙端連結串列中刪除
void removeFromLinkedList(Object key) {
    // 遍歷連結串列找到該元素
    Entry<K,V> entry = find(key);
    // 如果沒找到則直接返回
    if (entry == null)  return;
    // 如果是隊首元素
    if (entry == head) {
        // 只有一個節點
        if (tail == head)
            tail = entry.after;
        head = entry.after;
        head.before = null;
    } else if (entry == tail) {
        // 如果是隊尾元素
        tail = tail.before;
        tail.after = null;
    }
}

put()方法

put元素時需要判斷元素是否已經在容器中存在，如果存在，則修改對應節點的值，並將該節點移動到連結串列的頭部。

如果不存在，則將元素插入到連結串列的頭部。如果此時容量超過預設最大容量，需要將佇列尾部元素移除。

注意：上述操作需要判斷是否更新頭尾節點。

程式碼如下：

// 存入元素/修改元素
public void put(K key, V value) {
    V res = hashMap.put(key,value);
    // 如果res為null，表示沒找到，則存入並放置到隊首
    if (res == null) {
        Entry<K,V> entry = new Entry<>(key.hashCode(), key, value, null, head);
        // 如果之前沒有頭節點
        if (head == null) {
            head = entry;
            tail = entry;
        } else {
            // 如果之前有頭節點，將頭節點before指向entry
            entry.after = head;
            head.before = entry;
            head = entry;
        }
        // 判斷此時節點數量是否超過最大容量,如果超過，則將隊尾元素刪除
        if (hashMap.size() > maxSize) {
            tail = tail.before;
            tail.after = null;
        }
    } else {
        // 如果res不為null,表示包含該元素，則將節點放置到隊首
        Entry<K,V> entry = moveToFront(key);
        // 同時修改節點的V值
        entry.value = value;
    }
}

remove()方法

從容器中刪除元素，需要判斷是否在容器中存在。同時也要注意更新頭尾節點。

// 刪除元素
public void remove(Object key) {
    V res = hashMap.remove(key);
    // 如果刪除成功，則將連結串列中節點一併刪除
    if (res != null)
        removeFromLinkedList(key);
}

get()方法

查詢元素如果找到的話需要將對應節點移動到佇列頭部。

// 查詢元素
public V get(Object key) {
    V res = hashMap.get(key);
    // 如果在已有資料中找到，則將該元素放置到隊首
    if (res != null)
        moveToFront(key);
    return res;
}

完整程式碼

完整程式碼以及測試如下：

package com.simple.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class SimpleLRUCache <K,V>{
    int maxSize;            // 最大容量
    Entry<K,V> head;        // 頭節點
    Entry<K,V> tail;        // 尾節點
    HashMap<K,V> hashMap;   // 雜湊表
    // 建構函式
    public SimpleLRUCache(int size) {
        if (size <= 0)
            throw new RuntimeException("容器大小不能<=0");
        this.maxSize = size;
        this.hashMap = new HashMap<>();
    }
    static class Entry<K,V> {
        final int hash;     // 雜湊值
        final K key;        // 鍵
        V value;            // 值
        Entry<K,V> before;  // 先繼節點
        Entry<K,V> after;   // 後繼節點
        Entry(int hash, K key, V value, Entry before, Entry after) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.before = before;
            this.after = after;
        }
    }
    // 查詢元素
    public V get(Object key) {
        V res = hashMap.get(key);
        // 如果在已有資料中找到，則將該元素放置到隊首
        if (res != null)
            moveToFront(key);
        return res;
    }
    // 存入元素/修改元素
    public void put(K key, V value) {
        V res = hashMap.put(key,value);
        // 如果res為null，表示沒找到，則存入並放置到隊首
        if (res == null) {
            Entry<K,V> entry = new Entry<>(key.hashCode(), key, value, null, head);
            // 如果之前沒有頭節點
            if (head == null) {
                head = entry;
                tail = entry;
            } else {
                // 如果之前有頭節點，將頭節點before指向entry
                entry.after = head;
                head.before = entry;
                head = entry;
            }
            // 判斷此時節點數量是否超過最大容量,如果超過，則將隊尾元素刪除
            if (hashMap.size() > maxSize) {
                tail = tail.before;
                tail.after = null;
            }
        } else {
            // 如果res不為null,表示包含該元素，則將節點放置到隊首
            Entry<K,V> entry = moveToFront(key);
            // 同時修改節點的V值
            entry.value = value;
        }
    }
    // 刪除元素
    public void remove(Object key) {
        V res = hashMap.remove(key);
        // 如果刪除成功，則將連結串列中節點一併刪除
        if (res != null)
            removeFromLinkedList(key);
    }
    // 將key對應的元素移至隊首
    Entry<K,V> moveToFront(Object key) {
        // 遍歷連結串列找到該元素
        Entry<K,V> entry = find(key);
        // 如果找到了並且不是隊首,則將該節點移動到佇列的首部
        if (entry != null && entry != head) {
            // 如果該節點是隊尾
            if (entry == tail)
                tail = entry.before;
            // 先將該節點從連結串列中移出
            Entry<K,V> p = entry.before;
            Entry<K,V> q = entry.after;
            p.after = q;
            if (q != null)
                q.before = p;
            // 然後將該節點作為新的head
            entry.before = null;
            entry.after = head;
            head = entry;
        }
        return entry;
    }
    // 將key對應的元素從雙端連結串列中刪除
    void removeFromLinkedList(Object key) {
        // 遍歷連結串列找到該元素
        Entry<K,V> entry = find(key);
        // 如果沒找到則直接返回
        if (entry == null)  return;
        // 如果是隊首元素
        if (entry == head) {
            // 只有一個節點
            if (tail == head)
                tail = entry.after;
            head = entry.after;
            head.before = null;
        } else if (entry == tail) {
            // 如果是隊尾元素
            tail = tail.before;
            tail.after = null;
        }
    }
    // 根據key從連結串列中找對應節點
    Entry<K, V> find(Object key) {
        // 遍歷連結串列找到該元素
        Entry<K,V> entry = head;
        while (entry != null) {
            if (entry.key.equals(key))
                break;
            entry = entry.after;
        }
        return entry;
    }
    // 順序返回元素
    public List<Entry<K,V>> getList() {
        List<Entry<K,V>> list = new ArrayList<>();
        Entry<K,V> p = head;
        while (p != null) {
            list.add(p);
            p = p.after;
        }
        return list;
    }
    // 順序輸出元素
    public void print() {
        Entry<K,V> p = head;
        while (p != null) {
            System.out.print(p.key.toString()+":"+p.value.toString()+"\t");
            p = p.after;
        }
        System.out.println();
    }
    public static void main(String[] args) {
        SimpleLRUCache<String, String> test = new SimpleLRUCache(4);
        test.put("a","1");
        test.put("b","2");
        test.put("c","3");
        test.put("d","4");
        // 此時順序為d c b a
        test.print();
        // 獲取a,此時順序為 a d c b
        test.get("a");
        test.print();
        // 修改c，此時順序為 c a d b
        test.put("c","31");
        test.print();
        // 增加e,淘汰末尾元素b,此時順序為e c a d
        test.put("e","5");
        test.print();
    }
}