還是直接上代碼

package com.sbtufss.test;

import java.util.Arrays;

/**
 * 所謂的順序存儲結構，實際上就是用數組來存儲隊列的元素
 * @author sbtufss
 *
 */
public class ArrayQueue<T> {
    
    private int tLenght=3;//數組的大小，或者每次增加的大小
    //初始化能存放tLenght個元素的數組
    private Object[] t=new Object[tLenght];
    
    private int front;//對頭
    private
 
 int rear;//隊尾
    private int size;//隊列的大小，非常重要，一方面是為了防止指針溢出，另一方面，實際上是記錄隊列的大小，數組的大小不是隊列的大小
    
    public ArrayQueue(){
        super();
        front=0;
        rear=0;
        size=0;
    }
    
    /**
     * 數據插入從隊尾插入
     * @param data
     */
    public void add(T data){
        
        t[rear++]=data;
        size
 
++;
        if(size==t.length){//如果隊列的大小等於數組的大小，我們要對數組進行擴容之後，再玩裏面插入數據
            expansLength();
        }
        if(rear==t.length){
            rear=0;//如果此時的隊尾處於數組的最後一位，那麽就要將隊尾移到第一位
        }
    }
    
    /**
     * 從隊頭彈出數據，並且返回該數據，在這裏我沒有將t[front]賦值為null，是參考了win的刪除文件一樣，只是把指針移到別的位置，並沒有真正的清空
     */
    public
 
 T poll(){
        Object o=null;
        if(size>0){
            o=t[front];
            //然後我們就來處理front的數值
            if(front==(t.length-1)){//如果我們讀取是是數組的最後一位，那麽就隊頭就移到數組的第一位
                front=0;
            }else{
                front++;
            }
            size--;//返回數值之前要把隊列的大小－1
            return (T)o;
        }
        return null;
    }
    
    public int getSize(){
        return size;
    }
    
    /**
     * 對數組進行擴容
     */
    private void expansLength(){
        //對數組擴容，我們要在隊頭和隊尾中間插入一定長度的數組
        Object[] copy=new Object[t.length+tLenght];//擴容tLenght個元素
        if(front==0){
            System.arraycopy(t, 0, copy, 0, t.length);
        }else{
            System.arraycopy(t, front, copy, copy.length-size+rear,size-front);
            System.arraycopy(t, 0, copy, 0, rear);
            //重新給front賦值
            front=copy.length-size+rear;
        }
        t=copy;
    }
    
    
    @Override
    public String toString() {
        int temp=size;
        int index=front;

        StringBuilder sb=new StringBuilder();
        sb.append("[");
        while(temp>0){
            sb.append(t[index]).append(",");
            if(index==(t.length-1)){
                index=0;
            }else{
                index++;
            }
            temp--;
        }
        if(sb.length()!=1){
            sb.deleteCharAt(sb.length()-1);
        }
        sb.append("]");
        return sb.toString();
    }
    
    public String toTString(){
        return Arrays.toString(t);
    }
    
}

我們簡單的測試一下

package com.sbtufss.test;


public class Test {
    
    private static ArrayQueue<Integer> queue=new ArrayQueue<>();
    
    public static void main(String[] args) {
        queue.add(0);//目前隊列中的數據為[0]   數組為[0,null,null]
        queue.add(1);//目前隊列中的數據為[0,1]   數組為[0,1,null]
        queue.add(2);//目前隊列中的數據為[0,1,2]   數組為[0,1,2,null,null,null]
        //取出先進隊列的數，並且刪除他(假的刪除)
        queue.poll();//目前隊列中的數據為[1,2]   數組為[0,1,2,null,null,null]
        queue.add(3);//目前隊列中的數據為[1,2,3]   數組為[0,1,2,3,null,null]
        //然後我們在添加兩個數，讓他們數組自增長
        queue.add(4);//目前隊列中的數據為[1,2,3,4]    數組為[0,1,2,3,4,null]
        System.out.println("隊列的數據:"+queue);
        System.out.println("隊列中數組的數據"+queue.toTString());
        queue.add(5);//目前隊列中的數據為[1,2,3,4,5]    數組為[0,1,2,3,4,5]
        queue.add(6);//目前隊列中的數據為[1,2,3,4,5,6]    數組為[6,null,null,null,1,2,3,4,5]
        System.out.println("添加5之後隊列的數據:"+queue);
        System.out.println("添加5之後隊列中數組的數據"+queue.toTString());
    }
}

測試結果

隊列的順序存儲結構