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