Map集合，List集合,Array数组,Iterator迭代,Collection集合,Set集合的多种遍历方式

不废话，直接上方法:

Map集合遍历的方式6种,以下只提供核心思路，具体请结合项目一起使用:

第一种: 最基础的遍历方式,先获取key,然后通过key获取value,这种方法最基础，最实用;

for(String key:maps.keySet()){       String value = maps.get(key);      System.out.println(key + ":" + value);}

第二种方法: 遍历获取所有的value值，此种方法具有局限性，只能获取value，不能获取key,请结合实际使用;

for(String value:maps.values()){      System.out.println(value);}

第三种方式: 通过Entry集合访问，将map集合转换为Entry集合,从Entry里面获取getKey(), getValue()，这个方式也比较实用;

for(Entry entry:maps.entrySet()){      System.out.println(entry.getKey()+":"+entry.getValue());}

第四种方式: 将key集合进行迭代，这种方式是在第一种方式的基础上做了一个拓展，迭代的遍历稍后给大家讲解;

Iterator<String> iterator = maps.keySet().iterator();     while(iterator.hasNext()){      String key = iterator.next();       String value = maps.get(key);     System.out.println(key + ":" + value);}

第五种方式: 将value集合进行迭代，这种方式在第二种的方式上做了一个拓展，稍后会讲解关于Collection的遍历

Iterator<String> iter= maps.values().iterator();        while(iter.hasNext()){           String value = iter.next();           System.out.println(value); }

第六种方式: 讲Entry集合进行迭代，这种方式是在第三种方式的基础上进行拓展,从Entry里面获取getKey(), getValue()，也是比较实用;

Iterator<Entry<String, String>> it = maps.entrySet().iterator();       while(it.hasNext()){       Entry<String, String> entry = it.next();       System.out.println(entry.getKey()+":"+entry.getValue()); } 

List集合遍历的4种方式:增强for,iterator，一般for,迭代与for结合；

让我们从简单到难的顺序:

第一种方式: 一般for,最基础的,(题外话，也是我犯错比较多的一个for循环),细节点就是  size() 与 < =的问题;

for(int i = 0;i < list.size(); i ++){      System.out.println(list.get(i)); }

其中 i <=  list.size() -1;

第二种方式: 增强for又或者是超级for,这个方式非常方便，我在项目中也是使用的比较多;

for(String value:list){    System.out.println(value);}

第三种方式: iterator 迭代， list集合都可以转换为Iterator;

Iterator it1 = list.iterator();      while(it1.hasNext()){         System.out.println(it1.next());}

第四种方式：iterator与for结合使用，用的比较少，个人觉得比较复杂，但是足以使用;

for(Iterator it2 = list.iterator();it2.hasNext();){      System.out.println(it2.next());}

java 中数组遍历方式5种

第一种方式: 一般for

for(int i = 0; i < arr.length; i++){    System.out.println(i);}

第二种方式:增强for或者超级for

for(String arr : array){    System.out.println(arr);}

第三种方式: 转换为list集合， 而list集合有4种遍历方式，所以java数组的遍历方式有7种;

List list = Arrays.asList(array)

第四种方式: stream遍历,并且结合lambda表达式结合使用;

Arrays.asList(array).stream().forEach(x -> System.out.println(x));

第五种方式: 同第四种方式一样，只是表达的形式不一样而已；

Arrays.asList(array).stream().forEach(System.out::println);

Iterator遍历方式有2种:

第一种方式: 正常迭代;

Iterator<Integer> iterator = lstint.iterator();   while (iterator.hasNext()){     int i = (Integer) iterator.next();     System.out.println(i);  }

第二种方式: 结合for循环使用， 也可以参考list集合的第四种方式;

for (Iterator<Integer> it = lstint.iterator(); it.hasNext();){    int i = (Integer) it.next();    System.out.println(i);  }

Collection集合遍历，Collection集合包含list与set集合，所以Collection集合的遍历方式有6中，其中四种，可以参考list集合的遍历方式，下面再介绍两种，针对于Collection与LinkedList的遍历方式;

第一种方式:针对于Collections的方法的使用，非常的方便;

ArrayList<String> list4=new ArrayList<>(list);Enumeration<String> e = Collections.enumeration(list4);while(e.hasMoreElements()){System.out.print(e.nextElement()+" ");}

第二种方式: 针对于linkedList,既有栈（stack）的特点，又有队列（Queue）的特点。所以遍历LinkedList中的元素。根据stack和queue，可以进行相关的遍历。

LinkedList<String> list2=new LinkedList<>(list);while(!list2.isEmpty()){      System.out.print(list2.removeFirst()+" ");}LinkedList<String> list3=new LinkedList<>(list); while(list3.peek() != null){ System.out.print(list3.poll()+" ");}

Set集合的遍历方式 遍历方式有3种

  

1.Itertor迭代遍历：  

Set<String> set = new HashSet<String>();  Iterator<String> it = set.iterator();  while (it.hasNext()) {    String str = it.next();    System.out.println(str);  }  

2.增强for或者超级for遍历：  

for (String str : set) {        System.out.println(str);  }  

小彩蛋， 当set集合里面的泛型是object，做如何处理;Set<Object> set = new HashSet<Object>();  for循环遍历：  for (Object obj: set) {        if(obj instanceof Integer){                  int aa= (Integer)obj;               }else if(obj instanceof String){                 String aa = (String)obj               }                ........  }

最后一个大彩蛋，我们习惯了使用java给我们提供的方法，那如果我们自己封装，会不会很难，下面请看封装的代码:

第一种，对增强for或者超级for循环进行封装

//公共方法public static void forEachCollection(Collection<String> colleciton){          for(String str:colleciton){////按照被添加的顺序保存对象              System.out.print(str+" ");          }          System.out.println();      } //测试方法 public static void listCollection() {          String[] array = {"A","A","B","E","F","G","C","D"};          forEachCollection(new ArrayList<String>(Arrays.asList(array)));//A A B E F G C D           forEachCollection(new LinkedList<String>(Arrays.asList(array)));//按照被添加的顺序保存对象 //A A B E F G C D           forEachCollection(new HashSet<String>(Arrays.asList(array)));//无重复，无序,存储顺序并无实际意义//D E F G A B C           forEachCollection(new TreeSet<String>(Arrays.asList(array)));//无重复，按照比较结果的升序保存对象//A B C D E F G           forEachCollection(new LinkedHashSet<String>(Arrays.asList(array)));//无重复，按照被添加的顺序保存对象//A B E F G C D       }     

细节点： 创建一个数组，然后将数组转换为list(Arrays.asList(array)))，最后将list存放到new ArrayLsit<>(Arrays.asList(array));

第二种，对迭代进行简单封装

//公共方法public class ForeachDemo {            public static void printCollection(Collection<String> colleciton){          Iterator<String> it = colleciton.iterator();          while(it.hasNext()){              System.out.print(it.next()+" ");          }          System.out.println();      }   //测试方法    public static void main(String[] args) {          String[] array = {"A","A","B","E","F","G","C","D"};          printCollection(new ArrayList<String>(Arrays.asList(array)));//A A B E F G C D           printCollection(new LinkedList<String>(Arrays.asList(array)));//按照被添加的顺序保存对象 //A A B E F G C D           printCollection(new HashSet<String>(Arrays.asList(array)));//无重复，无序,存储顺序并无实际意义//D E F G A B C           printCollection(new TreeSet<String>(Arrays.asList(array)));//无重复，按照比较结果的升序保存对象//A B C D E F G           printCollection(new LinkedHashSet<String>(Arrays.asList(array)));//无重复，按照被添加的顺序保存对象//A B E F G C D       }  

细节点: for  与 迭代的方式;