Java的循环队列(环形缓冲、RingBuffer)

分析&回答


RingBuffer好处线程安全,可以边写边读。

创建一个循环队列(环形缓冲、RingBuffer),实际元素存在一个数组中,操作数组的指针,不移动元素。

public class CircleQueue<T> {

    /**
     * 循环队列 (数组)默认大小 
     */
    private final int DEFAULT_SIZE = 1000;

    /**
     * (循环队列)数组的容量 
     */
    public int capacity;

    /**
     * 数组:保存循环队列的元素 
     */
    public Object[] elementData;

    /**
     * 队头(先见先出) 
     */
    public int head = 0;

    /**
     * 队尾 
     */
    public int tail = 0;

    /**
     * 以循环队列 默认大小创建空循环队列 
     */
    public CircleQueue() {
        capacity = DEFAULT_SIZE;
        elementData = new Object[capacity];
    }

    /**
     * 以指定长度的数组来创建循环队列 
     *
     * @param initSize
     */
    public CircleQueue(final int initSize) {
        capacity = initSize;
        elementData = new Object[capacity];
    }

    /**
     * 获取循环队列的大小(包含元素的个数) 
     */
    public int size() {
        if (isEmpty()) {
            return 0;
        } else if (isFull()) {
            return capacity;
        } else {
            return tail + 1;
        }
    }

    /**
     * 插入队尾一个元素 
     */
    public void add(final T element) {
        if (isEmpty()) {
            elementData[0] = element;
        } else if (isFull()) {
            elementData[head] = element;
            head++;
            tail++;
            head = head == capacity ? 0 : head;
            tail = tail == capacity ? 0 : tail;
        } else {
            elementData[tail + 1] = element;
            tail++;
        }
    }

    public boolean isEmpty() {
        return tail == head && tail == 0 && elementData[tail] == null;
    }

    public boolean isFull() {
        return head != 0 && head - tail == 1 || head == 0 && tail == capacity - 1;
    }

    public void clear() {
        Arrays.fill(elementData, null);
        head = 0;
        tail = 0;
    }

    /**
     * @return 取 循环队列里的值(先进的index=0) 
     */
    public Object[] getQueue() {
        final Object[] elementDataSort = new Object[capacity];
        final Object[] elementDataCopy = elementData.clone();
        if (isEmpty()) {
        } else if (isFull()) {
            int indexMax = capacity;
            int indexSort = 0;
            for (int i = head; i < indexMax;) {
                elementDataSort[indexSort] = elementDataCopy[i];
                indexSort++;
                i++;
                if (i == capacity) {
                    i = 0;
                    indexMax = head;
                }
            }
        } else {
            // elementDataSort = elementDataCopy;//用这行代码代替下面的循环,在队列刚满时候会出错  
            for (int i = 0; i < tail; i++) {
                elementDataSort[i] = elementDataCopy[i];
            }
        }
        return elementDataSort;
    }

    /**
     * 测试代码 
     */
    public static void main(final String[] args) {
        final CircleQueue<Integer> queue = new CircleQueue<Integer>(10);
        for (int i = 0; i < 99; i++) {
            queue.add(i);
        }

        final Object[] queueArray = queue.getQueue();
        System.out.println("按入队列的先后顺序打印出来:");
        for (final Object o : queueArray) {
            System.out.println(o);
        }
        System.out.println("capacity: " + queue.capacity);
        System.out.println("size: " + queue.size());
        System.out.println("head index: " + queue.head);
        System.out.println("tail index: " + queue.tail);

    }
}

反思&扩展


喵呜面试助手: 一站式解决面试问题,你可以搜索微信小程序 [喵呜面试助手] 或关注 [喵呜刷题] -> 面试助手 免费刷题。如有好的面试知识或技巧期待您的共享!

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

喵呜刷题

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值