数组模拟队列代码实现及队列复用的代码优化

初期代码实现如下：

package com.liu.queue;

import java.util.Scanner;

public class MyQueue {
    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("(a)add:添加");
            System.out.println("(g)get:取出");
            System.out.println("(f)showF:显示头部");
            System.out.println("(e)exit:退出");
            key = scanner.next().charAt(0);//接收一个字符
            switch (key){
                case 's':
                    try{
                        queue.getArr();
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'a':
                    System.out.println("请输入一个数字：");
                    int a = scanner.nextInt();
                    try{
                        queue.add(a);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'g':
                    try{
                        queue.get();
                    } catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'f':
                    try{
                        queue.getFront();
                    } catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
            }
        }
    }
}
class Queue{
    private int MaxSize;
    private int front;
    private int rear;
    private int[] arr;
//  参数进行初始化
    public Queue(int maxSize) {
        MaxSize = maxSize;
        front = -1;
        rear = -1;
        arr = new int[maxSize];
    }
//  判断队列什么时候是满的
    public Boolean isFull(){
//      队列满 true
        if(rear == MaxSize - 1){
            return true;
        }
//      不满返回false
        return false;
    }
//  判断队列是不是为空
    public Boolean isEmpty(){
        if (front == -1 && rear == -1){
            return true;
        }
        return false;
    }
//  向队列中添加元素
    public void add(int num){
        if (this.isFull()){
            throw new RuntimeException("元素已满，无法进行添加元素");
        }
//      rear后移
        rear++;
        arr[rear] = num;
    }
//  在队列中取元素
    public int get(){
        if(this.isEmpty()){
            throw new RuntimeException("元素为空，无法取出元素");
        }
        if(rear == front){
            throw new RuntimeException("元素为空，无法取出元素");
        }
//      front初始为-1
        front++;
        return arr[front];
    }
//  查询全部的元素
    public void getArr(){
        if (this.isEmpty()){
            throw new RuntimeException("没有元素查询");
        }
        if(rear == front){
            throw new RuntimeException("没有元素查询");
        }
        for (int i = front + 1; i < rear+1; i++) {
            System.out.println(arr[i]);
        }
    }
//  查询头部元素
    public void getFront(){
        if (this.isEmpty()){
            throw new RuntimeException("没有元素查询");
        }
        System.out.println(arr[front+1]);
    }
}

效果演示：

 

 

 

 

 但是，上述代码的实现是有弊端的，取出一次值后，就无法继续取值了：

对MaxSize取模后，就可以对数组实现代码复用，而不需要担心越界问题：

package com.liu.queue1;

import java.util.Scanner;

public class MyQueue {
    public static void main(String[] args) {
        Queue queue = new Queue(4);
        char key = ' ';
        Scanner scanner = new Scanner(System.in);
        Boolean loop = true;
        while(loop){
            System.out.println("(s)show:显示队列");
            System.out.println("(a)add:添加");
            System.out.println("(g)get:取出");
            System.out.println("(f)showF:显示头部");
            System.out.println("(e)exit:退出");
            key = scanner.next().charAt(0);//接收一个字符
            switch (key){
                case 's':
                    try{
                        queue.getArr();
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'a':
                    System.out.println("请输入一个数字：");
                    int a = scanner.nextInt();
                    try{
                        queue.add(a);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'g':
                    try{
                        queue.get();
                    } catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'f':
                    try{
                        queue.getFront();
                    } catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
            }
        }
    }
}
class Queue{
    private int MaxSize;
//  front=0 指向队列的第一个元素，也就是说arr[front]
//  rear=0 指向队列的最后一个元素的后一个位置，因此希望空出一个位置
    private int front;
    private int rear;
    private int[] arr;
//  参数进行初始化
    public Queue(int maxSize) {
        MaxSize = maxSize;
        front = 0;
        rear = 0;
        arr = new int[maxSize];
    }
//  判断队列什么时候是满的
    public Boolean isFull(){
//      队列满true
//      取模保证数组不越界
        if((rear+1)  % MaxSize == front){
            return true;
        }
//      不满返回false
        return false;
    }
//  判断队列是不是为空
    public Boolean isEmpty(){
        if (front == rear){
            return true;
        }
        return false;
    }
//  向队列中添加元素
    public void add(int num){
        if (isFull()){
            throw new RuntimeException("元素已满，无法进行添加元素");
        }
//      rear后移
        arr[rear] = num;
        rear = (rear + 1) % MaxSize;
    }
//  在队列中取元素
    public int get(){
        if(isEmpty()){
            throw new RuntimeException("元素为空，无法取出元素");
        }
//      front初始为0
        int value = arr[front];
        front = (front+1) % MaxSize;
        return value;
    }
//  查询全部的元素
    public void getArr(){
        if(rear == front){
            throw new RuntimeException("没有元素查询");
        }
        for (int i = front ; i < front + getSize(); i++) {
//          保证输出的时候不越界
            System.out.println("arr[" + i%MaxSize + "]"+arr[i % MaxSize]);
        }
    }
//  获取有效数据的个数
    public int getSize(){
        return (rear - front + MaxSize) % MaxSize;
    }
//  查询头部元素
    public void getFront(){
        if (isEmpty()){
            throw new RuntimeException("没有元素查询");
        }
        System.out.println("arr[" + front % MaxSize + "]" + arr[front]);
    }
}

按照这种方式，就可以实现队列的复用啦

具体测试，可以粘贴粘贴代码，自行测试，此处略。