Map接口

Map集合概述

*A:Map集合概述:
    我們通過查看Map接口描述,發現Map接口下的集合與Collection接口下的集合，它們存儲數據的形式不同
    a:Collection中的集合，元素是孤立存在的（理解為單身），向集合中存儲元素采用一個個元素的方式存儲。
    b:Map中的集合，元素是成對存在的(理解為夫妻)。每個元素由鍵與值兩部分組成，通過鍵可以找對所對應的值。
    Collection中的集合稱為單列集合，Map中的集合稱為雙列集合。
    需要註意的是，Map中的集合不能包含重復的鍵，值可以重復；每個鍵只能對應一個值。
    Map
     |--HashMap
     |--LinkedHashMap
 

Map接口中的常用方法 ?

*A:Map接口中的常用方法
    /*
     *  Map接口中的常用方法
     *    使用Map接口的實現類 HashMap
     */
    public class MapDemo {
        public static void main(String[] args) {
            function_2();
        }

        /*
         *  移除集合中的鍵值對,返回被移除之前的值
         *  V remove(K)
         */
        public static void function_2() {
            Map<Integer, String> map = new HashMap<Integer, String>();
            map.put(1, "a");
            map.put(2, "b");
            map.put(3, "c");
            System.out.println(map);
            String value = map.remove(33);
            System.out.println(value);
            System.out.println(map);
        }

        /*
         * 通過鍵對象,獲取值對象
         * V get(K)
         * 如果集合中沒有這個鍵,返回null
         */
        public static void function_1() {
            //創建集合對象,作為鍵的對象整數,值的對象存儲字符串
            Map<Integer, String> map = new HashMap<Integer, String>();
            map.put(1, "a");
            map.put(2, "b");
            map.put(3, "c");
            System.out.println(map);

            String value = map.get(4);
            System.out.println(value);
        }

        /*
         *  將鍵值對存儲到集合中
         *  V put(K,V) K 作為鍵的對象, V作為值的對象
         *  存儲的是重復的鍵,將原有的值,覆蓋
         *  返回值一般情況下返回null,
         *  存儲重復鍵的時候,返回被覆蓋之前的值
         */
        public static void function() {
            //創建集合對象,HashMap,存儲對象,鍵是字符串,值是整數
            Map<String, Integer> map = new HashMap<String, Integer>();
            map.put("a", 1);

            map.put("b", 2);

            map.put("c", 3);

            System.out.println(map);
        }
    }
 

Map集合遍歷方式keySet方法

*A:Map集合遍歷方式keySet方法
    1.獲取Map集合中所有的鍵，由於鍵是唯一的，所以返回一個Set集合存儲所有的鍵
    2.遍歷鍵的Set集合，得到每一個鍵
    3.根據鍵利用get(key)去Map找所對應的值

    /*
     *  Map集合的遍歷
     *    利用鍵獲取值
     *    Map接口中定義方法keySet
     *    所有的鍵,存儲到Set集合
     */
    public class MapDemo1 {
        public static void main(String[] args) {
                 /*
                 *  1. 調用map集合的方法keySet,所有的鍵存儲到Set集合中
                 *  2. 遍歷Set集合,獲取出Set集合中的所有元素 (Map中的鍵)
                 *  3. 調用map集合方法get,通過鍵獲取到值
                 */
            Map<String, Integer> map = new HashMap<String, Integer>();
            map.put("a", 11);
            map.put("b", 12);
            map.put("c", 13);
            map.put("d", 14);
            //1. 調用map集合的方法keySet,所有的鍵存儲到Set集合中
            Set<String> set = map.keySet();
            //2. 遍歷Set集合,獲取出Set集合中的所有元素 (Map中的鍵)
            Iterator<String> it = set.iterator();
            while (it.hasNext()) {
                //it.next返回是Set集合元素,也就是Map中的鍵
                //3. 調用map集合方法get,通過鍵獲取到值
                String key = it.next();
                Integer value = map.get(key);
                System.out.println(key + "...." + value);
            }

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

Map集合Entry對象

*A:Map集合Entry對象

    interface Map {
        interface Entry {//Entry是Map的一個內部接口
            //由Map的子類的內部類實現
        }
    }

    class HashMap {
        static class Entry<K, V> implements Map.Entry<K, V> {//Entry對象指的就是該類的對象
            final K key;
            V value;
        }
    }
    /*
        在Map類設計時，提供了一個嵌套接口：Entry。
        Entry將鍵值對的對應關系封裝成了對象。
        即鍵值對對象，這樣我們在遍歷Map集合時，就可以從每一個鍵值對（Entry）對象中獲取對應的鍵與對應的值。
        a:Entry是Map接口中提供的一個靜態內部嵌套接口。
        b:相關方法
        getKey()方法：獲取Entry對象中的鍵
        getValue()方法：獲取Entry對象中的值
        entrySet()方法：用於返回Map集合中所有的鍵值對(Entry)對象，以Set集合形式返回。
     */

Map集合遍歷方式entrySet方法

*A:Map集合遍歷方式entrySet方法

    /*
    *Map集合獲取方式
    *entrySet方法,鍵值對映射關系(結婚證)獲取
    *實現步驟:
    *1.調用map集合方法entrySet()將集合中的映射關系對象,存儲到Set集合
    *Set<Entry<K, V> >
    *2.叠代Set集合
    *3.獲取出的Set集合的元素,是映射關系對象
    *4.通過映射關系對象方法 getKet,getValue獲取鍵值對
    *
    *創建內部類對象 外部類.內部類=new
    */
    public class MapDemo2 {
        public static void main(String[] args) {
            Map<Integer, String> map = new HashMap<Integer, String>();
            map.put(1, "abc");
            map.put(2, "bcd");
            map.put(3, "cde");
            //1. 調用map集合方法entrySet()將集合中的映射關系對象,存儲到Set集合
            Set<Map.Entry<Integer, String>> set = map.entrySet();
            //2. 叠代Set集合
            Iterator<Map.Entry<Integer, String>> it = set.iterator();
            while (it.hasNext()) {
                //  3. 獲取出的Set集合的元素,是映射關系對象
                // it.next 獲取的是什麽對象,也是Map.Entry對象
                Map.Entry<Integer, String> entry = it.next();
                //4. 通過映射關系對象方法 getKet, getValue獲取鍵值對
                Integer key = entry.getKey();
                String value = entry.getValue();
                System.out.println(key + "...." + value);
            }
        }
    }

Map集合遍歷方式增強for循環

*A:Map集合遍歷方式增強for循環
    *A:Map集合遍歷方式entrySet方法

        /*
        *Map集合獲取方式
        *entrySet方法,鍵值對映射關系(結婚證)獲取
        *實現步驟:
        *1.調用map集合方法entrySet()將集合中的映射關系對象,存儲到Set集合
        *Set<Entry<K, V> >
        *2.叠代Set集合
        *3.獲取出的Set集合的元素,是映射關系對象
        *4.通過映射關系對象方法 getKet,getValue獲取鍵值對
        *
        *創建內部類對象 外部類.內部類=new
        */
        public class MapDemo2 {
            public static void main(String[] args) {
                Map<Integer, String> map = new HashMap<Integer, String>();
                map.put(1, "abc");
                map.put(2, "bcd");
                map.put(3, "cde");
                //1. 調用map集合方法entrySet()將集合中的映射關系對象,存儲到Set集合
                Set<Map.Entry<Integer, String>> set = map.entrySet();
                //2. 叠代Set集合
                Iterator<Map.Entry<Integer, String>> it = set.iterator();
                while (it.hasNext()) {
                    //  3. 獲取出的Set集合的元素,是映射關系對象
                    // it.next 獲取的是什麽對象,也是Map.Entry對象
                    Map.Entry<Integer, String> entry = it.next();
                    //4. 通過映射關系對象方法 getKet, getValue獲取鍵值對
                    Integer key = entry.getKey();
                    String value = entry.getValue();
                    System.out.println(key + "...." + value);
                }
                System.out.println("=========================");
                for (Map.Entry<Integer, String> entry : map.entrySet()) {
                    System.out.println(entry.getKey() + "..." + entry.getValue());
                }
            }
        }

    註意：Map集合不能直接使用叠代器或者foreach進行遍歷。但是轉成Set之後就可以使用了。

HashMap集合存儲和遍歷

*A:HashMap集合存儲和遍歷

    /*
     *  使用HashMap集合,存儲自定義的對象
     *  自定義對象,作為鍵,出現,作為值出現
     */
    public class HashMapDemo {
        public static void main(String[] args) {
            function_1();
        }

        /*
         * HashMap 存儲自定義對象Person,作為鍵出現
         * 鍵的對象,是Person類型,值是字符串
         * 保證鍵的唯一性,存儲到鍵的對象,重寫hashCode equals
         */
        public static void function_1() {
            HashMap<Person, String> map = new HashMap<Person, String>();
            map.put(new Person("a", 20), "裏約熱內盧");
            map.put(new Person("b", 18), "索馬裏");
            map.put(new Person("b", 18), "索馬裏");
            map.put(new Person("c", 19), "百慕大");
            for (Person key : map.keySet()) {
                String value = map.get(key);
                System.out.println(key + "..." + value);
            }
            System.out.println("===================");
            for (Map.Entry<Person, String> entry : map.entrySet()) {
                System.out.println(entry.getKey() + "..." + entry.getValue());
            }
        }

        /*
         * HashMap 存儲自定義的對象Person,作為值出現
         * 鍵的對象,是字符串,可以保證唯一性
         */
        public static void function() {
            HashMap<String, Person> map = new HashMap<String, Person>();
            map.put("beijing", new Person("a", 20));
            map.put("tianjin", new Person("b", 18));
            map.put("shanghai", new Person("c", 19));
            for (String key : map.keySet()) {
                Person value = map.get(key);
                System.out.println(key + "..." + value);
            }
            System.out.println("=================");
            for (Map.Entry<String, Person> entry : map.entrySet()) {
                String key = entry.getKey();
                Person value = entry.getValue();
                System.out.println(key + "..." + value);
            }
        }
    }

LinkedHashMap的特點

*A:LinkedHashMap的特點

    /*
    *  LinkedHashMap繼承HashMap
    *  保證叠代的順序
    */
    public class LinkedHashMapDemo {
        public static void main(String[] args) {
            LinkedHashMap<String, String> link = new LinkedHashMap<String, String>();
            link.put("1", "a");
            link.put("13", "a");
            link.put("15", "a");
            link.put("17", "a");
            System.out.println(link);
        }
    }

Hashtable的特點

*A:Hashtable的特點

    /*
     *  Map接口實現類 Hashtable
     *  底層數據結果哈希表,特點和HashMap是一樣的
     *  Hashtable 線程安全集合,運行速度慢
     *  HashMap 線程不安全的集合,運行速度快
     *
     *  Hashtable命運和Vector是一樣的,從JDK1.2開始,被更先進的HashMap取代
     *
     *  HashMap 允許存儲null值,null鍵
     *  Hashtable 不允許存儲null值,null鍵
     *
     *  Hashtable他的孩子,子類 Properties 依然活躍在開發舞臺
     */
    public class HashtableDemo {
        public static void main(String[] args) {
            Map<String, String> map = new Hashtable<String, String>();
            map.put(null, null);
            System.out.println(map);
        }
    }

靜態導入

*A:靜態導入:
    如果本類中有和靜態導入的同名方法會優先使用本類的
    如果還想使用靜態導入的,依然需要類名來調用
    /*
    * JDK1.5新特性,靜態導入
    * 減少開發的代碼量
    * 標準的寫法,導入包的時候才能使用
    *
    * import static java.lang.System.out;最末尾,必須是一個靜態成員
    */
    
    public class StaticImportDemo {
        public static void main(String[] args) {
            out.println("hello");
    
            int[] arr = {1, 4, 2};
            sort(arr);
        }
    }

方法的可變參數

*A:方法的可變參數

    /*
     *  JDK1.5新的特性,方法的可變參數
     *  前提: 方法參數數據類型確定,參數的個數任意
     *  可變參數語法: 數據類型...變量名
     *  可變參數,本質就是一個數組
     */
    public class VarArgumentsDemo {
        public static void main(String[] args) {
            //調用一個帶有可變參數的方法,傳遞參數,可以任意
            //  getSum();
            int sum = getSum(5, 34, 3, 56, 7, 8, 0);
            System.out.println(sum);
        }
    
        /*
         * 定義方法,計算10個整數和
         * 方法的可變參數實現
         */
        public static int getSum(int... a) {
            int sum = 0;
            for (int i : a) {
                sum = sum + i;
            }
            return sum;
        }
    
        /*
         * 定義方法,計算3個整數和
         */
        /*public static int getSum(int a,int b ,int c){
            return a+b+c;
        }*/
    
        /*
         * 定義方法,計算2個整數和
         */
        /*public static int getSum(int a,int b){
            return a+b;
        }*/
    }

可變參數的註意事項

*A:可變參數的註意事項
    /*
    * 可變參數的註意事項
    * 1. 一個方法中,可變參數只能有一個
    * 2. 可變參數,必須寫在參數列表的最後一位
    */
    public static void function(Object...o){}

Collections工具類?

*A:Collections工具類

    /*
     *  集合操作的工具類
     *    Collections
     */
    public class CollectionsDemo {
        public static void main(String[] args) {
            function_2();
        }

        /*
         * Collections.shuffle方法
         * 對List集合中的元素,進行隨機排列
         */
        public static void function_2() {
            List<Integer> list = new ArrayList<Integer>();
            list.add(1);
            list.add(5);
            list.add(9);
            list.add(11);
            list.add(8);
            list.add(10);
            list.add(15);
            list.add(20);
            System.out.println(list);
            //調用工具類方法shuffle對集合隨機排列
            Collections.shuffle(list);
            System.out.println(list);
        }

        /*
         * Collections.binarySearch靜態方法
         * 對List集合進行二分搜索,方法參數,傳遞List集合,傳遞被查找的元素
         */
        public static void function_1() {
            List<Integer> list = new ArrayList<Integer>();
            list.add(1);
            list.add(5);
            list.add(8);
            list.add(10);
            list.add(15);
            list.add(20);
            //調用工具類靜態方法binarySearch
            int index = Collections.binarySearch(list, 16);
            System.out.println(index);
        }

        /*
         *  Collections.sort靜態方法
         *  對於List集合,進行升序排列
         */
        public static void function() {
            //創建List集合
            List<String> list = new ArrayList<String>();
            list.add("ewrew");
            list.add("qwesd");
            list.add("Qwesd");
            list.add("bv");
            list.add("wer");
            System.out.println(list);
            //調用集合工具類的方法sort
            Collections.sort(list);
            System.out.println(list);
        }
    }

集合的嵌套

*A:集合的嵌套

    /*
     *  Map集合的嵌套,Map中存儲的還是Map集合
     *  要求:
     *    傳智播客
     *      Java基礎班
     *        001  張三
     *        002  李四
     *
     *      Java就業班
     *        001  王五
     *        002  趙六
     *  對以上數據進行對象的存儲
     *   001 張三  鍵值對
     *   Java基礎班: 存儲學號和姓名的鍵值對
     *   Java就業班:
     *   傳智播客: 存儲的是班級
     *
     *   基礎班Map   <學號,姓名>
     *   傳智播客Map  <班級名字, 基礎班Map>
     */
    public class MapMapDemo {
        public static void main(String[] args) {
            //定義基礎班集合
            HashMap<String, String> javase = new HashMap<String, String>();
            //定義就業班集合
            HashMap<String, String> javaee = new HashMap<String, String>();
            //向班級集合中,存儲學生信息
            javase.put("001", "張三");
            javase.put("002", "李四");
            javaee.put("001", "王五");
            javaee.put("002", "趙六");
            //定義傳智播客集合容器,鍵是班級名字,值是兩個班級容器
            HashMap<String, HashMap<String, String>> czbk =
                    new HashMap<String, HashMap<String, String>>();
            czbk.put("基礎班", javase);
            czbk.put("就業班", javaee);

            keySet(czbk);

        }
    }

集合的嵌套keySet遍歷?

*A:集合的嵌套keySet遍歷

    /*
     *  Map集合的嵌套,Map中存儲的還是Map集合
     *  要求:
     *    傳智播客
     *      Java基礎班
     *        001  張三
     *        002  李四
     *
     *      Java就業班
     *        001  王五
     *        002  趙六
     *  對以上數據進行對象的存儲
     *   001 張三  鍵值對
     *   Java基礎班: 存儲學號和姓名的鍵值對
     *   Java就業班:
     *   傳智播客: 存儲的是班級
     *
     *   基礎班Map   <學號,姓名>
     *   傳智播客Map  <班級名字, 基礎班Map>
     */
    public class MapMapDemo {
        public static void main(String[] args) {
            //定義基礎班集合
            HashMap<String, String> javase = new HashMap<String, String>();
            //定義就業班集合
            HashMap<String, String> javaee = new HashMap<String, String>();
            //向班級集合中,存儲學生信息
            javase.put("001", "張三");
            javase.put("002", "李四");
            javaee.put("001", "王五");
            javaee.put("002", "趙六");
            //定義傳智播客集合容器,鍵是班級名字,值是兩個班級容器
            HashMap<String, HashMap<String, String>> czbk =
                    new HashMap<String, HashMap<String, String>>();
            czbk.put("基礎班", javase);
            czbk.put("就業班", javaee);

            keySet(czbk);

        }

        public static void keySet(HashMap<String, HashMap<String, String>> czbk) {
            //調用czbk集合方法keySet將鍵存儲到Set集合
            Set<String> classNameSet = czbk.keySet();
            //叠代Set集合
            Iterator<String> classNameIt = classNameSet.iterator();
            while (classNameIt.hasNext()) {
                //classNameIt.next獲取出來的是Set集合元素,czbk集合的鍵
                String classNameKey = classNameIt.next();
                //czbk集合的方法get獲取值,值是一個HashMap集合
                HashMap<String, String> classMap = czbk.get(classNameKey);
                //調用classMap集合方法keySet,鍵存儲到Set集合
                Set<String> studentNum = classMap.keySet();
                Iterator<String> studentIt = studentNum.iterator();

                while (studentIt.hasNext()) {
                    //studentIt.next獲取出來的是classMap的鍵,學號
                    String numKey = studentIt.next();
                    //調用classMap集合中的get方法獲取值
                    String nameValue = classMap.get(numKey);
                    System.out.println(classNameKey + ".." + numKey + ".." + nameValue);
                }
            }

            System.out.println("==================================");
            for (String className : czbk.keySet()) {
                HashMap<String, String> hashMap = czbk.get(className);
                for (String numKey : hashMap.keySet()) {
                    String nameValue = hashMap.get(numKey);
                    System.out.println(className + ".." + numKey + ".." + nameValue);
                }
            }
        }

    }

集合的嵌套entrySet遍歷

*A:集合的嵌套entrySet遍歷

    /*
     *  Map集合的嵌套,Map中存儲的還是Map集合
     *  要求:
     *    傳智播客
     *      Java基礎班
     *        001  張三
     *        002  李四
     *
     *      Java就業班
     *        001  王五
     *        002  趙六
     *  對以上數據進行對象的存儲
     *   001 張三  鍵值對
     *   Java基礎班: 存儲學號和姓名的鍵值對
     *   Java就業班:
     *   傳智播客: 存儲的是班級
     *
     *   基礎班Map   <學號,姓名>
     *   傳智播客Map  <班級名字, 基礎班Map>
     */
    public class MapMapDemo {
        public static void main(String[] args) {
            //定義基礎班集合
            HashMap<String, String> javase = new HashMap<String, String>();
            //定義就業班集合
            HashMap<String, String> javaee = new HashMap<String, String>();
            //向班級集合中,存儲學生信息
            javase.put("001", "張三");
            javase.put("002", "李四");

            javaee.put("001", "王五");
            javaee.put("002", "趙六");
            //定義傳智播客集合容器,鍵是班級名字,值是兩個班級容器
            HashMap<String, HashMap<String, String>> czbk =
                    new HashMap<String, HashMap<String, String>>();
            czbk.put("基礎班", javase);
            czbk.put("就業班", javaee);

            entrySet(czbk);
        }

        public static void entrySet(HashMap<String, HashMap<String, String>> czbk) {
            //調用czbk集合方法entrySet方法,將czbk集合的鍵值對關系對象,存儲到Set集合
            Set<Map.Entry<String, HashMap<String, String>>>
                    classNameSet = czbk.entrySet();
            //叠代器叠代Set集合
            Iterator<Map.Entry<String, HashMap<String, String>>> classNameIt = classNameSet.iterator();
            while (classNameIt.hasNext()) {
                //classNameIt.next方法,取出的是czbk集合的鍵值對關系對象
                Map.Entry<String, HashMap<String, String>> classNameEntry = classNameIt.next();
                //classNameEntry方法 getKey,getValue
                String classNameKey = classNameEntry.getKey();
                //獲取值,值是一個Map集合
                HashMap<String, String> classMap = classNameEntry.getValue();
                //調用班級集合classMap方法entrySet,鍵值對關系對象存儲Set集合
                Set<Map.Entry<String, String>> studentSet = classMap.entrySet();
                //叠代Set集合
                Iterator<Map.Entry<String, String>> studentIt = studentSet.iterator();
                while (studentIt.hasNext()) {
                    //studentIt方法next獲取出的是班級集合的鍵值對關系對象
                    Map.Entry<String, String> studentEntry = studentIt.next();
                    //studentEntry方法 getKey getValue
                    String numKey = studentEntry.getKey();
                    String nameValue = studentEntry.getValue();
                    System.out.println(classNameKey + ".." + numKey + ".." + nameValue);
                }
            }
            System.out.println("==================================");

            for (Map.Entry<String, HashMap<String, String>> me : czbk.entrySet()) {
                String classNameKey = me.getKey();
                HashMap<String, String> numNameMapValue = me.getValue();
                for (Map.Entry<String, String> nameMapEntry : numNameMapValue.entrySet()) {
                    String numKey = nameMapEntry.getKey();
                    String nameValue = nameMapEntry.getValue();
                    System.out.println(classNameKey + ".." + numKey + ".." + nameValue);
                }
            }
        }
    }

?

總結

Map集合:

? map集合中的元素都是成對出現，成對存儲的

? map集合中的元素都是以一對鍵和值的形式組成存在的，稱為鍵值對，理解為夫妻對

? map集合中的鍵不能重復存儲，值可以重復

? map集合中的每一個鍵 對應著一個值

? 方法：

? put(K key, V value) 把指定的鍵與指定的值添加到Map集合中

? remove(Object key) 把指定的鍵 所對應的鍵值對元素 在Map集合中刪除，返回被刪除元素的值

? Set<Map.Entry<K,V>> entrySet() 獲取到Map集合中所有的鍵值對對象的集合(Set集合)

? get(Object key) 根據指定的鍵，在Map集合中獲取對應的值

? Set keySet() 獲取Map集合中所有的鍵，存儲到Set集合中

Map集合遍歷的兩種方式：

//方式1：根據鍵找值的方式
       //a, 獲取到Map集合中所有的鍵，返回對應的Set集合
       //b, 遍歷鍵的集合，獲取到每一個鍵
       //c, 通過鍵，找到對應的值
       //獲取到Map集合中所有的鍵，返回對應的Set集合
       Set<String> keys=map.keySet();
       //遍歷鍵的集合，獲取到每一個鍵
       for(String key:keys){
           //通過鍵，找到對應的值
           Student s=map.get(key);
           System.out.println(key+"..."+s.getName()+"..."+s.getAge());
       }

//方式2：根據鍵值對對象找鍵和值的方式
       //a, 獲取Map集合中所有的鍵值對元素,返回對應的Set集合
       //b, 遍歷鍵值對元素集合，獲取到每一個鍵值對元素對象
       //c, 通過鍵值對元素對象，獲取對應的鍵，和對應的值
       //獲取Map集合中所有的鍵值對元素,返回對應的Set集合
       Set<Map.Entry<String, Student>>entrySet=map.entrySet();
       //遍歷鍵值對元素集合，獲取到每一個鍵值對元素對象
       for(Map.Entry<String, Student> entry:entrySet){
           //通過鍵值對元素對象，獲取對應的鍵，和對應的值
           //找鍵
           String key=entry.getKey();
           //找值
           Student s=entry.getValue();
           //打印
           System.out.println(key+"..."+s.getName()+"..."+s.getAge());
       }

 

HashMap:

? 特點：

? 是Map集合的子集合

? 底層采用哈希表結構

? HashMap集合中的key不能重復，通過重寫hashCode() 與 equals()方法來保證鍵的唯一。

? 不能保證元素存與取的順序完全一致

LinkedHashMap:

? 特點：

? 是HashMap集合的子集合

? 底層采用哈希表+鏈表結構

? LinkedHashMap集合中的key不能重復，通過重寫hashCode() 與 equals()方法來保證鍵的唯一。

Collections中的方法：

? public static void sort(List list) 排序

? public static void shuffle(List<?> list) 集合中的元素存儲位置隨機打亂

11、Map、可變參數、Collections