Java集合的Stack、Queue、Map的遍历

Java集合的Stack、Queue、Map的遍历

 

在集合操作中，常常离不开对集合的遍历，对集合遍历一般来说一个foreach就搞定了，但是，对于Stack、Queue、Map类型的遍历，还是有一些讲究的。

下面是常用的写法：

 

一、Map的遍历

Java代码  

1. import java.util.HashMap;  
2. import java.util.Iterator;  
3. import java.util.Map;  
4.   
5. /** 
6. * Map的遍历，这个遍历比较特殊，有技巧 
7. * 
8. * @author leizhimin 2009-7-22 15:15:34 
9. */  
10. public class TestMap {  
11.         public static void main(String[] args) {  
12.                 Map<String, String> map = new HashMap<String, String>();  
13.                 map.put("1", "a");  
14.                 map.put("2", "b");  
15.                 map.put("3", "c");  
16.   
17.                 //最简洁、最通用的遍历方式  
18.                 for (Map.Entry<String, String> entry : map.entrySet()) {  
19.                         System.out.println(entry.getKey() + " = " + entry.getValue());  
20.                 }  
21.                 //Java5之前的比较简洁的便利方式1  
22.                 System.out.println("----1----");  
23.                 for (Iterator<Map.Entry<String, String>> it = map.entrySet().iterator(); it.hasNext();) {  
24.                         Map.Entry<String, String> entry = it.next();  
25.                         System.out.println(entry.getKey() + " = " + entry.getValue());  
26.                 }  
27.                 //Java5之前的比较简洁的便利方式2  
28.                 System.out.println("----2----");  
29.                 for (Iterator<String> it = map.keySet().iterator(); it.hasNext();) {  
30.                         String key = it.next();  
31.                         System.out.println(key + " = " + map.get(key));  
32.                 }  
33.         }  
34. }  

 3 = c 
2 = b 
1 = a 
----1---- 
3 = c 
2 = b 
1 = a 
----2---- 
3 = c 
2 = b 
1 = a 

Process finished with exit code 0

二、Queue的遍历

Java代码  

1. import java.util.Queue;  
2. import java.util.concurrent.LinkedBlockingQueue;  
3.   
4. /** 
5. * 队列的遍历 
6. * 
7. * @author leizhimin 2009-7-22 15:05:14 
8. */  
9. public class TestQueue {  
10.         public static void main(String[] args) {  
11.                 Queue<Integer> q = new LinkedBlockingQueue<Integer>();  
12.                 //初始化队列  
13.                 for (int i = 0; i < 5; i++) {  
14.                         q.offer(i);  
15.                 }  
16.                 System.out.println("-------1-----");  
17.                 //集合方式遍历，元素不会被移除  
18.                 for (Integer x : q) {  
19.                         System.out.println(x);  
20.                 }  
21.                 System.out.println("-------2-----");  
22.                 //队列方式遍历，元素逐个被移除  
23.                 while (q.peek() != null) {  
24.                         System.out.println(q.poll());  
25.                 }  
26.         }  
27. }  

 

三、Stack的遍历

Java代码  

1. import java.util.Stack;  
2.   
3. /** 
4. * 栈的遍历 
5. * 
6. * @author leizhimin 2009-7-22 14:55:20 
7. */  
8. public class TestStack {  
9.         public static void main(String[] args) {  
10.                 Stack<Integer> s = new Stack<Integer>();  
11.                 for (int i = 0; i < 10; i++) {  
12.                         s.push(i);  
13.                 }  
14.                 //集合遍历方式  
15.                 for (Integer x : s) {  
16.                         System.out.println(x);  
17.                 }  
18.                 System.out.println("------1-----");  
19.                 //栈弹出遍历方式  
20. //                while (s.peek()!=null) {     //不健壮的判断方式，容易抛异常，正确写法是下面的  
21.                 while (!s.empty()) {  
22.                         System.out.println(s.pop());  
23.                 }  
24.                 System.out.println("------2-----");  
25.                 //错误的遍历方式  
26. //                for (Integer x : s) {  
27. //                        System.out.println(s.pop());  
28. //                }  
29.         }  
30. }  

  在遍历集合时候，优先考虑使用foreach语句来做，这样代码更简洁些。

并且推荐使用foreach