数组模拟环形队列

思路：(通过取模的方式)

1.front含义变化：front指向队头，初始值为0；
2.rear含义变化：rear指向队尾的后一个元素，初始值为0；
留一个空间作为约定
3.队满条件：(rear+1)%MaxSize=front;
4.队列为空：rear=front；
5.队列中有效元素个数：(rear+MaxSize-front)%MaxSize

环形队列特点：
不需要进行动态的内存释放和分配,使用固定大小的内存空间反复使用。

package com;


import com.sun.glass.ui.Size;
import com.sun.jmx.remote.internal.ArrayQueue;
import org.omg.CORBA.portable.IDLEntity;
import org.omg.SendingContext.RunTime;

import java.util.Scanner;

//数组模拟队列
public class QueueArray {

    private int MaxSize;
    private int rear;
    private int front;
    private int []arr;

    public static void main(String[] args) {
        //创建队列
        QueueArray arr= new QueueArray(2);  //其实最大为1，因为留了一个作为约定
        char key=' ';  //接收用户输入
        Scanner sc=new Scanner(System.in);
        boolean loop=true;


        System.out.println("s(show):显示队列");
        System.out.println("a(add):添加数据");
        System.out.println("g(get):获取数据");
        System.out.println("h(head):显示头数据");
        System.out.println("e(exit):退出");

        //输出一个菜单
        while(loop)
        {

            key=sc.next().charAt(0);  //接收一个字符
            switch (key){
                case's':
                    arr.show();
                    break;
                case'a':
                    System.out.println("输入一个数：");
                    int value=sc.nextInt();
                    arr.add(value);
                    break;
                case'g':
                  try{
                      int res=arr.get();
                      System.out.printf("%d",res);

                  }catch (Exception e){
                      System.out.println(e.getMessage());
                  }
                  break;
                case'h':
                    try{

                        int res=arr.head();
                        System.out.printf("%d",res);

                    }
                    catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;

                case'e':
                    sc.close();
                    loop=false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");



    }

    //创建队列
    public QueueArray(int arrMaxSize){
        MaxSize=arrMaxSize;
        arr=new int[MaxSize];


    }

    //判断队列是否为满
    public boolean isFull(){
        return (rear+1)%MaxSize==front;
    }
    //是否为空
    public boolean isEmpty(){
        return rear==front;
    }

    //添加数据
    public void add(int n){
        if(isFull())
        {
            System.out.println("队列满了，不能加入");
            return;
        }else{

           arr[rear]=n;
           //此处必须考虑取模
            rear=(rear+1)%MaxSize;

        }
    }

    //取出数据
    public int get(){
        if(isEmpty())
        {
            //通过抛出异常来处理
          throw new RuntimeException("队列空，不能取出数据");
        }
        else{
         //找一个临时变量保存front，然后front后移，然后将临时变量返回
            int value=arr[front];
            front=(front+1)%MaxSize;
            return value;

        }
    }

    //显示当前数据
    public void show(){
        //遍历
        if(isEmpty())
        {
            System.out.println("队列空");
        }

           //从front开始遍历
            for(int i = front; i<front+ Size(); i++)
                System.out.printf("arr[%d]=%d",i%MaxSize,arr[i%MaxSize]);


    }

    public int Size(){
        return (rear+MaxSize-front)%MaxSize;
    }
    //显示队列头数据
    public int head(){
        if(isEmpty())
        {

            throw new RuntimeException("没有数据");
        }
        return arr[front+1];
    }


}