Java队列

Java队列

队列的两端都"开口"，要求数据只能从一端进，从另一端出，且数据的进出要遵循 “先进先出” 的原则，即最先进队列的数据元素，同样要最先出队列。

其中，对于队列中的某一数组来说具有font和back还有个数currentsize，操作enquene是在rear插入一个元素，dequene是删除并返回在font的一个元素，不浪费空间的方法即为循环队列

接口实现：
/*
 *项目名: JavaTest
 *文件名: Quene
 *创建者: ZhangChengkai
 *创建时间:2020/1/4 22:14
 */

public interface Quene<T> {
    /**
     * 返回队列长度
     * @return
     */
    int size();

    /**
     * 判断队列是否为空
     * @return
     */
    boolean isEmpty();

    /**
     * data 入队,添加成功返回true,否则返回false,可扩容
     * @param data
     * @return
     */
    boolean add(T data);

    /**
     * offer 方法可插入一个元素,这与add 方法不同，
     * 该方法只能通过抛出未经检查的异常使添加元素失败。
     * 而不是出现异常的情况，例如在容量固定（有界）的队列中
     * NullPointerException:data==null时抛出
     * @param data
     * @return
     */
    boolean offer(T data);

    /**
     * 返回队头元素,不执行删除操作,若队列为空,返回null
     * @return
     */
    T peek();

    /**
     * 返回队头元素,不执行删除操作,若队列为空,抛出异常:NoSuchElementException
     * @return
     */
    T element();

    /**
     * 出队,执行删除操作,返回队头元素,若队列为空,返回null
     * @return
     */
    T poll();

    /**
     * 出队,执行删除操作,若队列为空,抛出异常:NoSuchElementException
     * @return
     */
    T remove();

    /**
     * 清空队列
     */
    void clearQueue();
}

顺序队列：
/*
 *项目名: JavaTest
 *文件名: ArrayQuene
 *创建者: ZhangChengkai
 *创建时间:2020/1/5 10:03
 */

import java.util.NoSuchElementException;

public class ArrayQuene<T> implements Quene<T> {
    private int front;
    private int rear;
    private int size;
    private T element[];

    public ArrayQuene() {
        element = (T[]) new Object[1000];
        front = rear = 0;
    }

    public ArrayQuene(int capacity) {
        element = (T[]) new Object[capacity];
        front = rear = 0;
    }

    /**
     * 返回队列长度
     *
     * @return
     */
    @Override
    public int size() {
        return size;
    }

    /**
     * 判断队列是否为空
     *
     * @return
     */
    @Override
    public boolean isEmpty() {
        return front == rear;
    }

    /**
     * data 入队,添加成功返回true,否则返回false,可扩容
     *
     * @param data
     * @return
     */
    @Override
    public boolean add(T data) {
        if (this.front == (this.rear + 1) % this.element.length) {
            dilatation(element.length * 2 + 1);
        }
        element[this.rear] = data;
        this.rear = (this.rear + 1) % element.length;
        size++;
        return true;
    }

    /**
     * 扩容
     *
     * @param capacity
     */
    public void dilatation(int capacity) {
        if (capacity < size) {
            return;
        }
        T[] old = element;
        element = (T[]) new Object[capacity];
        int j = 0;
        for (int i = this.front; i != rear; i = (i + 1) % old.length) {
            element[j++] = old[i];
        }
        this.front = 0;
        this.rear = j;
    }

    /**
     * offer 方法可插入一个元素,这与add 方法不同，
     * 该方法只能通过抛出未经检查的异常使添加元素失败。
     * 而不是出现异常的情况，例如在容量固定（有界）的队列中
     * NullPointerException:data==null时抛出
     *
     * @param data
     * @return
     */
    @Override
    public boolean offer(T data) {
        if (data == null)
            throw new NullPointerException("The data can't be null");
        //队满抛出异常
        if (this.front == (this.rear + 1) % this.element.length) {
            throw new IllegalArgumentException("The capacity of SeqQueue has reached its maximum");
        }

        //添加data
        element[this.rear] = data;
        //更新rear指向下一个空元素的位置
        this.rear = (this.rear + 1) % element.length;
        size++;
        return true;
    }

    /**
     * 返回队头元素,不执行删除操作,若队列为空,返回null
     *
     * @return
     */
    @Override
    public T peek() {
        if (isEmpty()) {
            return null;
        } else return this.element[front];
    }

    /**
     * 返回队头元素,不执行删除操作,若队列为空,抛出异常:NoSuchElementException
     *
     * @return
     */
    @Override
    public T element() {
        if (isEmpty()) {
            throw new NoSuchElementException("The Queue is empty");
        }
        return peek();
    }

    /**
     * 出队,执行删除操作,返回队头元素,若队列为空,返回null
     *
     * @return
     */
    @Override
    public T poll() {
        T temp = this.element[this.front];
        this.front = (this.front + 1) % this.element.length;
        size--;
        return temp;
    }

    /**
     * 出队,执行删除操作,若队列为空,抛出异常:NoSuchElementException
     *
     * @return
     */
    @Override
    public T remove() {
        if (isEmpty()) {
            throw new NoSuchElementException("The Queue is empty");
        }
        return poll();
    }

    /**
     * 清空队列
     */
    @Override
    public void clearQueue() {
        for (int i = this.front; i != this.rear; i = (i + 1) % element.length) {
            element[i] = null;
        }
        //复位
        this.front = this.rear = 0;
        size = 0;
    }

    public static void main(String[] args) {
        ArrayQuene<String> quene = new ArrayQuene<String>();
        quene.add("a");
        quene.add("b");
        quene.add("c");
        quene.poll();
        System.out.println(quene.element());
        while (!quene.isEmpty()) {
            String temp = quene.remove();
            System.out.println(temp);
        }

    }
}

结果：