java 顺序结构循环队列（源代码）

1.import java.util.Arrays;  
2.public class LoopQueue<T>  
3.{  
4.    private int DEFAULT_SIZE = 10;  
5.    //保存数组的长度。  
6.    private int capacity;  
7.    //定义一个数组用于保存循环队列的元素  
8.    private Object[] elementData;  
9.    //保存循环队列中元素的当前个数  
10.    private int front = 0;  
11.    private int rear = 0;  
12.    //以默认数组长度创建空循环队列  
13.    public LoopQueue()  
14.    {  
15.        capacity = DEFAULT_SIZE;  
16.        elementData = new Object[capacity];  
17.    }  
18.    //以一个初始化元素来创建循环队列  
19.    public LoopQueue(T element)  
20.    {  
21.        this();  
22.        elementData[0] = element;  
23.        rear++;  
24.    }  
25.    /** 
26.     * 以指定长度的数组来创建循环队列 
27.     * @param element 指定循环队列中第一个元素 
28.     * @param initSize 指定循环队列底层数组的长度 
29.     */  
30.    public LoopQueue(T element , int initSize)  
31.    {  
32.        this.capacity = initSize;  
33.        elementData = new Object[capacity];  
34.        elementData[0] = element;  
35.        rear++;  
36.    }  
37.    //获取循环队列的大小  
38.    public int length()  
39.    {  
40.        if (empty())  
41.        {  
42.            return 0;  
43.        }  
44.        return rear > front ? rear - front   
45.            : capacity - (front - rear);  
46.    }  
47.    //插入队列  
48.    public void add(T element)  
49.    {  
50.        if (rear == front   
51.            && elementData[front] != null)  
52.        {  
53.            throw new IndexOutOfBoundsException("队列已满的异常");  
54.        }  
55.        elementData[rear++] = element;  
56.        //如果rear已经到头，那就转头  
57.        rear = rear == capacity ? 0 : rear;  
58.    }  
59.    //移除队列  
60.    public T remove()  
61.    {  
62.        if (empty())  
63.        {  
64.            throw new IndexOutOfBoundsException("空队列异常");  
65.        }  
66.        //保留队列的rear端的元素的值  
67.        T oldValue = (T)elementData[front];  
68.        //释放队列的rear端的元素  
69.        elementData[front++] = null;   
70.        //如果front已经到头，那就转头  
71.        front = front == capacity ? 0 : front;  
72.        return oldValue;  
73.    }  
74.    //返回队列顶元素，但不删除队列顶元素  
75.    public T element()  
76.    {  
77.        if (empty())  
78.        {  
79.            throw new IndexOutOfBoundsException("空队列异常");  
80.        }  
81.        return (T)elementData[front];  
82.    }  
83.    //判断循环队列是否为空队列  
84.    public boolean empty()  
85.    {  
86.        //rear==front且rear处的元素为null  
87.        return rear == front   
88.            && elementData[rear] == null;  
89.    }  
90.    //清空循环队列  
91.    public void clear()  
92.    {  
93.        //将底层数组所有元素赋为null  
94.        Arrays.fill(elementData , null);  
95.        front = 0;  
96.        rear = 0;  
97.    }  
98.    public String toString()  
99.    {  
100.        if (empty())  
101.        {  
102.            return "[]";  
103.        }  
104.        else  
105.        {  
106.            //如果front < rear，有效元素就是front到rear之间的元素  
107.            if (front < rear)  
108.            {  
109.                StringBuilder sb = new StringBuilder("[");  
110.                for (int i = front  ; i < rear ; i++ )  
111.                {  
112.                    sb.append(elementData[i].toString() + ", ");  
113.                }  
114.                int len = sb.length();  
115.                return sb.delete(len - 2 , len).append("]").toString();  
116.            }  
117.            //如果front >= rear，有效元素为front->capacity之间、0->front之间的  
118.            else  
119.            {  
120.                StringBuilder sb = new StringBuilder("[");  
121.                for (int i = front  ; i < capacity ; i++ )  
122.                {  
123.                    sb.append(elementData[i].toString() + ", ");  
124.                }  
125.                for (int i = 0 ; i < rear ; i++)  
126.                {  
127.                    sb.append(elementData[i].toString() + ", ");  
128.                }  
129.                int len = sb.length();  
130.                return sb.delete(len - 2 , len).append("]").toString();  
131.            }  
132.        }  
133.    }  
134.}