队列是一个有序列表，可以使用数组或链表来实现
遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出

使用数组实现:

package com.swh.data;

public class Queue {
    private int[] queueTopic;
    private int occupiedSize = 0;


    private Queue(int[] queueTopic) {
        this.queueTopic = queueTopic;
    }

    public static Queue createQueue(int size){
        int[] initQueue = new int[size];
        return new Queue(initQueue);
    }


    public void pushQueue(int num){
        if(occupiedSize>=queueTopic.length)throw new RuntimeException("队列已满");
        queueTopic[occupiedSize]=num;
        occupiedSize++;
    }



    public int pullQueue(){
        if(occupiedSize<=0)throw new RuntimeException("队列已空");
        int stratData = queueTopic[0];

        for(int i =0;i<occupiedSize;i++){
            if(i>=queueTopic.length-1)
                queueTopic[queueTopic.length-1]=0;
            else
                queueTopic[i] = queueTopic[i + 1];
        }
        occupiedSize--;
        return stratData;
    }

    public int queueSize(){
        return occupiedSize;
    }
}

上述思路是使用当队列第一个元素出队列时，剩下的队列中的元素，统一进行左移，然后保证新进的数据可以正常进入，同时出队列的位置也可以重新被利用，但是这样会造成大量的性能消耗。

使用数据实现队列(升级版)

class Queue1 {
    private int queueSize;
    private int headPointer;
    private int tailPointer;
    private int[] arr;

    public Queue1(int queueSize) {
        this.queueSize = queueSize;
        headPointer = -1;
        tailPointer = -1;
        arr = new int[queueSize];
    }

    public boolean isfull() {
        return headPointer - tailPointer >= queueSize;
    }

    public boolean isEmpty() {
        return headPointer == tailPointer;
    }


    public void addQueue(int num) {
        if (isfull()) System.out.println("队列满了，不能再插入数据");
        headPointer++;
        headPointer = headPointer % 3;

        arr[headPointer] = num;
    }

    public int getQueue() {
        if (isEmpty()) throw new RuntimeException("队列空了，不能再取数据");
        tailPointer++;
        tailPointer = tailPointer % 3;
        int tail = arr[tailPointer];
        arr[tailPointer] = 0;
        return tail;
    }

    public int getHeadQueue() {
        if (isEmpty()) throw new RuntimeException("队列空了，没有头数据");
        return arr[headPointer];
    }

    public int[] showQueues() {
        if (isEmpty()) throw new RuntimeException("队列空了，没有队列数据");

        for(int i=tailPointer+1;i<=tailPointer+getSize();i++){
            System.out.printf("队列中的数据:arr[%d]=%d\n",i%queueSize,arr[i%queueSize]);
        }

        return arr;
    }

    public int getSize() {
        return (queueSize+headPointer-tailPointer)%queueSize;
        //  下面所注释的代码可以合并成上面一句代码
        

       /* if(headPointer>=tailPointer){
            return headPointer-tailPointer;
        }else {
            //这个是指tailPointer指针大于headPointer指针时
            // 获取队列长度应该是  (queueSize-tailPointer-1)+(headPointer+1)
            return queueSize+headPointer-tailPointer;
        }*/
    }
}

这种思路是巧妙的使用一个环形队列来解决问题，不需要数组元素的迁移动作，从而大大增加了效率。