面试-阿里社招笔试题两则（二）----基于hashMap实现LRU缓存

基于HashMap实现LRU缓存

单线程环境下，实现LRU缓存，不可以通过 LinkedHashMap 来实现。

LinkedHashMap 本身实现了LRU存储方式，可以通过定义初始容量和重写
boolean removeEldestEntry(Map.Entry<K,V> eldest) 方式来实现，这里不采用这种方式。我感觉需要考虑比较多的地方就是各种边界值吧，本身的算法实现来说，没有太高的复杂度。

代码实现：

package com.lhc.cache;

import java.util.HashMap;
import java.util.LinkedHashMap;

/**
 * @description:
 * @author: hjt
 * @create: 2020-06-01 14:05
 */

public class LRUCache<K, V> {
    private final int MAX_CACHE_SIZE;
    private Node first;
    private Node last;

    private HashMap<K, Node<K, V>> hashMap;

    public LRUCache(int cacheSize) {
        MAX_CACHE_SIZE = cacheSize;
        hashMap = new HashMap<K, Node<K, V>>();
    }

    public void put(K key, V value) {
        Node node = hashMap.get(key);
        if (node == null) {
            if (hashMap.size() >= MAX_CACHE_SIZE) {
                hashMap.remove(last.key);
                removeLast();
            }
            node = new Node();
            node.key = key;
        }
        node.value = value;
        moveToFirst(node);
        hashMap.put(key, node);
    }

    public V get(K key) {
        Node<K, V> node = hashMap.get(key);
        if (node == null) return null;
        moveToFirst(node);
        return node.value;
    }

    public void remove(K key) {
        Node node = hashMap.get(key);
        if (node != null) {
            if (node.pre != null) node.pre.next = node.next;
            if (node.next != null) node.next.pre = node.pre;
            if (node == first) first = node.next;
            if (node == last) last = node.pre;
        }
        hashMap.remove(key);
    }

    private void moveToFirst(Node node) {
        if (node == first) return;
        if (node.pre != null) node.pre.next = node.next;
        if (node.next != null) node.next.pre = node.pre;
        if (node == last) last = last.pre;

        if (first == null || last == null) {
            first = last = node;
            return;
        }

        node.next = first;
        first.pre = node;
        first = node;
        node.pre = null;
    }

    private void removeLast() {
        if (last != null) {
            last = last.pre;
            if (last == null) first = null;
            else last.next = null;
        }
    }

    class Node<K, V> {
        public Node pre;
        public Node next;
        public K key;
        public V value;
    }
}