java 完成最近最少使用算法刷新cache，使用数组作为缓存

在 Java 中，也可以使用数组来实现 LRU 缓存淘汰策略。具体实现步骤如下：

1. 创建一个 Entry 类用于存储缓存中的键值对。

class Entry<K, V> {
    K key;
    V value;

    Entry(K key, V value) {
        this.key = key;
        this.value = value;
    }
}

2. 在缓存类中创建一个数组以及一个计数器，用于存储缓存中的元素以及当前缓存中的元素个数。

class LRUCache<K, V> {
    private final Entry<K, V>[] cache;
    private int count;

    LRUCache(int capacity) {
        // 创建一个长度为 capacity 的数组
        cache = new Entry[capacity];
        count = 0;
    }
}

3. 在 get 方法中查找缓存中的元素。如果找到了该元素，将其移到数组的最后一位，以表示最近访问过。

public V get(K key) {
    for (int i = 0; i < count; i++) {
        if (cache[i].key.equals(key)) {
            // 找到了元素，将其移到数组的最后一位
            Entry<K, V> entry = cache[i];
            for (int j = i; j < count - 1; j++) {
                cache[j] = cache[j + 1];
            }
            cache[count - 1] = entry;
            return entry.value;
        }
    }
    return null;
}

4. 在 put 方法中插入新元素，并在缓存满时删除最老的元素。如果缓存中已存在该元素，则将其移到数组的最后一位。

public void put(K key, V value) {
    // 查找缓存中是否已存在该元素
    for (int i = 0; i < count; i++) {
        if (cache[i].key.equals(key)) {
            // 找到了元素，将其移到数组的最后一位
            Entry<K, V> entry = cache[i];
            for (int j = i; j < count - 1; j++) {
                cache[j] = cache[j + 1];
            }
            cache[count - 1] = entry;
            entry.value = value;
            return;
        }
    }

    // 插入新元素
    if (count < cache.length) {
        // 缓存未满，直接插入到数组的最后一位
        cache[count] = new Entry<>(key, value);
        count++;
    } else {
        // 缓存已满，删除最老的元素，将新元素插入到数组的最后一位
        for (int i = 0; i < count - 1; i++) {
            cache[i] = cache[i + 1];
        }
        cache[count - 1] = new Entry<>(key, value);
    }
}

下面是一个完整的示例代码：

class Entry<K, V> {
    K key;
    V value;

    Entry(K key, V value) {
        this.key = key;
        this.value = value;
    }
}

class LRUCache<K, V> {
    private final Entry<K, V>[] cache;
    private int count;

    LRUCache(int capacity) {
        cache = new Entry[capacity];
        count = 0;
    }

    public V get(K key) {
        for (int i = 0; i < count; i++) {
            if (cache[i].key.equals(key)) {
                // 找到了元素，将其移到数组的最后一位
                Entry<K, V> entry = cache[i];
                for (int j = i; j < count - 1; j++) {
                    cache[j] = cache[j + 1];
                }
                cache[count - 1] = entry;
                return entry.value;
            }
        }
        return null;
    }

    public void put(K key, V value) {
        // 查找缓存中是否已存在该元素
        for (int i = 0; i < count; i++) {
            if (cache[i].key.equals(key)) {
                // 找到了元素，将其移到数组的最后一位
                Entry<K, V> entry = cache[i];
                for (int j = i; j < count - 1; j++) {
                    cache[j] = cache[j + 1];
                }
                cache[count - 1] = entry;
                entry.value = value;
                return;
            }
        }

        // 插入新元素
        if (count < cache.length) {
            // 缓存未满，直接插入到数组的最后一位
            cache[count] = new Entry<>(key, value);
            count++;
        } else {
            // 缓存已满，删除最老的元素，将新元素插入到数组的最后一位
            for (int i = 0; i < count - 1; i++) {
                cache[i] = cache[i + 1];
            }
            cache[count - 1] = new Entry<>(key, value);
        }
    }

    public static void main(String[] args) {
        LRUCache<Integer, String> cache = new LRUCache<>(2);

        cache.put(1, "one");
        cache.put(2, "two");
        System.out.println(Arrays.toString(cache.cache)); // 输出 [{1=one}, {2=two}]
        
        cache.get(1);
        cache.put(3, "three");
        System.out.println(Arrays.toString(cache.cache)); // 输出 [{2=two}, {3=three}]
    }
}