Go语言视频零基础入门到精通

javalearner

队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。这也就是我 们平常经常用说到的先进先出原则（FIFO）。java 中的 List 就可以作为队列来使用，在队列尾部添加元素则使用 list.add 方法，从队列头部删除元素则使用 list.remove 方法。

1. public interface Queue
2.    
3.       {  
   
4.      /**
   
5.       * 入队: 从队尾加入一元素
   
6.       *  
   
7.       * @param target
   
8.       */  
   
9.      public void add(E target);  
   
10.    
    
11.      /**
    
12.       * 出队: 移走队头元素
    
13.       *  
    
14.       * @param target
    
15.       * @return 当前队头元素
    
16.       */  
    
17.      public E remove();  
    
18.    
    
19.      /**
    
20.       * 当前队列中的元素个数
    
21.       */  
    
22.      public int size();  
    
23.    
    
24.      /**
    
25.       * 判断当前队列是否为空
    
26.       *  
    
27.       * @return
    
28.       */  
    
29.    
    
30.      public boolean isEmpty();  
    
31.      /**
    
32.       * 只是返回队头元素
    
33.       * @return
    
34.       */  
    
35.      public E front();  
    
36. }  
    
37. 
    
38.   /**
    
39.   *基于数组的队列
    
40.   * @param
41.      
42.       
    
43.   */  
    
44. public class ArrayQueue
45.       
46.         implements Queue
47.       
48.          {  
    
49.      private E[] data;  
    
50.       
    
51.      private int size ;//队列中对象数量  
    
52.       
    
53.      private int front ;// 队列中第一个对象位置  
    
54.       
    
55.      private int rear ;//队列中当前对象位置  
    
56.       
    
57.      public ArrayQueue() {  
    
58.          data = (E[]) new Object[10];  
    
59.          size = 0;  
    
60.          front = 0;  
    
61.          rear = 0;  
    
62.      }  
    
63.    
    
64.      public void add(E target) {  
    
65.          if( isFull() ){  
    
66.              enlarge();  
    
67.              front = 0;  
    
68.          }  
    
69.          rear = (front + size) % data.length;  
    
70.          data[rear] = target;  
    
71.          size++;  
    
72.      }  
    
73.    
    
74.      public E front() {  
    
75.          if (isEmpty()) {  
    
76.              throw new RuntimeException("队列为空!");  
    
77.          }  
    
78.          return data[front];  
    
79.    
    
80.      }  
    
81.    
    
82.      public boolean isEmpty() {  
    
83.          return size == 0;  
    
84.      }  
    
85.    
    
86.      public E remove() {  
    
87.          if (isEmpty()) {  
    
88.              throw new RuntimeException("队列为空!");  
    
89.          }  
    
90.          E tempData = data[front];  
    
91.          data[front] = null;  
    
92.          front = (front + 1) % (data.length);  
    
93.          size--;  
    
94.            
    
95.          return tempData;  
    
96.      }  
    
97.       
    
98.      public int size() {  
    
99.          return size;  
    
100.      }  
     
101.      /**
     
102.       * 判断当前队列是否已满
     
103.       *  
     
104.       * @return
     
105.       */  
     
106.      public boolean isFull() {  
     
107.          return size == data.length;  
     
108.      }  
     
109.      /**
     
110.       * 将数组容量扩大两倍
     
111.       *  
     
112.       */  
     
113.      public void enlarge() {  
     
114.          E[] newData = (E[]) new Object[data.length * 2];  
     
115.          System.arraycopy(data, 0, newData, 0, data.length);  
     
116.          data = newData;  
     
117.          newData = null;  
     
118.      }  
     
119.    
     
120. }  
     
121. 测试代码：
122.         
123. 
     
124.     public void testArrayQueue(){  
     
125.             ArrayQueue
126.         
127.           q = new ArrayQueue
128.          
129.           ();  
     
130.             q.add("a");  
     
131.             q.add("b");  
     
132.             q.add("c");  
     
133.             q.add("d");  
     
134.             q.add("e");  
     
135.             q.add("f");  
     
136.             q.add("g");  
     
137.            q.add("h");  
     
138.            q.add("i");  
     
139.            q.add("j");      
     
140.            q.add("k");  
     
141.            q.add("l");  
     
142.            q.add("m");  
     
143.            while( !q.isEmpty() ){  
     
144.                String temp = q.remove();  
     
145.                System.out.println(temp);  
     
146.            }  
     
147.        }  
148.          
149.         
150.       
151.       
152.      
153.    

复制代码

   
     
     
      
      

        
      

        
      
     
   

  


源码下载：http://file.javaxxz.com/2014/12/2/000631578.zip