背景：

不同的集合实现迭代器的方式是不相同的；常见的集合的迭代器有：1.列表的迭代器使用；2数组的迭代器的使用；3.hashset的迭代器的使用。4.hashMap迭代器的使用（重点，易错）

1.1数组的迭代器的使用

package com.ydlclass.collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class ArrayListTest {
    public static void del(){

    }
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("a");
        arrayList.add("b");

        //ArrayList<String> arrayList1 = new ArrayList<>();
        //arrayList1.add("1");
        //arrayList1.add("2");
        //arrayList.addAll(1,arrayList1);
        Iterator<String> iterator = arrayList.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }

        //常见的遍历操作
        //for (int i = 0; i < arrayList.size(); i++) {
        //    System.out.print(arrayList.get(i) + " ");
        //}
        //List<String> list = new LinkedList<>();
        /**
         * 父类引用指向子类对象，存在静态类型和动态类型的区别；
         * 静态分派和动态分派的过程，成为了多态，多态的好处是能够解耦合
         * 多态的好处就是比如在编写一个函数的时候，传入的参数我们使用接口的方式传入；虽然接口不能直接调用方法
         * 但是编写的时候依旧调用了原因在于，是根据传入的参数类型确定调用什么方法的
         */

        //list的相关操作
        /**
         * list.remove();
         * list.removeAll();
         * list.removeif();
         * 列表常见的增，删，改，查；
         */



    }
}

1.2hashSet迭代器的使用；

package com.ydlclass.collection;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Set;

public class SetTest {
    public static void main(String[] args) {
        HashSet<String> hashSet = new HashSet<>();

        hashSet.add("a");
        hashSet.add("b");
        hashSet.add("c");
        hashSet.add("d");
        hashSet.add("e");
        hashSet.add("e");
        hashSet.add("1");
        hashSet.add("2");
        hashSet.add("3");
        Iterator<String> iterator = hashSet.iterator();

        //第一步先判断有误下一个

        while (iterator.hasNext()){
            String next = iterator.next();//拿到下一个元素；由于不同的集合类有不同的实现方式；
            System.out.println(next);
        }



    }
}

1.3hashMap迭代器的使用（两种方式使用其迭代器，其中第二种的迭代器的使用需要注意避免错误使用）


import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class HashMapTest {
    public static void main(String[] args) {
        HashMap<String,Integer> hashMap = new HashMap<>(16);
        hashMap.put("a",1);
        hashMap.put("b",2);
        //HashMap中迭代器的几种使用方法：
        //1.通过先获取hashMapkeySet（）方法的到键的集合；
        Set<String> keySet = hashMap.keySet();
        Iterator<String> iterator1 = keySet.iterator();//keySet集合先获得迭代器；
        while (iterator1.hasNext()){
            String key = iterator1.next();
            System.out.println("key = " + key);
            System.out.println("value= " + hashMap.get(key));//使用get方法并且使用了key的获取对应的值；
        }
        //2.方式二：
        Set<Map.Entry<String, Integer>> entries = hashMap.entrySet();//键值对集合，entry其实类似于node节点，他是一个接口；此处是一个函数，这个函数的主要工作是：把每一对key—value
        //打包成一个实例对象entry集合；这个集合中每个对象是一个entry对象，每个对象封装了key-value;
        Iterator<Map.Entry<String, Integer>> iterator2 = entries.iterator();
        //错误的做法
        //while(iterator2.hasNext()){
        //    System.out.println("iterator2.next().getKey() = " + iterator2.next().getKey());
        //    System.out.println("iterator2.next().getValue() = " + iterator2.next().getValue());
        //}
        //上面的方式产生问题的原因在于：两句话中分别调用了next方法，导致了不是同一个对象；
        //正确的方法：
        while (iterator2.hasNext()){
            Map.Entry<String, Integer> next = iterator2.next();
            System.out.println("next.getKey() = " + next.getKey());
            System.out.println("next.getValue() = " + next.getValue());
        }

    }
}

前面的两次方法中第二种方法的效率比较高；前者主要是先遍历hashMap得到一个keyset，然后在通过key遍历hashMap找到对应的val；（keyset->key实例->hashMap使用key实例获取val） 后者是先遍历一次hashMap得到一个键值对的entryset然后直接从entry对象中取值val即可；（entrySet->entry实例对象->entry对象调用特定的方法获取key或者val）