数组模拟队列(Java语言实现)：

1.队列的基本概念:

队列遵循先进先出的概念，当一个数据先进入队列中的话，取出数据时，这个数据就会先被取出来。

例如：一个队列存入了1、2、3、4、5 这几个数据，取这几个数据的顺序就是 1、2、3、4、5

2.各个属性的含义:

front：指向队列头部前一个的位置

rear：队列尾部,用来指向队列尾部数据的一个指针

maxSize：代表该数组的最大存储容量

front和rear的初始值都是-1。

3.将要实现的操作：

1.进队时,rear的指针往后移一位,然后在该位置放入元素。

2.出队时,front先加+1，然后取出该位置的元素

4.实现思路:

1.实现队列进队(存入数据)、出队(取出数据),要考虑两个问题，进队时,该队列是否已满,如果不满,则可以存入

数据,出队时，该队列是否没有数据(也就是空的队列),如果队列中有数据,则可以出队(取出数据)。

2.判断该队列是否已满：rear==maxSize-1 则表示该队列已满. 因为该队列maxSize代表了该数组(数组模拟队列)的最大存储容量,而rear指向的是队列尾部的数据(下标从0开始算),所以当rear==maxSize-1时，代表该队列已存满数据

3.判断该队列是否为空：rear==front,当rear和front相等时,就代表了尾部指针和头部指针指向同一个位置，则该队列为空。

5.代码：

package com.lzh.queue;

import java.util.Scanner;

//使用数组模拟实现队列
public class ArrayQueue {
    public static void main(String[] args) {
        //测试--创建一个队列
        Queue queue = new Queue(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); 要放在这个位置
            key = scanner.next().charAt(0); //接收用户输入的第一个字符
            switch (key) {
                case 's':
                   queue.showAll();
                    break;
                case 'e' :
                    scanner.close();
                    loop = false;
                    System.out.println("程序退出");
                    break;
                case 'a' :
                    System.out.println("请输入一个整数");
                    int a = scanner.nextInt();
                    queue.addQueue(a);
                    break;
                case 'g' :
                    try {
                        int res = queue.getQueue();
                        System.out.println(res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }

                    break;
                case 'h' :
                    try{
                        int head = queue.getHead();
                        System.out.println(head);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                
            }


        }
    }

     static    class Queue {
            private int maxSize;//数组最大储存空间
            private int front;//队列头部，指向该队列头部的前一个位置
            private int rear;//队列尾部,指向该队列尾部的数据
            private int[] arr;//创建一个数组,使用数组来模拟队列

            //创建一个构造方法,来进行传参
            public Queue(int arrMaxSize) {
                //这里没用this.maxSize是因为:this是强调该实例变量,因为传入的参数和该类的属性名字不一样,程序自己可以找到该属性进行赋值
                //如果这里传入的参数和该类属性中的参数名字是一样的话,这个时候就要加上this了(如:this.maxSize=arrMaxSize)
                maxSize = arrMaxSize;
                arr = new int[maxSize];
                front = -1;
                rear = -1;
            }

            //判断该队列是否已经存满了数据
            public boolean isFull() {
                return rear == maxSize - 1;
            }

            //判断该队列是否为空
            public boolean isNull() {
                return rear == front;
            }

            //添加数据到队列
            public void addQueue(int n) {
                //先判断该队列是否满了,如果没满,则可以把数据添加到该队列
                if (isFull()) {
                    System.out.println("该数列已满,不能再添加数据了");
                    return;
                }
                //该队列没满的情况下执行下面的代码
                rear++;
                arr[rear] = n;
            }

            //从队列中取出数据(出列)
            public int getQueue() {
                //从队列取数据时,先判断该队列是否为空
                if (isNull()) {
                    //如果执行到这里了 就代表该队列是空的,所以执行时,抛出一个异常
                    throw new RuntimeException("该队列为空,不能再进行出列操作了");
                    //抛出异常之后，就自己return了,所以不用再写return了，再在这个异常下面写代码就会
                    //UnReachable Code 不能到达的代码
                }
                front++;//front后移
                return arr[front];//把从队列中取到的数据返回
            }
            //得到队列的第一个数据,即头部数据 注意 不是取数据
         public int getHead(){
                if(isNull()){
                    //如果队列为空,则抛出异常
                    throw new RuntimeException("该队列为空,取不到头部数据");
                }
                //这里只是显示头部数据,所以front指针不往后移,只需要在arr[]中让front+1就可以了。
             //front++ 是在这个类中 这个变量改变了,而在arr[]中没有变,只是让front+1
                return arr[front+1];
         }
            //显示队列的所有数据
            public void showAll() {
                //先判断该队列是否为空
                if (isNull()) {
                    System.out.println("该队列为空,取不到数据");
                    return;
                }
                for (int i = 0; i < arr.length; i++) {
                    System.out.printf("arr[%d]=%d\n", i, arr[i]);
                }
            }
        }



}

6.问题：

1.这个程序运行之后我们会发现,该队列只能用一次,而且,我们取出数据之后,队列中的数据并没有消失。

不能达到一个复用的效果(假溢出)。

7.解决方案：

我们这时使用一个环形队列来解决一个假溢出的问题,从而达到队列复用的效果。这里我们在下篇文章实现。

本人自学数据结构后的个人理解,如有问题,欢迎各位大牛来指正,帮助本人更好的理解。

下篇文章见