基于数组的LRU缓存策略

缓存是一种提高数据读取性能的技术，在硬件设计、软件开发中都有着非常广泛的应用，比如常见的CPU缓存、数据库缓存、浏览器缓存等等。
缓存的大小有限，当缓存用满时，哪些数据应该清理出去，哪些数据应该保留？这就需要淘汰策略来决定。常见的策略有三种：先进先出策略FIFO(First In,First Out)、最少使用策略LRU(Least Frequently Used)、最近最少使用策略LRU(Least Recently Used)
缓存实际上就是利用了空间换时间的设计思想。如果我们把数据存储在硬盘上，会比较节省内存，但每次查找数据都需要询问一次硬盘，会比较慢。但如果我们通过缓存技术，事先将数据加载在内存中，虽然会比较耗费内存空间，但每次查询的速度就大大提高了
具体代码如下：

package com.hyc.oa.cache;

import java.util.HashMap;
import java.util.Map;
/*
基于数组的LRU(最近最少使用)缓存淘汰算法
 */
public class LRUBaseArray<T> {
    //默认存储空间8个
    private static final int DEFAULT_CAPACITY=(1<<3);
    //存储空间大小
    private int capacity;
    //当前大小
    private int count;
    //缓存数据
    private T[] data;
    //散列表
    private Map<T,Integer> holder;

    //无参构造
    public LRUBaseArray(){
        this(DEFAULT_CAPACITY);
    }
    //有参构造
    public LRUBaseArray(int n){
        capacity=n;
        data= (T[])new Object[n];
        holder=new HashMap<>();
        count=0;
    }
    public void office(T value){
        if(value==null){  //传过来的数据最好不要为null
            throw new IllegalArgumentException("不能传一个空对象过来");
        }
        Integer index=holder.get(value); //已有的数据中是否存在
        if(index==null){ //不存在则就添加缓存
            if(isFull()){  //如果缓存满了，则就删除头部在缓存
                removeTailCache(value);
            }else{ //直接缓存
                cache(value,count);
            }
        }else{ //更新缓存
            update(index);
        }
    }
    public void update(Integer n){
        T target=data[n];
        rightShift(n);
        data[0]=target;
        holder.put(target,0);
    }
    public void removeTailCache(T value){
        T targent=data[--count];
        holder.remove(targent);
        cache(value,count);
    }
    public void cache(T value,int n){
        rightShift(n);
        data[0]=value;
        holder.put(value,0);
        count++;
    }

    //删除尾部
    public void rightShift(int end){
        for(int i=end-1;i>=0;i--){
            data[i+1]=data[i];
            holder.put(data[i],i+1);
        }
    }
    public boolean isContain(T key){
        return holder.containsKey(key);
    }
    public boolean isFull(){
        return count==capacity;
    }
    public boolean isEmpty(){
        return count==0;
    }
    @Override
    public String toString() {
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<count;i++){
            sb.append(data[i]);
            sb.append(" ");
        }
        return sb.toString();
    }
}
测试：
@Test
public void testLRUBaseArray(){
    LRUBaseArray<Integer> lruBaseArray=new LRUBaseArray<>();
    lruBaseArray.office(1);
    lruBaseArray.office(2);
    lruBaseArray.office(3);
    lruBaseArray.office(4);
    System.out.println(lruBaseArray.toString());
    lruBaseArray.office(5);
    lruBaseArray.office(6);
    lruBaseArray.office(7);
    lruBaseArray.office(8);
    System.out.println(lruBaseArray.toString());
    lruBaseArray.office(9);
    lruBaseArray.office(10);
    lruBaseArray.office(11);
    lruBaseArray.office(12);
    lruBaseArray.office(13);
    System.out.println(lruBaseArray.toString());
}
结果：
4 3 2 1 
8 7 6 5 4 3 2 1 
13 12 11 10 9 8 7 6 ```