package Collection;
 ​
 import java.util.ArrayList;
 import java.util.Collection;
 ​
 /*
 Collection集合常用方法
 boolean add(E e)；                    向集合中添加元素
 boolean remove(E e);                  刪除集合中的某個(gè)元素
 void clear();                       清空集合中所有的元素
 boolean contains();                       判斷集合中是否含有xxx元素
 boolean isEmpty();                    判斷集合是否為空
 int size();                            計(jì)算集合的長(zhǎng)度
 Object[] toArray();                       將集合轉(zhuǎn)成一個(gè)數(shù)組
  */
 public class Test {
     public static void main(String[] args) {
         //創(chuàng)建集合對(duì)象 , 可以多態(tài)使用
         Collection<String>col = new ArrayList<>();
 //      Collection<String>col = new HashSet<>();    下面的功能照樣能實(shí)現(xiàn)：共性方法
         col.add("小明"); // 添加元素
         col.add("小紅");
         col.add("小藍(lán)");
         col.add("小綠");
         System.out.println(col); //[小明, 小紅, 小藍(lán), 小綠]
 ​
         //boolean remove(E e);      刪除集合中的某個(gè)元素
 //        boolean ans = col.remove("小明");
 //        System.out.println(ans);//true
 //        System.out.println(col);//[小紅, 小藍(lán), 小綠]
 ​
         //void clear();             清空集合中所有的元素
 //        col.clear();
 //        System.out.println(col);//[]
 ​
         //boolean contains();        判斷集合中是否含有xxx元素
 //        boolean result = col.contains("小明");
 //        System.out.println(result);//true
 ​
         //boolean isEmpty();          判斷集合是否為空
 //        boolean result = col.isEmpty();
 //        System.out.println(result);// 不為空f(shuō)alse
 ​
         //int size();             計(jì)算集合的長(zhǎng)度
 //        int len = col.size();
 //        System.out.println(len);// 4
 ​
         //Object[] toArray();        將集合轉(zhuǎn)成一個(gè)數(shù)組
         Object[] arr = col.toArray();
         // 遍歷數(shù)組
 //        for (int i = 0; i < arr.length; i++) {
 //            System.out.println(arr[i]);
 //        }
     }
 }

 package Iterator;
 ​
 import javax.swing.text.html.parser.Entity;
 import java.util.*;
 ​
 public class Test {
     public static void main(String[] args) {
         //創(chuàng)建一個(gè)集合對(duì)象
         Collection<String>col = new ArrayList();
         //添加元素
         col.add("小明");
         col.add("小紅");
         col.add("小藍(lán)");
         col.add("小綠");
 ​
         /*
         1.使用集合的方法iterator()獲取迭代器的實(shí)現(xiàn)類(lèi)對(duì)象，使用Iterator接口接收（多態(tài)）
         注意：
             Iterator接口也是有泛型的，迭代器的泛型跟集合走，集合是什么泛型，迭代器就是什么泛型
          */
         // 多態(tài) 接口             實(shí)現(xiàn)類(lèi)對(duì)象
         Iterator<String>it = col.iterator();
 ​
         // 2.使用 Iterator接口中的hashNext方法判斷是否還有下一個(gè)元素
         while(it.hasNext());{
         // 3.使用 Iterator接口中的next方法取出集合的下一個(gè)元素
         String str = it.next();
         System.out.println(str);        
         }
 ​
     }
 }

for(類(lèi)型 變量 : 數(shù)組/集合){// 數(shù)組或者集合里的每一項(xiàng)賦值給這個(gè)變量
     // 循環(huán)體
 }

         String[] student = {"小明","小紅","小藍(lán)"};
 //        // 傳統(tǒng)遍歷方式
 //        for (int i = 0; i < student.length; i++) {
 //            System.out.println(student[i]);
 //        }
 ​
         // 增強(qiáng)for
         for(String c : student){
             System.out.println(c);
         }
 ​
  --------------------------------
         List<Integer>list = new ArrayList<Integer>();
         list.add(123);
         list.add(234);
         list.add(456);
         for(Integer n : list){
             System.out.println(n);
         }

 public static void main(String[] args) {
         List list = new ArrayList();
         list.add("小明");
         list.add("小紅");
         for (int i = 0; i < list.size(); i++) {
         String s= (String)list.get(i) // 強(qiáng)轉(zhuǎn)
             System.out.println(s);
         }
     }

public static void main(String[] args) {
         List<String> list = new ArrayList();// 規(guī)范了數(shù)據(jù)類(lèi)型，只能放字符串!
         list.add("小明");
         list.add("小紅");
         //stringList.add(123);// 除了字符串以外的類(lèi)型不能加，報(bào)錯(cuò)！
         for (int i = 0; i < list.size(); i++) {
             String s = list.get(i); // 不用再?gòu)?qiáng)轉(zhuǎn)了
             System.out.println(s);
         }
     }

修飾符 class 類(lèi)名<泛型變量>{
 ​
 }
 // 注：泛型變量建議使用E、T、K、V

 public class Box<T> {
  
   private T t;
  
   public void add(T t) {
     this.t = t;
   }
  
   public T get() {
     return t;
   }

 修飾符 <泛型變量> 返回值的類(lèi)型 方法名稱(chēng)(形參列表){
     //方法體
 }

 public interface 接口名<泛型類(lèi)型> {
     
 }

 package FanXing;
 ​
 import javax.swing.text.html.HTMLDocument;
 import java.util.ArrayList;
 import java.util.Iterator;
 /*
     泛型的通配符：
         ？：代表數(shù)據(jù)類(lèi)型
     使用方式：
         不能在創(chuàng)建對(duì)象時(shí)使用
         只能作為方法的傳遞參數(shù)使用
  */
 public class Generic {
     public static void main(String[] args) {
 ​
         ArrayList<Integer>list01 = new ArrayList<>();
         list01.add(123);
         list01.add(456);
 ​
         ArrayList<String>list02 = new ArrayList<>();
         list02.add("小明");
         list02.add("小紅");
 // ......還有很多其它類(lèi)型
         printArray(list01);
         printArray(list02);
         /*
             定義一個(gè)方法，能遍歷所有類(lèi)型的ArrayList集合
             這時(shí)候我們不知道ArrayList集合使用的是什么類(lèi)型，可以使用泛型的通配符：？來(lái)代表數(shù)據(jù)類(lèi)型
             注意：泛型沒(méi)有繼承的概念
          */
     }
 ​
     public static void printArray(ArrayList<?>list){
         // 使用迭代器遍歷集合
        Iterator<?> it = list.iterator();
        while(it.hasNext()){
            Object obj = it.next();//it.next()取出的元素是Object類(lèi)。Object類(lèi) 可以接收任意的數(shù)據(jù)類(lèi)型
            System.out.println(obj);
        }
 ​
     }
 }

 add(int index, E element) 根據(jù)索引添加元素
 get(int index) 根據(jù)索引獲取元素
 remove(int index) 根據(jù)索引刪除元素
 set(int index, E element) 根據(jù)索引修改該位置上的元素
 contains(E element)判斷容器是否含有XXX東西
 clear() 清空集合中的元素
 size()計(jì)算集合的大小

 package Collection;
 ​
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
 ​
 public class TestList {
     public static void main(String[] args) {
         List<String>list = new ArrayList();
         // 換成Linkedist 下面的操作都能一樣實(shí)現(xiàn)
 ​
         list.add("小明");
         list.add("小紅");
         list.add("小藍(lán)");
         list.add("小綠");
         list.add("小明");
 ​
 ​
 //        // 在某個(gè)索引位置往集合中添加元素
 //        list.add(2,"哈哈哈哈");
 //        System.out.println(list);
 ​
 //        // 刪除集合中某個(gè)元素
 //        list.remove("小藍(lán)");
 ​
 ​
 //        // 根據(jù)索引獲取元素
 //        System.out.println(list.get(0));
 ​
 //        // 修改索引位置處的元素
 //        list.set(0,"小明很明白!");
 //        System.out.println(list.get(0));//小明很明白!
 ​
 //        // 計(jì)算列表的大小(長(zhǎng)度)：
 //        System.out.println(list.size());
 ​
 //        //判斷列表中是否有xxx false
 //        System.out.println(list.contains("小藍(lán)"));
 ​
     }
 }

 // 遍歷列表
 for (int i = 0; i < list.size(); i++) {
     String str = list.get(i);
     System.out.println(str);
 ​
 }

 Iterator<String>it = list.iterator(); // 創(chuàng)建一個(gè)List的迭代器
 ​
 while(it.hasNext()){// 判斷有沒(méi)有下一個(gè)元素
     String s = it.next(); 
     System.out.println(s);
 }

 List<String>list = new ArrayList<>();
 ​
     for(String s : list){
         System.out.println(s);
     }

 list.foreach(s -> {
       System.out.println(s);    
 });

 public void addFirst(E e); 將指定的元素插到列表開(kāi)頭。
 public void addLat(E e); 將指定的元素插到列表結(jié)尾。 此方法等效于add()方法
 public void push(E e); 將元素推入此列表所示的堆棧。 此方法等效于addFirst()方法
 ​
 public E getFirst(); 返回此列表的第一個(gè)元素
 public E getLast(); 返回此列表的最后一個(gè)元素
 ​
 public E removeFirst(); 移除并返回此列表的第一個(gè)元素
 public E removeLast(); 移除并返回此列表的最后一個(gè)元素
 public E pop(E e); 入此列表所示的堆棧中彈出一個(gè)元素。
 ​
 public boolean isEmpty(); 如果列表為空 返回true

 package Collection;
 /*
 public void addFirst(E e); 將指定的元素插到列表開(kāi)頭。
 public void addLast(E e); 將指定的元素插到列表結(jié)尾。
 public void push(E e); 將元素推入此列表所示的堆棧。
 ​
 public E getFrist(); 返回此列表的第一個(gè)元素
 public E getLast(); 返回此列表的最后一個(gè)元素
 ​
 public E removeFrist(); 移除并返回此列表的第一個(gè)元素
 public E removeLast(); 移除并返回此列表的最后一個(gè)元素
 public E pop(E e); 入此列表所示的堆棧中彈出一個(gè)元素。
 ​
 public boolean isEmpty(); 如果列表為空 返回true
  */
 ​
 import java.util.LinkedList;
 import java.util.List;
 ​
 public class TestLinkedList {
     public static void main(String[] args) {
     show01();
     show02();
     show03();
     }
 ​
     /*
     public void addFirst(E e); 將指定的元素插到列表開(kāi)頭。
     public void addLast(E e); 將指定的元素插到列表結(jié)尾。
     public void push(E e); 將元素推入此列表所示的堆棧
      */
     public static void show01(){
 //        注：LinkedList特有的方法不能使用多態(tài)！
 //        List<String> list = new LinkedList<>(); 是不對(duì)的
         LinkedList<String>list = new LinkedList<>();
 ​
         // add()添加元素
         list.add("a");
         list.add("b");
         list.add("c");
         System.out.println(list);//[a, b, c]
 ​
         list.addFirst("hhh");
         //public void push(E e); 將元素推入此列表所示的堆棧。 等效于addFirst()
         list.push("hhh");
         System.out.println(list);
 ​
         //public void lastFrist(E e); 將指定的元素插到列表結(jié)尾。 等效于add()
         list.addLast("com");
         System.out.println(list);
 ​
     }
     /*
     public E getFrist(); 返回此列表的第一個(gè)元素
     public E getLast(); 返回此列表的最后一個(gè)元素
      */
     public static void show02(){
         LinkedList<String>list = new LinkedList<>();
         // add()添加元素
         list.add("a");
         list.add("b");
         list.add("c");
 //        list.clear(); // 清空集合中所有元素
         if(! list.isEmpty()){
             System.out.println(list.getFirst());//a
             System.out.println(list.getLast());//c
         }
     }
     /*
     public E removeFrist(); 移除并返回此列表的第一個(gè)元素
     public E removeLast(); 移除并返回此列表的最后一個(gè)元素
     public E pop(E e); 入此列表所示的堆棧中彈出一個(gè)元素。
      */
     public static void show03(){
         LinkedList<String>list = new LinkedList<>();
         // add()添加元素
         list.add("a");
         list.add("b");
         list.add("c");
         System.out.println(list.pop());
         //public E pop(E e); 入此列表所示的堆棧中彈出一個(gè)元素。 等效于 removefirst()
         //System.out.println(list.pop());   
         System.out.println(list.removeFirst());//a
         System.out.println(list.removeLast());//c
         System.out.println(list);//[b]
     }
 }

 package Collection;
 ​
 import javax.swing.text.html.HTMLDocument;
 import java.util.Enumeration;
 import java.util.Iterator;
 import java.util.Vector;
 ​
 /*
     Vector集合的使用
         存儲(chǔ)結(jié)構(gòu)：數(shù)組
  */
 public class VectorTest {
     public static void main(String[] args) {
         // 創(chuàng)建集合
         Vector<String>vector = new Vector<>();
         // 添加元素
         vector.add("小明");
         vector.add("小紅");
         vector.add("小藍(lán)");
         System.out.println("元素個(gè)數(shù)"+ vector.size());
         // 判斷
         System.out.println(vector.contains("小明"));
         System.out.println(vector.isEmpty());
         //刪除
         vector.remove("小紅");
         System.out.println(vector);
         //清空 clear(); vector.clear();
         // 遍歷
         Iterator<String> it = vector.iterator();
         while (it.hasNext()){
             String str = it.next();
             System.out.println(str);
         }
         //vector獨(dú)有的遍歷  使用枚舉器
 //        Enumeration<String>en = vector.elements();
 //        while (en.hasMoreElements()){
 //            String s = en.nextElement();
 //            System.out.println(s);
 //        }
     }
 }

 package Collection;
 ​
 import java.util.Objects;
 ​
 public class Person {
     private String name;
     private int age;
 ​
     public Person(String name, int age) {
         this.name = name;
         this.age = age;
     }
 ​
     // 用于打印
     @Override
     public String toString() {
         return "Person{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
     }
     // 重寫(xiě)hashCode方法和equals方法
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         Person person = (Person) o;
         return age == person.age && Objects.equals(name, person.name);
     }
 ​
     @Override
     public int hashCode() {
         return Objects.hash(name, age);
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
 }

 // 主控制臺(tái)
 package Collection;
 ​
 import java.util.HashSet;
 import java.util.Set;
 /*
     HashSet存儲(chǔ)自定義類(lèi)型的元素
 ​
     Set集合保證元素唯一性：
         存儲(chǔ)的元素(String Integer,...Student,Person...) 必須重寫(xiě)hashCode方法和equals方法
     要求：
         同名且同年齡視為同一個(gè)人噢
  */
 public class TestHaxhSet {
     public static void main(String[] args) {
         // 創(chuàng)建hashSet集合存儲(chǔ)Person
         Set<Person>set = new HashSet<>();
        //集合類(lèi)存放對(duì)象的！
         // 創(chuàng)建對(duì)象(人)
 /*
        // 在沒(méi)有重寫(xiě)hashCode方法和equals方法前，它們的哈希值都是不一樣的,equals也為false 故沒(méi)有重復(fù)
         Person p1 = new Person("小明",18);
         Person p2 = new Person("小明",19);
         Person p3 = new Person("小明",18);
         System.out.println(p1.hashCode());// 460141958
         System.out.println(p2.hashCode());// 1163157884
         System.out.println(p3.hashCode());// 1956725890
         System.out.println(p1.equals(p2));// false
         set.add(p1);
         set.add(p2);
         set.add(p3);
         System.out.println(set);// [Person{name='小明', age=18}, Person{name='小明', age=19}, Person{name='小明', age=18}]
 */
         // 重寫(xiě)hashCode方法和equals方法之后set對(duì)象就唯一性了
         Person p1 = new Person("小明",18);
         Person p2 = new Person("小明",19);
         Person p3 = new Person("小明",18);
         set.add(p1);
         set.add(p2);
         set.add(p3);
         System.out.println(set);// [Person{name='小明', age=19}, Person{name='小明', age=18}]
 ​
     }
 }

 package Collection;
 ​
 import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.Set;
 ​
 public class TestHashSet {
     public static void main(String[] args) {
         Set<String>set = new HashSet<>();
         set.add("kkk");
         set.add("abc");
         set.add("abc");
         set.add("afterglow");
         System.out.println(set);//[afterglow, abc, kkk] 無(wú)序，不重復(fù)
 ​
         Set<String>Linkset = new LinkedHashSet<>();
         Linkset.add("kkk");
         Linkset.add("abc");
         Linkset.add("abc");
         Linkset.add("afterglow");
         System.out.println(Linkset);//[kkk, abc, afterglow] 有序，不重復(fù)
     }
 ​
 }

 package Collection;
 ​
 public class KeBiancanShu {
     public static void main(String[] args) {
         int i =add(1,2,3,4);
         System.out.println(i);
     }
 ​
 //    // 兩個(gè)數(shù)的和
 //    public static int add(int a, int b){
 //        return a + b;
 //    }
 //    // 三個(gè)數(shù)的和,要是多個(gè)一直往下寫(xiě)，很麻煩!
 //    public static int add(int a, int b, int c){
 //        return a + b +c;
 //    }
 ​
     /*    
         求0~n個(gè)整數(shù)的和
         數(shù)據(jù)類(lèi)型已經(jīng)確定：int
         參數(shù)個(gè)數(shù)不確定，可以使用可變參數(shù)
 ​
      */
     public static int add(int...arr){
 //        System.out.println(arr);// [I@1b6d3586 底層是一個(gè)數(shù)組
 //        System.out.println(arr.length);// 可變數(shù)組的長(zhǎng)度，卻決于你添加的個(gè)數(shù)
         int sum = 0;
         for (int i : arr){
            sum += i;
         }
         return sum;
     }
 }

     /*
     可變參數(shù)注意事項(xiàng)：
         一個(gè)方法的參數(shù)列表，只能有一個(gè)可變參數(shù)
         如果方法的參數(shù)有多個(gè)，那么可變參數(shù)必須寫(xiě)在參數(shù)列表的末尾!
      */
     //一個(gè)方法的參數(shù)列表，只能有一個(gè)可變參數(shù)
 //    public static void method01(int...a,String...b){ 報(bào)錯(cuò)!
 //         }
     
     //如果方法的參數(shù)有多個(gè)，那么可變參數(shù)必須寫(xiě)在參數(shù)列表的末尾!
     public static void method02(String b, double c, int...a){
         
     }

 public class Test {
     public static void main(String[] args) {
         List<Integer>list = new ArrayList<Integer>();
         list.add(120);
         list.add(20);
         list.add(220);
 ​
         // 求最值
         Integer max = Collections.max(list);
         System.out.println(max);
         Integer min = Collections.min(list);
         System.out.println(min);
         // 排序
         Collections.sort(list);
         System.out.println(list);
         // 打亂順序
         Collections.shuffle(list); // 斗地主發(fā)牌
         System.out.println(list);
         // 不定參數(shù)添加
         Collections.addAll(list,456,789);
         System.out.println(list);//[220, 20, 120, 456, 789]
         
     }
 }

 public class TestComparator {
     public static void main(String[] args) {
         List<Integer> list = new ArrayList<>();
         list.add(2);
         list.add(1);
         list.add(3);
 ​
         Collections.sort(list, new Comparator<Integer>() {
             @Override
             public int compare(Integer o1, Integer o2) {
                 return o1 - o2;// 升序
 //                return o2 - o1;// 降序
             }
         });
 ​
         System.out.println(list);// [1, 2, 3]
     }
 }

 package Map;
 ​
 import java.util.HashMap;
 import java.util.Map;
 ​
 public class Test {
     public static void main(String[] args) {
         // 創(chuàng)建Map集合對(duì)象，多態(tài)
         Map<Integer,String>map = new HashMap();
         map.put(11,"小明");
         map.put(22,"小紅");
         map.put(33,"小藍(lán)");
         map.put(44,"小綠");
         System.out.println(map);// {33=小藍(lán), 22=小紅, 11=小明, 44=小綠} HashMap無(wú)序的
 ​
         map.remove(44);// 刪除
         System.out.println(map);// {33=小藍(lán), 22=小紅, 11=小明}
 ​
         System.out.println(map.size()); //大小 3
 ​
         System.out.println(map.containsKey(33)); //true
         System.out.println(map.containsValue("小藍(lán)")); //true
 ​
         map.put(22,"小芳"); // {33=小藍(lán), 22=小芳, 11=小明} 若出現(xiàn)重復(fù)的key原來(lái)的數(shù)據(jù)會(huì)被頂替
         System.out.println(map);
 //        map.put(55,"小明");
 //        System.out.println(map);//是否被頂替卻決于key，key映射value，而不是value映射key {33=小藍(lán), 22=小芳, 55=小明, 11=小明}
 ​
         System.out.println(map.keySet()); // [33, 22, 11] 把map中的key打包成Set集合的形式
 ​
         System.out.println(map.get(33));// 小藍(lán)  通過(guò)key查詢(xún)value
     }
 }
 ​

 package Map;
 ​
 import javax.swing.text.html.HTMLDocument;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 ​
 public class Test {
     public static void main(String[] args) {
         // 創(chuàng)建Map集合對(duì)象
         Map<String,Integer>map = new HashMap<>();
         map.put("小明",18);
         map.put("小紅",18);
         map.put("小藍(lán)",19);
         map.put("小綠",20);
 ​
         //1. 使用Map集合中的方法keySet()，把Map集合里所有的key取出來(lái)，存放到一個(gè)Set集合中\(zhòng)
         Set<String> set = map.keySet();
         
         //2.遍歷set集合，獲取Map集合中的每一個(gè)key
         /* 使用while遍歷 */
         Iterator <String> it = set.iterator();
         while (it.hasNext()){
             String key = it.next();
             
             //3.通過(guò)Map集合中的get(key)方法，找到value
             Integer value = map.get(key);
             System.out.println(key+"="+value);
         }
         System.out.println("-----------------------");
         /* 使用增強(qiáng)for遍歷 */
         for(String key : set){
             //3.通過(guò)Map集合中的get(key)方法，找到value
             Integer value = map.get(key);
             
             System.out.println(key+"="+value);
         }
 ​
     }
 }

     Set<String> set = map.keySet();
     Iterator <String> it = set.iterator();
     
     while (it.hasNext()){
         String key = it.next();
         Integer value = map.get(key);
         System.out.println(key+"="+value);
     }

     Set<String> set = map.keySet();
     
     for(String key : set){
         //3.通過(guò)Map集合中的get(key)方法，找到value
         Integer value = map.get(key);
         System.out.println(key+"="+value);
     }

 package Map;
 ​
 import javax.swing.text.html.HTMLDocument;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 ​
 public class Test {
     public static void main(String[] args) {
         // 創(chuàng)建Map集合對(duì)象
         Map<String,Integer>map = new HashMap<>();
         map.put("小明",18);
         map.put("小紅",18);
         map.put("小藍(lán)",19);
         map.put("小綠",20);
 ​
         //1.通過(guò)Map集合中的entrySet()方法，把Map集合中的多個(gè)Entry對(duì)象取出來(lái)，存儲(chǔ)到一個(gè)Set集合中
         Set<Map.Entry<String,Integer>> set = map.entrySet();
 ​
         //遍歷set集合，獲取每一個(gè)Entry對(duì)象
         //使用迭代器遍歷set集合
         Iterator <Map.Entry<String,Integer>> it = set.iterator();
         while (it.hasNext()){
             Map.Entry<String,Integer>entry = it.next();
             // 使用Entry對(duì)象中的getKey()和getValue()方法獲取鍵和值
             String key = entry.getKey();
             Integer value = entry.getValue();
             System.out.println(key+"="+value);
         }
         System.out.println("-----------");
 ​
         //增強(qiáng)for
         for(Map.Entry<String,Integer> entry : set){
             // 使用Entry對(duì)象中的getKey()和getValue()方法獲取鍵和值
             String key = entry.getKey();
             Integer value = entry.getValue();
             System.out.println(key+"="+value);
         }
     }
 }

         Set<Map.Entry<String,Integer>> set = map.entrySet();
 ​
         //遍歷set集合，獲取每一個(gè)Entry對(duì)象
         //使用迭代器遍歷set集合
         Iterator <Map.Entry<String,Integer>> it = set.iterator();
         while (it.hasNext()){
             Map.Entry<String,Integer>entry = it.next();
             
             // 使用Entry對(duì)象中的getKey()和getValue()方法獲取鍵和值
             String key = entry.getKey();
             Integer value = entry.getValue();
             System.out.println(key+"="+value);
         }

      //增強(qiáng)for
         for(Map.Entry<String,Integer> entry : set){
             // 使用Entry對(duì)象中的getKey()和getValue()方法獲取鍵和值
             String key = entry.getKey();
             Integer value = entry.getValue();
             System.out.println(key+"="+value);
         }

 package Map;
 /*
     hashMap存儲(chǔ)自定義類(lèi)型鍵值：
     Map集合保證key是唯一的：
         作為key元素，必須重寫(xiě)hashMap方法和equals方法，以保證key唯一
  */
 ​
 import java.util.HashMap;
 import java.util.Set;
 ​
 public class HashMapSavePerson {
     public static void main(String[] args) {
         show01();
         /*
             上海-->HashMapSavePerson{name='小藍(lán)', age=18}
             深圳-->HashMapSavePerson{name='小綠', age=18}
             北京-->HashMapSavePerson{name='小紅', age=18}
             
             key唯一
          */
     }
     
         /*
            hashMap存儲(chǔ)自定義類(lèi)型鍵值：
              key:String類(lèi)型
                String類(lèi)重寫(xiě)hashCode方法和equals方法，可以保證key唯一
             value:Person類(lèi)型
                value可以重復(fù)（同名同年齡視為重復(fù)）
          */
 ​
 ​
     public static void show01(){
 ​
         // 創(chuàng)造HashMap集合
         HashMap<String,Person> map = new HashMap<>();
         //往集合中添加元素
         map.put("深圳",new Person("小明",18));
         map.put("上海",new Person("小藍(lán)",18));
         map.put("北京",new Person("小紅",18));
         map.put("深圳",new Person("小綠",18));
         // 使用keySet()增強(qiáng)for遍歷map集合
         Set<String> set = map.keySet();
         for(String key:set){
             Person value = map.get(key);
             System.out.println(key+"-->"+value);
             // 因?yàn)樽址?lèi)（Java幫我們的）重寫(xiě)了hashCode方法和equals方法，所以鍵（key）是不能重復(fù)的
         }
         
     }
     
 }

 package Map;
 /*
     hashMap存儲(chǔ)自定義類(lèi)型鍵值：
     Map集合保證key是唯一的：
         作為key元素，必須重寫(xiě)hashMap方法和equals方法，以保證key唯一
  */
 ​
 import javax.swing.text.html.HTMLDocument;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 ​
 public class HashMapSavePerson {
     public static void main(String[] args) {
         
         show02();
     }
           /*
            hashMap存儲(chǔ)自定義類(lèi)型鍵值：
              key:Person類(lèi)型
                Person就必須類(lèi)重寫(xiě)hashCode方法和equals方法，來(lái)保證key唯一
             value:String類(lèi)型
                value可以重復(fù)（同名同年齡視為重復(fù)）
          */
 ​
     public static void show02(){
         // 創(chuàng)造HashMap集合
         HashMap<Person,String> map02 = new HashMap<>();
         // 往集合中添加元素
         map02.put(new Person("張三",18),"法外狂徒");
         map02.put(new Person("黃老板",18),"英國(guó)");
         map02.put(new Person("陳奕迅",18),"中國(guó)");
         map02.put(new Person("張三",18),"法外狂徒");
 ​
        // 使用迭代器遍歷set集合中的Entry對(duì)象
         Set<Map.Entry<Person,String>> set = map02.entrySet();
         Iterator<Map.Entry<Person,String>> it = set.iterator();
         while(it.hasNext()){
 ​
             Map.Entry<Person,String> entry = it.next();
 ​
             Person key = entry.getKey();
             String value = entry.getValue();
             System.out.println(key+"--->"+value);
         }
     }
 ​
 }

 package Map;
 ​
 import javax.swing.text.html.HTMLDocument;
 import java.util.*;
 ​
 public class Test {
     public static void main(String[] args) {
 ​
         HashMap<String,String> map = new LinkedHashMap<>();
         map.put("a","a");
         map.put("c","c");
         map.put("b","b");
         map.put("d","d");
         System.out.println(map);//{a=a, c=c, b=b, d=d}
     }
 }
 ​