java关于集合的遍历与增强for循环的使用<Reprinted>

浏览数：29 / 时间：2015年06月08日
  java集合类的使用可以说是无处不在，总的我们可以将之分为三大块，分别是从Collection接口延伸出的List、Set和以键值对形式作存储的Map类型集合。
     许多情况需要我们遍历出集合中的元素，并做相应的处理。
     下面对各种类型的集合的遍历做一些总结，关于增强for循环,需要注意的是，使用增强for循环无法访问数组下标值，对于集合的遍历其内部采用的也是Iterator的相关方法。如果只做简单遍历读取，增强for循环确实减轻不少的代码量。
关于List与Set类型集合的遍历：
[java] view plaincopy
 
  1. import java.util.ArrayList;  
  2. import java.util.HashSet;  
  3. import java.util.Iterator;  
  4. import java.util.List;  
  5. import java.util.Set;  
  6.   
  7. public class ListAndSetTest {  
  8.   
  9.     public static void main(String[] args) {  
  10.         // List集合的遍历  
  11.         listTest();  
  12.         // Set集合的遍历  
  13.         setTest();  
  14.     }  
  15.   
  16.     private static void setTest() {  
  17.         Set<String> set = new HashSet<String>();  
  18.         set.add("JAVA");  
  19.         set.add("C");  
  20.         set.add("C++");  
  21.         // 重复的加不进去。  
  22.         set.add("JAVA");  
  23.         set.add("JAVASCRIPT");  
  24.   
  25.         //set集合遍历方法1，使用iterator  
  26.         Iterator<String> it = set.iterator();  
  27.         while (it.hasNext()) {  
  28.             String value = it.next();  
  29.             System.out.println(value);  
  30.         }  
  31.           
  32.         //set集合遍历方法2，使用增强for循环。  
  33.         for(String s: set){  
  34.             System.out.println(s);  
  35.         }  
  36.     }  
  37.   
  38.     // 遍历list集合  
  39.     private static void listTest() {  
  40.         List<String> list = new ArrayList<String>();  
  41.         list.add("java111");  
  42.         list.add("java222");  
  43.         list.add("java333");  
  44.         list.add("java444");  
  45.         list.add("java555");  
  46.   
  47.         // 遍历方式1 ，使用iterator  
  48.         Iterator<String> it = list.iterator();  
  49.         while (it.hasNext()) {  
  50.             String value = it.next();  
  51.             System.out.println(value);  
  52.         }  
  53.   
  54.         // 遍历方法2 ， 使用传统for循环进行遍历。  
  55.         for (int i = 0, size = list.size(); i < size; i++) {  
  56.             String value = list.get(i);  
  57.             System.out.println(value);  
  58.         }  
  59.   
  60.         // 遍历方法3 ， 使用增强for循环进行遍历。  
  61.         for (String value : list) {  
  62.             System.out.println(value);  
  63.         }  
  64.     }  
  65. }  

关于Map类型集合的遍历，keySet()与entrySet()方法：
[java] view plaincopy
 
  1. //增强For循环  
  2. public class MapTest {  
  3.   
  4.     public static void main(String[] args) {  
  5.         // 创建一个HashMap对象,并加入了一些键值对。  
  6.         Map<String, String> maps = new HashMap<String, String>();  
  7.         maps.put("111", "java111");  
  8.         maps.put("222", "java222");  
  9.         maps.put("333", "java333");  
  10.         maps.put("444", "java444");  
  11.         maps.put("555", "java555");  
  12.           
  13.         // 传统的遍历map集合的方法1; keySet()  
  14.         //traditionalMethod1(maps);  
  15.         // 传统的遍历map集合的方法2; entrySet()  
  16.         //traditionalMethod2(maps);  
  17.         // 使用增强For循环来遍历map集合方法1; keySet()  
  18.         //strongForMethod1(maps);  
  19.         // 使用增强For循环来遍历map集合方法2; entrySet()  
  20.         strongForMethod2(maps);  
  21.     }  
  22.   
  23.     private static void strongForMethod2(Map<String, String> maps) {  
  24.         Set<Entry<String, String>> set = maps.entrySet();  
  25.         for (Entry<String, String> entry : set) {  
  26.             String key = entry.getKey();  
  27.             String value = entry.getValue();  
  28.             System.out.println(key + " : " + value);  
  29.         }  
  30.     }  
  31.   
  32.     private static void strongForMethod1(Map<String, String> maps) {  
  33.         Set<String> set = maps.keySet();  
  34.         for (String s : set) {  
  35.             String key = s;  
  36.             String value = maps.get(s);  
  37.             System.out.println(key + " : " + value);  
  38.         }  
  39.     }  
  40.   
  41.     // 使用entrySet()方法，获取maps集合中的每一个键值对，  
  42.     private static void traditionalMethod2(Map<String, String> maps) {  
  43.         Set<Map.Entry<String, String>> sets = maps.entrySet();  
  44.         // 取得迭代器遍历出对应的值。  
  45.         Iterator<Entry<String, String>> it = sets.iterator();  
  46.         while (it.hasNext()) {  
  47.             Map.Entry<String, String> entry = (Entry<String, String>) it.next();  
  48.             String key = entry.getKey();  
  49.             String value = entry.getValue();  
  50.             System.out.println(key + " : " + value);  
  51.         }  
  52.     }  
  53.   
  54.     // 使用keySet()方法，获取maps集合中的所有键，遍历键取得所对应的值。  
  55.     private static void traditionalMethod1(Map<String, String> maps) {  
  56.         Set<String> sets = maps.keySet();  
  57.         // 取得迭代器遍历出对应的值。  
  58.         Iterator<String> it = sets.iterator();  
  59.         while (it.hasNext()) {  
  60.             String key = it.next();  
  61.             String value = maps.get(key);  
  62.             System.out.println(key + " : " + value);  
  63.         }  
  64.     }  
  65. } 

java关于集合的遍历与增强for循环的使用<Reprinted>,古老的榕树,5-wow.com

郑重声明：本站内容如果来自互联网及其他传播媒体，其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享，并不代表本站赞同其观点和对其真实性负责，也不构成任何其他建议。

标签： 编程语言 Java C C# Javascript js Python Ruby Spring 程序 VB

相关文章

随机文章

您可能还喜欢

您可能还喜欢