实现一个简单的队列（底层数组）

队列的特色

1. 先进先出（FIFO）
2. 容许在表的一端插入数据，在另外一端删除数据

---

 

所需元素

1. 数组queueArray
2. 指向队头的指针front
3. 指向队尾的指针rear
4. 记录队列元素数量的elements
5. 数组的初始化大小maxSize

---

 

分析实现

　　1. 在实例化队列类时肯定数组大小并初始化数组
　　2. 肯定队列具备的功能：

　　　　（1）EnQueue(Object obj) 　　插入元素，即元素入队，而且是在队尾入队

　　　　（2）DeQueue() 　　删除元素，即元素出队，而且是在队头出队

　　　　（3）isEmpty()　　判空

　　　　（4）isFull() 　　判满

　　　　（5）getHead() 　　查看队头元素，只查看，不删除

　　　　（6）length()　　查看队列长度

　　　　（7）clear()　　清空队列

---

 

代码实现

 1 public class Queue {
 2 
 3     /**
 4      * queueArray 底层数组
 5      * front 队头
 6      * rear 队尾
 7      * elements 队列元素
 8      * maxSize 数组最大容量
 9      */
10     private Object[] queueArray;
11     private int front;
12     private int rear;
13     private int elements;
14     private int maxSize;
15 
16     /**
17      * 初始化操做
18      * @param maxSize
19      */
20     public Queue(int maxSize) {
21         this.maxSize = maxSize;
22         this.queueArray = new Object[maxSize];
23         this.front = 0;
24         this.rear = 0;
25         this.elements = 0;
26     }
27 
28     /**
29      * 判断队列是否为空
30      * @return
31      */
32     public boolean isEmpty() {
33         return (elements == 0);
34     }
35 
36     /**
37      * 判断队列是否为满队列
38      * @return
39      */
40     public boolean isFull() {
41         return (elements == maxSize);
42     }
43 
44     /**
45      * 插入元素，即元素入队，而且是在队尾入队
46      * @param data
47      */
48     public void enQueue(Object data) {
49         if (isFull()) {
50             throw new RuntimeException("队列已满");
51         }
52         queueArray[rear++] = data;
53         elements++;
54     }
55 
56     /**
57      * 删除元素，即元素出队，而且是在队头出队
58      * @return
59      */
60     public Object deQueue() {
61         if (isEmpty()) {
62             throw new RuntimeException("空队列");
63         }
64         // 其实这里并无真正删除数组里的元素，只是访问指针往上移，即不提供访问被删除元素的方式
65         Object data = queueArray[front++];
66         elements--;
67         return data;
68     }
69 
70     /**
71      * 查看队头元素，只查看，不删除
72      * @return
73      */
74     public Object getHead() {
75         Object data = queueArray[front];
76         return data;
77     }
78 
79     /**
80      * 查看队列长度
81      * @return
82      */
83     public int length() {
84         return elements;
85     }
86 
87     /**
88      * 清空队列
89      */
90     public void clear() {
91         while (front != rear) {
92             deQueue();
93         }
94     }
95 }

 

测试

 1 public class QueueTest {
 2 
 3     public static void main(String[] args) {
 4 
 5         Queue queue = new Queue(4);
 6 
 7         System.out.println("队列是否为空? " + queue.isEmpty());
 8 
 9         queue.enQueue(11);
10         queue.enQueue(2);
11         queue.enQueue(5);
12         queue.enQueue(67);
13 
14         System.out.println("队列是否已满? " + queue.isFull());
15         System.out.println("队头元素： " + queue.getHead());
16         System.out.println("队列长度： " + queue.length());
17 
18         System.out.print("打印队列元素： ");
19         while (!queue.isEmpty()) {
20             Object o = queue.deQueue();
21             System.out.print(o + "\t");
22         }
23         System.out.println();
24 
25         /*queue.enQueue(5);
26         queue.enQueue(67);*/
27         // 清空队列
28         queue.clear();
29         System.out.println("清空队列后，队列是否为空? " + queue.isEmpty());
30     }
31 }

 

结果

队列是否为空? true
队列是否已满? true
队头元素： 11
队列长度： 4
打印队列元素： 11    2    5    67    
清空队列后，队列是否为空? true

 

---

 

总结

1. 只容许在队尾rear插入元素；
2. 只容许在队头front删除元素；
3. 本例子插入和删除都是队头队尾指针的移动，所存储的元素并不会移动；
4. 删除的元素其实还存在数组中，只是不提供访问的方法；
5. 使用数组实现，扩容困难。