Collection,ArrayList,LinkedList,HashSet,LinkedHashSet,HashMap如何遍历元素

package com.web;

import java.util.*;

public class Test35 {
    
    
    public static void main(String[] args) {
    
    
        Collection<String> collection = new ArrayList<>();
        collection.add("collection 1");
        collection.add("collection 2");
        collection.add("collection 3");
        collection.add("collection 4");
         // Object[] toArray()转换成一个Object数组
        Object[] objects = collection.toArray();
        for (int i = 0; i < objects.length; i++) {
    
    
            if (i==objects.length-1) {
    
    
                System.out.print(objects[i]);
            } else {
    
    
                System.out.print(objects[i] + " ,");
            }
        }
        Iterator<String> iterator1 = collection.iterator();
        //在使用next()函数获取集合中元素前，使用hasNext()判断集合中是否还有元素。**
        //循环条件是迭代器对象.hasNext()为false时表示集合中没有元素可以获取了，循环条件迭代器对象.hasNext() 为true的时候说明还可以获取元素。
        //public E next():返回迭代的下一个元素。
        //next()函数表示取出当前遍?到的那个元素。
        while (iterator1.hasNext()) {
    
    
            System.out.print(iterator1.next() + " ,");
        }
        System.out.println("");
        System.out.println("+++++++++++++++++++++++++++++++++++++++");
        //使用for循环遍历集合 推荐开发使用
        for (Iterator iterator2 = collection.iterator(); iterator2.hasNext(); ) {
    
    
            System.out.print(iterator2.next() + " ,");
        }
        System.out.println("");
        System.out.println("=====================================================");
        //ArrayList,LinkedList,Vector都是List的实现类
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(3);
        System.out.println("arrayList = " + arrayList);
        for (int i = 0; i < arrayList.size(); i++) {
    
    
            if (i==arrayList.size()-1) {
    
    
                System.out.print(arrayList.get(i));
            } else {
    
    
                System.out.print(arrayList.get(i) + " ,");
            }
        }
        System.out.println("");
        System.out.println("=====================================================");

        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("linkedList 1");
        linkedList.add("linkedList 2");
        linkedList.add("linkedList 3");
        linkedList.add("linkedList 4");
        System.out.println("linkedList = " + linkedList);
        for (String s : linkedList) {
    
    
            System.out.print(s + " ,");
        }
        System.out.println("");
        System.out.println("=====================================================");
        Vector<String> vector = new Vector<>();
        vector.add("vector 1");
        vector.add("vector 2");
        vector.add("vector 3");
        vector.add("vector 4");
        for (String s : vector) {
    
    
            System.out.print(s + ",");
        }
        System.out.println("");
        System.out.println("=====================================================");
        //Set集合（接口）：不能保存重?元素，没有下?。可以存?null但只能有一个。并且不保?存取的?序，也就是??于集合set?行存取操作的?候都没有任何?序，没有任何?律而言。
        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("hashSet 1");
        hashSet.add("hashSet 2");
        hashSet.add("hashSet 3");
        hashSet.add("hashSet 3");
        for (Iterator it = hashSet.iterator(); it.hasNext(); ) {
    
    
            System.out.print(it.next() + " ,");//hashSet 1 hashSet 2 hashSet 3
        }
        System.out.println("");
        System.out.println("=====================================================");
        //LinkedHashSet集合：它的底?使用的?表+哈希表??。它和HashSet集合的区?是LinkedHashSet是一个可以保?存取?序的集合，并且LinkedHashSet集合中的元素也不能重?。
        //A：存取有序（底层有一个链接表）链表记录着存储数据的顺序
        //B：保证元素的唯一（哈希表）哈希表是真正存储数据的地方
        //C：线程不安全，效率高
        //D：LinkedHashSet集合没有自己的特有函数，所有的功能全部继承父类。
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("linkedHashSet 1");
        linkedHashSet.add("linkedHashSet 2");
        linkedHashSet.add("linkedHashSet 3");
        linkedHashSet.add("linkedHashSet 4");
        for (Iterator iterator = linkedHashSet.iterator(); iterator.hasNext(); ) {
    
    
            System.out.print(iterator.next() + " ,");
        }
        System.out.println("");
        System.out.println("=====================================================");
        //Map和Collection的区别
        //1）Map中键唯一，值没有要求。Collection中只有Set体系要求元素唯一；
        //2）Map的数据结构针对键而言，Collection的数据结构针对元素而言；
        //3）Map是双列集合顶级接口，Collection是单列集合顶级接口，他们两个分别是两种集合的顶级接口，之间没有必然的联系；

        //但是Map集合不能直接使用Iterator迭代器来遍历，因为在Map集合根本就没有提供获得迭代器对象的函数。
        //
        //既然不能通过Iterator迭代器直接来遍历，那是否可以间接使用Iterator迭代器来遍历Map集合呢？
        //
        //之前讲Map集合时，Map集合是用来存储一对key-value两个对象，既然存储的是两个对象，那么能不能只获取其中一个所有的对象？
        //
        //可以。Map集合属于双列集合，里面有两个单列集合。由于Map集合中的key是唯一的，所以我们我可以先获取Map集合中的key，然后根据key值来获取Map集合中的value值。
        //
        //问题1：Map中的key对象，应该使用哪个集合存储？
        //
        //key必须保证唯一性(不能重复)，使用Set集合存储。
        //
        //问题2：如何将Map中的key存储到Set集合呢？
        //
        //可以使用Map中的keySet方法：获取Map集合中所有的key对象并存储到Set集合中。
        //
        //**public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。**
        //
        //这样通过上述操作就可以将Map集合中的key存放到Collection集合下面的set中，然后使用Iterator遍历Map集合中的key所在的Set集合，进而可以使用 Map集合中的 public V get(Object key) 通过key间接的获取每个value。
        //
        //注意：Map接口中提供了2个方法可以获取到Map中的key 或者key和value关系对象
        //
        //keySet()：Map中的key存储到Set集合中。
        //
        //entrySet()：Map中的key和value关系对象存储到Set集合中。
        //
        //注：由于Map中key是唯一的，不能重复的，所以Map集合中键值对整体也是不能重复的，但是单独value值是可以重复的。
        TreeMap<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("treeMap 1", 1);
        treeMap.put("treeMap 2", 2);
        treeMap.put("treeMap 3", 3);
        treeMap.put("treeMap 4", 4);
        /*
         * 通过Map的对象调用keySet函数获得Map中的key值并保存到Set集合
         * 所有的key键都保存到以下的set集合中了
         */
        Set<String> keySet = treeMap.keySet();
        使用迭代器迭代Set集
        for (Iterator<String> iterator = keySet.iterator(); iterator.hasNext(); ) {
    
    
            String key = iterator.next();
            Integer value = treeMap.get(key);
            System.out.println(key + "======" + value);
        }
        System.out.println("=====================================================");
        //使用entrySet遍历(会使用即可，开发使用的较少)
        //在Map集合中提供的entrySet方法，它可以获取到当前Map集合中的key和value的对应关系对象（映射对象）。
        //在Map集合中把key和value看成一组数据，然后Java中把这一组数据又一次封装成了一个新的对象，这个对象就是key和value的对应关系对象。然后把这些对象保存到了Set集合中。Set集合中保存的是key和value对应关系对象。
        //说明：
        //Set集合中保存的是key和value对应关系对象属于Map.Entry类型。
        //`public static interface Map.Entry`
        //而在内部接口Entry中有如下方法：
        //1）getKey()方法表示可以通过Map.Entry类型的对象调用此函数来获得在Set集合中保存的是key和value对应关系对象中的key值；
        //2）getValue()方法表示可以通过Map.Entry类型的对象调用此函数来获得在Set集合中保存的是key和value对应关系对象中的value值；
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("hashMap 1", 5);
        hashMap.put("hashMap 2", 5);
        hashMap.put("hashMap 3", 5);
        hashMap.put("hashMap 4", 5);

        /*
         * 使用entrySet()函数获得键值对对应关系的对象
         * KeyValues表示键值的对应关系的对象
         */

        Set<Map.Entry<String, Integer>> entrySet = hashMap.entrySet();
        //迭代Set集合
        /*
         * Iterator<Map.Entry<String, String>> 表示每次迭代出来的是Map.Entry类型，
         * 并且对应关系对象中的key和value都是String类型
         */
		/*for (Iterator<Map.Entry<String, String>> it = keyValues.iterator(); it.hasNext();) {
			Map.Entry<String, String> keyValue =  it.next();
			//keyValue表示每个独立的key-value对应关系的对象，现在分别取出对应关系中的key和value
			String key = keyValue.getKey();
			String value = keyValue.getValue();
			//输出key和value
			System.out.println(key+"---"+value);
		}*/
        //使用foreach循环遍历Set集合
        for (Map.Entry<String, Integer> keyValue : entrySet) {
    
    
            String key = keyValue.getKey();
            Integer value = keyValue.getValue();
            System.out.println(key + "........" + value);

        }
    }
}
//collection 1 ,collection 2 ,collection 3 ,collection 4 ,
//+++++++++++++++++++++++++++++++++++++++
//collection 1 ,collection 2 ,collection 3 ,collection 4 ,
//=====================================================
//arrayList = [1, 2, 3, 3]
//1 ,2 ,3 ,3 
//=====================================================
//linkedList = [linkedList 1, linkedList 2, linkedList 3, linkedList 4]
//linkedList 1 ,linkedList 2 ,linkedList 3 ,linkedList 4 ,
//=====================================================
//vector 1,vector 2,vector 3,vector 4,
//=====================================================
//hashSet 1 ,hashSet 2 ,hashSet 3 ,
//=====================================================
//linkedHashSet 1 ,linkedHashSet 2 ,linkedHashSet 3 ,linkedHashSet 4 ,
//=====================================================
//treeMap 1======1
//treeMap 2======2
//treeMap 3======3
//treeMap 4======4
//=====================================================
//hashMap 1........5
//hashMap 4........5
//hashMap 2........5
//hashMap 3........5
//
//Process finished with exit code 0