数据结构9：队列简单的实现

代码不全只是自己记录学习，借鉴:https://blog.csdn.net/javazejian/article/details/52953190;强烈推荐此大神博客。。。

package myproject.work.Queue_demo;

import java.io.Serializable;
import java.util.NoSuchElementException;

/**
 * 队列的实现  插入数据时，是从rear上插入array[rear] = data，获取数据时从font上获取   data=array[font]，先进先出
 * @param <T>
 */
public class SeqQueue<T> implements Queue<T>,Serializable{

    //默认的队列大小
    private static final int DEAULT_SIZE=10;

    //用数组控制队列
    private T[] array;

    //头索引与为索引
    /**
     * 3种情况
     * 1.队列为空 font=rear
     * 2.队列满了 rear+1 = font
     * 3.队列不满添加数据  (rear+1)%arrary.length
     *
     */
    private int font,rear;

    //队列中元素的数量
    private int size;

    public SeqQueue() {
        //初始化
        array= (T[]) new Object[DEAULT_SIZE];

        font=rear=0;

    }

    public SeqQueue(int capacity) {
       array= (T[]) new Object[capacity];

       font=rear=0;
    }

    /**
     * 返回元素的数量
     * @return
     */
    @Override
    public int size() {
        return this.size;
    }

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

        //头索引和尾索引是否在一个位置
        return font==rear;
    }

    /**
     * 添加元素
     * @param data
     * @return
     */
    @Override
    public boolean add(T data) {
        //判断是否队列满了
        if (font==(rear+1)%array.length){
            encapacity(DEAULT_SIZE*2+1);

        }

        //将数据添加到rear上
        array[rear]=data;

        //将rear更新下一个索引位置
        this.rear=(this.rear+1)%array.length;

        size++;

        return true;
    }

    /**
     * 扩容的方法
     * @param capacity
     */
    public void encapacity(int capacity){

        if (capacity>size){

            return;
        }

        T[] old = this.array;
        this.array = (T[]) new Object[capacity];

        int j=0;
        //赋值元素
        for (int i =this.font; i !=this.rear ; i=(i+1)%old.length) {//i=(i+1)%old.length   循环利用存储单元**********************

            array[j++]=old[i];
        }


        //重新赋值
        rear=j;
        font=0;


    }


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

        //赋值
        array[rear]=data;
        //rear重新赋值
        rear=(rear+1)%array.length;

        size++;

        return true;
    }

    /**
     * 返回队头元素,不执行删除操作,若队列为空,返回null
     * @return
     */
    @Override
    public T peek() {
        return array[font];
    }

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

    @Override
    public T element() {
        if(isEmpty()){
            throw new NoSuchElementException("The SeqQueue is empty");
        }
        return peek();
    }


    /**
     * 出队,执行删除操作,返回队头元素,若队列为空,返回null
     * @return
     */
    @Override
    public T poll() {
        T t = array[font];

        array[font]=null;
        font=(font+1)%array.length;    //循环利用存储单元**********************

        size--;
        return t;
    }

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

        if (isEmpty()){

            throw new NoSuchElementException("队列为空");
        }

        return poll();
    }

    /**
     * 删除队列中所有元素
     * @return
     */
    @Override
    public void clearQueue() {
        for(int j=font;j!=rear;j=(j+1)%array.length){

            array[j]=null;
        }

        this.rear=this.font=0;
        this.size=0;

    }


    public static void main(String[] args) {
        SeqQueue<Integer> queue=new SeqQueue<>();

        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);

            System.out.println(queue.poll());
            System.out.println(queue.poll());
            System.out.println(queue.poll());
            System.out.println(queue.poll());
//        1
//        2
//        3
//        4
    }
}