数组模拟队列

1. 遵循先入先出的原则，即：先存入队列的数据，要先取出，后存入的要后取出
2. 1. 当尾指针往后移：rear+1，当 front=rear【空】
   2. 若尾指针 rear 小于队列最大下标 maxSize-1，则将数据存入 rear 所指的数组元素中，否则无法存入数据，rear=maxSize-1【队列满】

      public class ArrayQueueDemo {
          public static void main(String[] args) {
              //测试一把
              //创建一个队列
              ArrayQueue arrayQueue = new ArrayQueue(3);
              char key=' '; //接收用户输入
              Scanner scanner = new Scanner(System.in);
              boolean loop=true;
              //输出一个菜单
              while (loop){
                  System.out.println("s(show): 显示队列");
                  System.out.println("e(exit): 退出程序");
                  System.out.println("a(add): 添加数据到队列");
                  System.out.println("g(get): 从队列取出数据");
                  System.out.println("h(head): 查看队列头的数据");
                  key=scanner.next().charAt(0); //接收一个字符
                  switch (key){
                      case 's':
                          arrayQueue.showQueue();;
                          break;
                      case 'a':
                          System.out.println("输出一个数");
                          int value=scanner.nextInt();
                          arrayQueue.addQueue(value);
                          break;
                      case 'g':
                          try {
                              int res= arrayQueue.getQueue();
                              System.out.printf("取出的数据是%d\n",res);
                          }catch (Exception e){
                              System.out.println(e.getMessage());
                          }
                          break;
                      case 'h': //查看队列头的数据
                          try{
                              int res=arrayQueue.headQueue();
                              System.out.printf("队列头的数据是%d\n",res);
                          } catch (Exception e){
                              System.out.println(e.getMessage());
                          }
                      case 'e': //退出
                          scanner.close();
                          loop=false;
                          break;
                      default:
                          break;
                  }
              }
              System.out.println("程序退出");
          }
      }
      
      class ArrayQueue{
          private int maxSize;  //表示数组的最大容量
          private int front;  //队列头
      
          private int rear; //队列尾
      
          private int[] arr; //该数组用于存放数据
      
          //创建队列的构造器
      
          public ArrayQueue(int arrMaxSize){
              maxSize=arrMaxSize;
              arr=new int[maxSize];
              front=-1; //指向队列头部，分析出front是指向队列头的前一个位置
              rear=-1; //指向队列尾部，指向队列尾部的数据(即就是队列最后一个数据)
          }
      
          //判断队列是否满
          public boolean isFull(){
              return rear==maxSize-1;
          }
      
          //判断队列是否为空
          public boolean isEmpty(){
              return rear==front;
          }
      
          //添加数据到队列
          public void addQueue(int n){
              if (isFull()){
                  System.out.println("队列满，不能加入数据");
                  return;
              }
              rear++; //让rear后移
              arr[rear]=n;
          }
      
          //获取队列的数据，出队列
          public int getQueue(){
              //判断队列是否为空
              if (isEmpty()){
                  throw new RuntimeException("队列为空，不能取数据");
              }
              front++; //front后移
              return arr[front];
          }
      
          //显示队列的所有数据
          public void showQueue(){
              //遍历
              if (isEmpty()){
                  System.out.println("队列为空");
                  return;
              }
              for (int i=0; i<arr.length;i++){
                  System.out.printf("arr[%d]=%d\n",i,arr[i]);
              }
          }
      
          //显示队列的头部，不是取出数据
          public int headQueue(){
              if (isEmpty()){
                  System.out.println("队列为空");
              }
              return arr[front+1];
          }
      }
      
      

      目前数据使用一次就不能使用了，不能达到复用的效果，后续将使用算法将此改进成一个环形的数组