基于双向链表和HashMap的LRU算法实现

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/baidu_28196435/article/details/90139537

LRU算法

往往在做内存管理的时候，我们使用LRU算法比较多，即Last Recently Used，最近最少使用原则，
最早出现在Linux操作系统中。
具体的实现思路是使用哈希链表存储键值对，我们可以基于双向链表和HashMap自己实现一个LRU缓存算法。具体的代码如下：

package com.natsuki;

import java.util.HashMap;

/**
 * @Author: xuzhiwei
 * @Date: 2019-05-12
 * @Description: 一个基于顺序HashMap的LRU算法实现
 */
public class LRUCache {
    private Node head;
    private Node end;
    private int limit;

    private HashMap<String, Node> hashMap;

    public LRUCache(int limit) {
        if (limit <= 0) {
            throw new IllegalArgumentException("limit must > 0");
        }
        this.limit = limit;
        hashMap = new HashMap<>();
    }

    public String get(String key) {
        Node node = hashMap.get(key);
        if (node == null) {
            return null;
        }
        refreshNode(node);
        return node.value;
    }

    public void put(String key, String value) {
        Node node = hashMap.get(key);
        if (node == null) {
            if (hashMap.size() >= limit) {
                // 删除最不常用的
                String oldKey = removeNode(head);
                hashMap.remove(oldKey);
            }
            Node newNode = new Node(key, value);
            addNode(newNode);
            hashMap.put(key, newNode);
        } else {
            node.value = value;
            //多次赋值，我们也默认提高优先级的
            refreshNode(node);
        }
    }

    private void refreshNode(Node node) {
        if (node == end) {
            return;
        }
        removeNode(node);
        addNode(node);
    }

    private void addNode(Node node) {
        if (end != null) {
            end.next = node;
            node.prev = end;
        }
        end = node;
        if (head == null) {
            head = node;
        }
        node.next = null;
    }

    private String removeNode(Node node) {
        if (node == end) {
            end = end.prev;
        } else if (node == head) {
            head = head.next;
        } else {
            node.prev.next = node.next;
            node.next.prev = node.prev;
        }
        return node.key;
    }

    private class Node {
        Node prev;
        Node next;
        String key;
        String value;

        Node(String key, String value) {
            this.key = key;
            this.value = value;
        }
    }

    @Override
    public String toString() {
        StringBuilder ret = new StringBuilder();
        Node p = head;
        while (p!=null){
            ret.append("key:").append(p.key).append(",value:").append(p.value).append(";");
            p = p.next;
        }
        return ret.toString();
    }

    public static void main(String[] args) {
        LRUCache lruCache = new LRUCache(5);
        lruCache.put("001","用户1信息");
        lruCache.put("002","用户2信息");
        lruCache.put("003","用户3信息");
        lruCache.put("002","用户2新信息");
        String s = lruCache.get("002");
        // 用户2新信息
        System.out.println(s);

        // key:001,value:用户1信息;key:003,value:用户3信息;key:002,value:用户2新信息;
        System.out.println(lruCache);

    }
}

这里最右端是最近或者最多使用的数据，而最左端则是最少使用数据，非常的巧妙。