使用Java 1.8数组实现循环队列

package DataStructure;

import java.util.Arrays;

/**
 * @author: Inki
 * @email: inki.yinji@qq.com
 * @create: 2020 1022
 * @last_modify: 2020 1023
 */

public class MyArrayQueue<AnyType> {

  /**
   * The default max size of my array queue.
   */
  private final int DEFAULT_MAX_SIZE = 10;

  /**
   * The max size of my array queue.
   */
  private int maxSize;

  /**
   * The front of my array queue.
   */
  private int front;

  /**
   * The rear of my array queue.
   */
  private int rear;

  /**
   * Using array to simulate queue.
   */
  private AnyType[] arrQueue;

  /**
   * The first constructor.
   */
  public MyArrayQueue() {
    this(DEFAULT_MAX_SIZE);
  }//Of the first constructor

  /**
   * The second constructor.
   */
  public MyArrayQueue(int paraMaxSize) {
    maxSize = paraMaxSize + 1;
    arrQueue = (AnyType[]) new Object[maxSize];
    front = 0;
    rear = 0;
  }//Of the second constructor

  /**
   * Queue is full&#63;
   * @return:
   *   True if full else false.
   */
  public boolean isFull() {
    return (rear + 1) % maxSize == front;
  }//Of isFull

  /**
   * Queue is empty&#63;
   * @return:
   *   True if empty else false.
   */
  public boolean isEmpty() {
    return front == rear;
  }//Of isEmpty

  /**
   * Add element.
   * @param:
   *   paraVal:
   *     The given value.
   */
  public void add(AnyType paraVal) {
    if(isFull()) {
      System.out.println("The queue is full.");
      return;
    }//Of if
    arrQueue[rear] = paraVal;
    rear = (rear + 1) % maxSize;
  }//Of add

  /**
   * Pop element.
   */
  public AnyType pop() {
    if (isEmpty()) {
      throw new RuntimeException("The queue is full.");
    }//Of if
    AnyType retVal = arrQueue[front];
    front = (front + 1) % maxSize;
    return retVal;
  }//of pop

  /**
   * Display array queue.
   */
  public void display() {
    if (isEmpty()) {
      System.out.println("The queue is empty.");
      return;
    }//Of if

    System.out.print("The queue is: [");
    int i = front;
    while (i != (rear + maxSize- 1) % maxSize) {
      System.out.printf("%s, ", arrQueue[i]);
      i = (i + 1) % maxSize;
    }//Of while
    System.out.printf("%s]", arrQueue[rear - 1]);
  }//Of display

  /**
   * Get current size of my array queue.
   */
  public int getSize() {
    return (rear - front + maxSize) % maxSize + 1;
  }//Of getSize

  /**
   * The main
   **/
  public static void main(String[] args) {
    MyArrayQueue <Integer> testArrayQueue = new MyArrayQueue<>(3);
    testArrayQueue.add(1);
    testArrayQueue.add(2);
    testArrayQueue.add(4);
    testArrayQueue.pop();
    testArrayQueue.display();
  }//Of main

}//Of MyArrayQueue