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 与迭代的方式;

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

猜你喜欢