队列(存储结构数组)--Java实现

/*队列：其实也是一种操作受限的线性表
 *特点：先进先出
 *队尾指针：负责元素的进队
 *队头指针：负责元素的出队
 *注意：普通队--容易浪费空间，一般队列使用最多的就是循环队列--指针环绕
 *队列的实现方式：数组/链表
 *队列判空判满：
 *1.按照队列中元素的个数
 *2.按照队头和队尾指针的关系
 *存在双端队列：每端都可以插入和删除，其变形可以是操作受限的双端队列
 *队列的应用：其实很多现实世界的规则都是按照排队这种思想
 * */
public class MyQueue {
    private int items;//队列元素的个数
    private long[] arr;//存储数组
    private int front;//队头指针
    private int rear;//队尾指针
    private int maxSize;//数组的长度
    
    public MyQueue(int s) {
        maxSize = s;
        arr = new long[maxSize];
        front = 0;
        rear = -1;
        items = 0;
    }
    
    //进队--先加在取
    public void insert(long key){
        if(rear == maxSize - 1){
            rear = -1;
        }
        arr[++rear] = key;
        items++;
    }
    
    //出队--先取在加1
    public long remove(){
        long num = arr[front++];
        if(front == maxSize){
            front = 0;
        }
        items--;
        return num;
    }
    
    //获取队头
    public long getFront(){
        return arr[front];
    }
    
    //判空
    public boolean isEmpty(){
        return items == 0;
    }
    
    public boolean isEmpty1(){
        return (rear + 1 == front ||(front + maxSize - 1 == rear));
    }
    
    
    
    //判满
    public boolean isFull(){
        return rear == maxSize;
    }
    
    public boolean isFull1(){
        return (rear + 2 == front ||(front + maxSize - 2 == rear));
    }
    
    //获取队列元素个数
    public int size(){
        return items;
    }
    
    public int size1(){
        if(rear >= front){
            return rear - front + 1;
        }
        else{
            return (maxSize - front) + (rear + 1);
        }
    }
    
    //显示队列
    public void displayQueue(){
        for(int i = front;i < rear;i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    
    
}