在Java中实现支持随机访问的固定窗口队列的代码示例

public class SlidingQueue<T> extends ForwardingQueue<T> {

    private final EvictingQueue<T> queue;
    // view
    private final ArrayDeque<T> arrayDeque;
    private int cachedHead = -1;
    private Object[] cachedElements = null;

    @SneakyThrows
    public SlidingQueue(int size) {
        this.queue = EvictingQueue.create(size);
        this.arrayDeque = (ArrayDeque<T>) FieldUtils.readField(queue, "delegate", true);
    }

    // 只允许添加和删除操作，其他操作都不允许修改队列内容
    @Override
    public boolean add(T element) {
        cachedHead = -1;
        return queue.add(element);
    }

    @Override
    public T remove() {
        cachedHead = -1;
        return queue.remove();
    }

    // 使用标准实现，下面两个方法委托给上面的add和remove方法
    @Override
    public boolean offer(T o) {return standardOffer(o);}
    @Override
    public T poll() {return standardPoll();}

    // 默认实现，委托给不可变视图，所有的写操作都默认禁止
    @Override
    protected Queue<T> delegate() {
        return UnmodifiableQueue.unmodifiableQueue(queue);
    }

    // 支持随机访问
    @SneakyThrows
    public T get(int index) {
        Object[] elements;
        int head;
        if (cachedHead == -1) {
            cachedElements = elements = (Object[]) FieldUtils.readField(arrayDeque, "elements", true);
            cachedHead = head = (int) FieldUtils.readField(arrayDeque, "head", true);
        } else {
            elements = cachedElements;
            head = cachedHead;
        }
        return (T) elements[inc(head, index, elements.length)];
    }

    // 环形数组下标计算
    static int inc(int i, int distance, int modulus) {
        if ((i += distance) - modulus >= 0) i -= modulus;
        return i;
    }
}

private final EvictingQueue<T> queue;

private final ArrayDeque<T> arrayDeque;

public T get(int index) {
    // 访问元素数组并计算正确的索引
}

static int inc(int i, int distance, int modulus) {
    if ((i += distance) - modulus >= 0) i -= modulus;
    return i;
}

public static void main(String[] args) {
    SlidingQueue<Integer> q = new SlidingQueue<>(5);
    for (int i = 0; i < 10; i++) {
        q.offer(i);
        System.out.format("iteration(i = %d): \n", i);
        int[] array = IntStream.range(0, q.size()).map(q::get).toArray();
        System.out.println("array extracted:" + Arrays.toString(array));
    }
}

iteration(i = 0): 
array extracted:[0]
iteration(i = 1): 
array extracted:[0, 1]
iteration(i = 2): 
array extracted:[0, 1, 2]
iteration(i = 3): 
array extracted:[0, 1, 2, 3]
iteration(i = 4): 
array extracted:[0, 1, 2, 3, 4]
iteration(i = 5): 
array extracted:[1, 2, 3, 4, 5]
iteration(i = 6): 
array extracted:[2, 3, 4, 5, 6]
iteration(i = 7): 
array extracted:[3, 4, 5, 6, 7]
iteration(i = 8): 
array extracted:[4, 5, 6, 7, 8]
iteration(i = 9): 
array extracted:[5, 6, 7, 8, 9]