淺談java集合

一.
算法介紹（棧、隊列、數組、鏈表、Hash、樹）
面試題要點：數據結構：存儲數據的方式 問題：常見數據結構的優缺點？
存儲要點和優缺點概述
棧：先進後出，畫圖存儲元素（A,B,C）（壓棧），並取出（彈棧），畫圖進行演示
隊列：先進先出，橫向隊列，存入取出，畫圖演示、
數組：查詢快，增刪慢(自己創建一個數組int[] arr = {11,13,45,67,34},

需求一：在45號元素後面增加一個元素23
需求二：刪除元素45
需求三：我要獲取45這個元素
鏈表：通過一個鏈子把多個結點（元素）連接起來，由數據和地址組成的一個元素，節點本身必須有一個地址值（就是下一個元素的地址值）
特點：查詢慢，增刪快
需求1：查詢元素45，需要一個一個從頭遍歷
需求2：刪除45這個元素，（1.保存45這個元素所保存的地址值 2.
斷開鏈子 3.將第一個步驟中取得到的地址值賦值給45的下一個元素））
分爲：單向鏈表：數據+下一個元素的地址
雙向鏈表 ：數據+下一個元素的地址+上一個元素的地址
單向循環鏈表 ：最後一個元素存儲的地址是第一個元素的地址值
雙向循環鏈表：存儲的是兩個地址，最後一個元素所存儲的兩個地址分別是上一個元素的地址和第一個元素的地址

hash:一般翻譯做“散列”，也有直接音譯爲“哈希”的，就是把任意長度的輸入（又叫做預映射， pre-image），通過散列算法，
變換成固定長度的輸出，該輸出就是散列值。這種轉換是一種壓縮映射，也就是，散列值的空間通常遠小於輸入的空間，
不同的輸入可能會散列成相同的輸出，所以不可能從散列值來唯一的確定輸入值。簡單的說就是一種將任意長度的信息壓縮到
某一固定長度的消息摘要的函數。（講解set集合的時候講解）

二叉樹：（講解set集合的時候講解）

三.集合概念
3.1
案例：寫一個學生數組，提出需求，根據需求分析數組和集合的區別
* 需求：存儲5個學生對象，並輸出學生對象的數據信息。
*
* 分析：
* A:定義學生類(name,age)
* B:定義學生數組，用於存儲學生對象
* C:創建學生對象，給學生對象的成員變量賦值
* D:把創建好的學生對象添加到數組中
* E:遍歷數組。

package com.edu_01;

public class Student {
    private String name;
    private int age;

    //無參構造有參構造
    public Student(){}
    public Student(String name,int age){
        this.age = age;
        this.name = name;
    }

    //set/get
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }

    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
}

package com.edu_01;

/**
 * 案例：寫一個學生數組，提出需求，根據需求分析數組和集合的區別 
 * 需求：存儲5個學生對象，並輸出學生對象的數據信息。
 * 
 * 需求2：郭德綱又收了一個徒弟，我們怎麼辦呢？
 * 分析：1.創建一個數組
 *     2.將以前的元素和新的一個元素全部添加到新的數組中
 * 
 * 分析：  1.創建學生數組 
 *      2.創建學生類
 *      3.創建學生對象 
 *      4.將學生對象存入數組 
 *      5.遍歷並輸出學生信息
 * 
 */
public class Test {
    public static void main(String[] args) {
        // 1.創建學生數組
        Student[] students = new Student[4];
        // 2.創建學生對象
        Student s = new Student("郭德綱", 40);
        Student s1 = new Student("于謙", 45);
        Student s2 = new Student("岳雲鵬", 30);
        Student s3 = new Student("孫越", 30);
        // 3.給數組元素賦值
        students[0] = s;
        students[1] = s1;
        students[2] = s2;
        students[3] = s3;
        //students[4] = "hellow";

        // 遍歷數組，並輸出學生信息
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i].getAge() + "--"
                    + students[i].getName());

        }

    }

}

集合和數組的區別：數組不適應變化的需求,所有Java就提供了集合類供我們使用
數組：
1.長度固定
2.可以存儲基本類型，也可以存儲引用類型
3.存儲元素類型一致
集合：
1.長度可變
2.只可以存儲引用類型
3.可以存儲多種類型

3.2
* 爲什麼出現集合類？
* 面嚮對象語言對事物的體現都是以對象的形式，所以爲了方便對多個對象的操作，我們就需要對這多個對象進行存儲。
* 而目前爲止我們學習過的可以存儲多個元素的東西是數組，但是呢，數組長度固定，不能適應變化的需求，所以，Java
* 就提供了集合類供我們使用。

四.
4.1
* Java提供了集合類供我們使用，而我們的需求可能是這樣的：
* 我要求我的元素是有序的，
* 我要求我的元素是無序的，
* 我要求我的元素是唯一的，
* 我要求我的元素是可以重複的。
* 爲了滿足不同的需求，Java就提供了不同的集合類。
* 而這些集合類由於數據結構不同，纔可以滿足這些條件的。
* 數據結構：存儲元素的方式。
* 而無論這些集合的結構是什麼樣子的，都是要裝水的，所以，他們應該有共性的內容。
* 通過不斷的向上提取，最終會形成一個集合的繼承體系圖。

4.2
java API 集合類圖介紹（主要看繼承關係，畫圖講解）
Collction體系結構圖
Collection
List
ArrayList
Vector
LinkedList
Set
HashSet
TreeSet

五.開發中常類介紹
String,Math,Scanner,List,ArrayList,等等

集合部分：
1.Collection
1.1
簡單介紹這個接口
是集合的頂層結構，定義了集合的共性功能。
可以存儲對象，這些對象也被稱爲元素。

package com.edu_02;

import java.util.ArrayList;
import java.util.Collection;

/**
 *  * 成員方法：(看到E我們先把它理解爲Object即可)
 *      A:添加功能
 *          boolean add(Object obj):往集合中添加一個元素
 *          boolean addAll(Collection c):往集合中添加多個元素
 *      B:刪除功能
 *          void clear():清空所有元素
 *          boolean remove(Object o):從集合中刪除一個元素
 *          boolean removeAll(Collection c):從集合中刪除另一個集合的元素
 *      C:判斷功能
 *          boolean contains(Object o):判斷集合中是否包含指定的元素
 *          boolean containsAll(Collection c):判斷集合中是否包含另一個集合的元素
 *          boolean isEmpty():判斷集合是否爲空。
 *      D:交集功能
 *          boolean retainAll(Collection c)
 *
 *
 *      G:集合轉數組
        Object[]toArray():把集合轉成數組，然後遍歷數組，
        其實就相當於遍歷了集合。(這個代碼我們練習一次，就可以忘)
 *
 */
public class CollectionDemo {
    public static void main(String[] args) {
        //創建collection這個接口的對象
        //Collection c = new Collection();-- 接口不能被實例化
        Collection c = new ArrayList();
        //給這個集合裏面存儲5個字符串元素
        String s = "hello";
        String s1 = "word";
        String s2 = "你好";
        String s3 = "世界";
        String s4 = "再見";
        //將元素添加到集合中
        //boolean add(Object obj):往集合中添加一個元素
        c.add(s);
        c.add(s1);
        c.add(s2);
        c.add(s3);
        c.add(s4);
        c.add(new Integer(100));//是將int類型的100轉換成引用類型的100，俗稱自動裝箱
        /*
        //boolean addAll(Collection c):往集合中添加多個元素
        //創建一個新的集合
        Collection c1 = new ArrayList();
        c1.add("haha");
        c1.add("hehe");
        //將新的這個集合添加到c這個集合中
        c.addAll(c1);
        */

        /*
        //void clear():清空所有元素
        c.clear();
        */

        /*
        //boolean remove(Object o):從集合中刪除一個元素
        //刪除成功地返回true,刪除失敗返回false
        boolean remove = c.remove("哈哈哈");
        System.out.println(remove);*/

        /*
        //boolean removeAll(Collection c):從集合中刪除另一個集合的元素
        Collection c1 = new ArrayList();
        c1.add("hello");
        c1.add("hehe");
        //將新的這個集合添加到c這個集合中
        //c.addAll(c1);
        boolean removeAll = c.removeAll(c1);
        //只要刪除集合裏面的一個元素就算刪除成功
        System.out.println(removeAll);*/

        /*
        //boolean contains(Object o):判斷集合中是否包含指定的元素
        boolean contains = c.contains("hello");
        System.out.println(contains);*/

        /*
        //boolean containsAll(Collection c):判斷集合中是否包含另一個集合的元素
        Collection c1 = new ArrayList();
        c1.add("hello");
        c1.add("word");
        boolean containsAll = c.containsAll(c1);
        System.out.println(containsAll);*/

        /*
        //boolean isEmpty():判斷集合是否爲空。
        c.clear();
        boolean empty = c.isEmpty();
        System.out.println(empty);*/


        //D:交集功能 boolean retainAll(Collection c)
        Collection c1 = new ArrayList();
        c1.add("hello");
        c1.add("hehe");
        boolean retainAll = c.retainAll(c1);
        //求出交集的元素，並刪除集合中沒有交集的元素
        System.out.println(retainAll);



        //遍歷這個集合
        //首先將集合轉換成數組
        Object[] objects = c.toArray();

        for (int i = 0; i < objects.length; i++) {
            Object object = objects[i];
            System.out.println(object);
        }

    }

}

1.2（學習方法）
* 成員方法：(看到E我們先把它理解爲Object即可)
* A:添加功能
* boolean add(Object obj):往集合中添加一個元素
* boolean addAll(Collection c):往集合中添加多個元素
* B:刪除功能
* void clear():清空所有元素
* boolean remove(Object o):從集合中刪除一個元素
* boolean removeAll(Collection c):從集合中刪除另一個集合的元素
* C:判斷功能
* boolean contains(Object o):判斷集合中是否包含指定的元素
* boolean containsAll(Collection c):判斷集合中是否包含另一個集合的元素
* boolean isEmpty():判斷集合是否爲空。
D:交集功能
* boolean retainAll(Collection c)
* E:迭代器(集合特有的遍歷方式)
* Iterator iterator()
重點：Iterator的使用
A:使用步驟
B:迭代器原理
* F:長度功能
* int size():返回集合中元素的個數
*
* 面試題：
* 數組有length()嗎?字符串有length()嗎?集合有length()嗎?
有 .length 有.length() 沒有，他有一個size()方法
G:集合轉數組
Object[]toArray():把集合轉成數組，然後遍歷數組，其實就相當於遍歷了集合。(這個代碼我們練習一次，就可以忘)

練習：
1.3
* 需求：往集合中添加三個字符串，並遍歷。
*
* 分析：
* A:創建集合對象
* B:創建字符串對象
* C:把字符串對象添加到集合對象中
* D:遍歷集合
*
* Object[] toArray():把集合轉成數組，然後遍歷數組，其實就相當於遍歷了集合。
*
* 練習：
* 在集合中存儲3個學生對象，並遍歷。

1.4
* 迭代器：（分別創建String對象，Student對象添加集合遍歷練習）
* Iterator iterator()
* Object next():返回迭代的下一個元素,並移動指向的位置
* boolean hasNext():判斷是否有元素
*
* NoSuchElementException:沒有這樣的元素異常。
* 原因是：你已經獲取到元素的末尾了，你還要繼續獲取元素，已經沒有了，所以就報錯了。
* 解決方案：你不要再拿了。我哪知道什麼就不拿了啊?怎麼辦呢?就應該在拿之前判斷一下是否有元素。
*
* 迭代器遍歷集合：
* 迭代器是依賴於集合而存在的。所以，要想得到迭代器對象，必須先有集合對象。
*
* 迭代步驟：
* A:通過集合對象獲取到迭代器對象
* B:通過迭代器對象的hasNext()方法判斷是否有元素
* C:通過迭代器對象的next()方法獲取元素

package com.edu_05;

public class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Student() {
        super();
        // TODO 自動生成的構造函數存根
    }
    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;
    }
}
package com.edu_05;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import com.edu_04.Student;

/**
 * 迭代器：作用：遍歷結合
 * 
 *    迭代器：（分別創建String對象，Student對象添加集合遍歷練習）
 *      Iterator iterator()
 *          Object next():返回迭代的下一個元素,並移動指向的位置
 *          boolean hasNext():判斷是否有元素
 * 
 *      NoSuchElementException:沒有這樣的元素異常。
 *          原因是：你已經獲取到元素的末尾了，你還要繼續獲取元素，已經沒有了，所以就報錯了。
 *          解決方案：你不要再拿了。我哪知道什麼就不拿了啊?怎麼辦呢?就應該在拿之前判斷一下是否有元素。
 * 
 *    迭代器遍歷集合：
 *      迭代器是依賴於集合而存在的。所以，要想得到迭代器對象，必須先有集合對象。
 * 
 *      迭代步驟：
 *          A:通過集合對象獲取到迭代器對象
 *          B:通過迭代器對象的hasNext()方法判斷是否有元素
 *          C:通過迭代器對象的next()方法獲取元素
 *  
 *
 */
public class StudentTest {
    public static void main(String[] args) {

        //將三個學生對象存儲到集合中
        Collection c = new ArrayList();
        c.add("hello");
        c.add("world");
        c.add("java");

        //咱們使用迭代器進行遍歷
        Iterator it = c.iterator();
        //用next()方法進行遍歷
//      System.out.println(it.next());
//      System.out.println(it.next());
//      System.out.println(it.next());
//      //java.util.NoSuchElementException，沒有你尋找的這個元素的異常
//      System.out.println(it.next());


        /*
        if (it.hasNext()) {
            System.out.println(it.next());
        }
        if (it.hasNext()) {
            System.out.println(it.next());
        }
        if (it.hasNext()) {
            System.out.println(it.next());
        }
        if (it.hasNext()) {
            System.out.println(it.next());
        }
        if (it.hasNext()) {
            System.out.println(it.next());
        }*/

        while (it.hasNext()) {
            System.out.println(it.next());
        }






    }

}

1.5
練習：創建狗對象（帶參數），存儲到集合，用迭代器進行遍歷並打印對象的屬性數據

//先創建狗這個類
package com.edu_06;

public class Dog {
    private String name;
    private int age;
    public Dog(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Dog() {
        super();
        // TODO 自動生成的構造函數存根
    }
    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;
    }
    public String toString() {
        return "Dog [name=" + name + ", age=" + age + "]";
    }

}
package com.edu_06;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class DogTest {
    public static void main(String[] args) {

        //創建狗對象
        Dog d = new Dog("大黃", 2);
        Dog d2 = new Dog("大白", 1);
        Dog d3 = new Dog("大黑", 3);

        //創建集合存儲狗的元素
        Collection c = new ArrayList();
        c.add(d);
        c.add(d2);
        c.add(d3);

        for (Object object : c) {
            Dog d4 = (Dog)object;
            System.out.println(d4.getAge()+"--"+d4.getName());
        }

        System.out.println("-----------------------");
        //運用迭代器進行遍歷
         Iterator it = c.iterator();
         while (it.hasNext()) {
            //System.out.println(it.next());
             Dog next = (Dog)it.next();
             System.out.println(next.getAge()+"--"+next.getName());
        }

    }

}

2.List
(1)List集合的元素有序(存儲和取出順序一致),元素可重複

(2)List的特有功能：
    A:添加功能
    void add(int index,Object obj):在指定的位置添加元素
    B:刪除功能
    Object remove(int index):通過指定的索引刪除元素，並把刪除的元素返回
    C:獲取功能
    get(int index) 返回列表中指定位置的元素。
    D:替換功能
    Object set(int index,Object obj)

(3)案例：
    A:List存儲字符串並遍歷(迭代器,普通for)
    B:List存儲自定義對象並遍歷(迭代器,普通for)
(4).List的倒序與洗牌
    List中元素順序可以被洗牌Collections.shuffle(list)
    List中元素順序可以被倒序Collections.reverse(list)
    Collections.sort(list)對List元素排序（字母數字分別進行測試）

案例練習：
* 需求：用List集合存儲3個汽車對象，然後遍歷。
*
* 汽車：Car
* 成員變量：String brand,int price,String color
* 構造方法：無參，帶參
* 成員方法：getXxx()/setXxx()
*
* 注意事項：
* A:忘寫main方法。
* B:導入包的問題，集合操作的時候，導入包基本上都是在java.util下
* C:大家針對我們的命名規範有些忘記了，需要回來再看一下
* 類，接口等名稱是首字母大寫
* 變量或者方法名首字母小寫

3.ArrayList
案例1：存儲字符串並遍歷
案例2：存儲自定義對象並遍歷
4.LinkedList
案例1：存儲字符串並遍歷
案例2：存儲自定義對象並遍歷
* LinkedList特有功能:
* public void addFirst(E e)
* public void addLast(E e)
*
* public E getFirst()
* public E getLast()
*
* public E removeFirst()
* public E removeLast()

package com.edu_07;

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

/**
 *  (2)List的特有功能：
        A:添加功能
        void add(int index,Object obj):在指定的位置添加元素
        B:刪除功能
        Object remove(int index):通過指定的索引刪除元素，並把刪除的元素返回
        C:獲取功能
        get(int index) 返回列表中指定位置的元素。
        D:替換功能
        Object set(int index,Object obj)
 *
 */
public class ListDemo {
    public static void main(String[] args) {
        //創建一個List集合
        List list = new ArrayList();
        //給list集合添加幾個字符串
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("java");

        /*
        //void add(int index,Object obj):在指定的位置添加元素
        //["hello","world","java"]
        list.add(1, "你好");//["hello","你好","world","java"]*/

        /*
        //Object remove(int index):通過指定的索引刪除元素，並把刪除的元素返回
        Object remove = list.remove(1);
        System.out.println(remove);*/

        /*
        //get(int index) 返回列表中指定位置的元素。
        Object object = list.get(1);
        System.out.println(object);*/

        /*
        //利用for循環遍歷集合
        //System.out.println(list.size());
        for(int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }*/

        //Object set(int index,Object obj)
        //list.set(1, "世界");

        for (Object object : list) {
            System.out.println(object);
        }


        System.out.println("-------------------------");
        //通過迭代器遍歷這個集合
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String next = (String)it.next();
            System.out.println(next);
        }

    }

}

8.ArrayList與LinkedList的相同點與不同點 （面試題**）
相同點：有順序的，元素可以重複
(1)ArrayList特點:
底層數據結構是數組,查詢快,增刪慢
線程不安全,效率高
(2)LinkedList特點:
底層數據結構是鏈表,查詢慢,增刪快
線程不安全,效率高

9.List的遍歷（掌握）
1.for（普通for）
2.Iterator(迭代器)
3.foreach（增強for）

package com.edu_10;

import java.util.ArrayList;
import java.util.List;

public class ArrayListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        //用法和之前學的相同
        list.add("hello");
        list.add("java");
        list.add("C++");

        //增強for循環，
        /**
         * foreach語句，一般用於集合的遍歷
         * 
         * 格式：for(遍歷出來的元素的數據類型    變量名：集合名){
         *          可以直接使用遍歷出來的對象
         * }
         * 
         */

        for (Object object : list) {
            System.out.println(object);
        }


    }

}

10.泛型入門
引入：
案例：創建集合存儲字符串，存儲integer類型數據，遍歷的時候強制轉換
與String數組進行對比，引入泛型

泛型(掌握)
(1)是一種把明確數據類型的工作推遲到創建對象或者調用方法的時候纔去明確類型的特殊類型
(2)格式：
<數據類型>
默認情況下，是Object類型。
這裏數據類型只能是引用類型。如果你看到寫基本類型也行，其實這裏使用了自動裝箱。
自動裝箱：比如講int類型通過創建對象形成Integer類型 例如：Integer IT = new Integer(100);
(3)好處：
A:把運行時期問題提前到了編譯時期
B:避免了強制類型轉換
C:優化程序設計，解決了黃色警告線問題
(4)在哪裏用?
一般來說就是在集合中用的多。
看API,如果類或者接口或者方法出現了<>說明這裏就有泛型。

拓展（有時間的話可以講一講，聽懂了解就可以）：
(5)泛型的概述(瞭解)
    A:泛型類（把泛型定義在類上）
    B:泛型方法（把泛型定義在方法上）
    C:泛型接口（泛型定義在接口上）
(6)泛型通配符（先不進行講解，後面會根據實例一一進行講解）
<?> 不確定類型
<? extends E> 向上限定，E及其子類
<? super E> 向下限定，E及及其父類

package com.edu_12;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
 * 
 * 泛型的好處：
 * 1.解決了黃色警告線的問題
 * 2.將運行時期的錯誤提前到了編譯時期，明確了數據類型
 * 3.避免了強制類型轉換的麻煩
 *
 */
public class GenericDemo {
    public static void main(String[] args) {
        //給List集合創建的時候加入泛型
        List<String> list = new ArrayList<String>();

        list.add("hello");
        list.add("你好");
        //list.add(100);//-- 就成功的將運行期的異常提前到了編譯時期

        //使用迭代器遍歷集合
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String string = it.next();
            System.out.println(string);
        }
    }

}

二十九章：集合3_Set
1.Set
1.1常用方法：直接查看api，裏面的方法我們基本都是學過的哦

2.HashSet（查詢api看說明進行講解）
2.1 元素順序：元素唯一，但是無序（它不保證 set 的迭代順序；特別是它不保證該順序恆久不變）
案例：創建一個HashSet集合，添加元素（String元素），測試唯一性，無序性

package com.edu_01;

import java.util.HashSet;

/**
 * HashSet集合特點：
 * 1.迭代元素無序，特別是不保證迭代順序不變
 * 2.無重複元素出現
 * 保證元素唯一性辦法
 * e.hash == hash&&((k = e.key) == key || e.equals(k))
 * e.hash == Hash.(HashCode())方法
 * (k = e.key) == key 比較的是地址值，如果地址值相同
 * 返回值爲true，則進行下面的比較
 * e.equals(k)方法比較兩者之間的內容是否相同
 * 當然，它默認比較的是地址值，重寫後可以比較內容
 * 重寫使用自動添加功能
 * 
 */
public class HashSetDemo {
public static void main(String[] args) {
    HashSet<String> hs1 = new HashSet<String>();
    hs1.add("hello");
    hs1.add("world");
    hs1.add("boy");
    for(String s : hs1){
        System.out.println(s);
    }
}
}

2.2如何保證元素的唯一性的呢（分析源碼）?
* 通過簡單的分析，我們知道HashSet集合保證元素的唯一性和add()方法相關。
* 如何我們想深入的瞭解，就必須看add()方法的源碼，看它的底層依賴什麼內容?
* if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {…}
*
* 左邊：e.hash == hash
* 比較對象的哈希值。
*
* 右邊：((k = e.key) == key || key.equals(k))
* 左邊：(k = e.key) == key
* 比較對象的地址值。
*
* 右邊：key.equals(k)
* 比較的是對象的內容是否相同。默認情況下比較的是地址值

    結論：
    底層數據結構是哈希表。
    哈希表依賴兩個方法：hashCode()和equals()


    執行流程：
        首先判斷哈希值是否相同,如果不同，就直接添加到集合。
        如果相同，繼續執行equals()，看其返回值，
        如果是false，就直接添加到集合。
        如果是true，說明元素重複不添加。


    使用：
        如果你看到哈希結構的集合，就要考慮可能需要重寫這兩個方法。
        如果真要重寫，自動生成即可。

    畫圖講解哈希表結構：是一個元素爲鏈表的數組結構

知識點demo演練：
1.存儲String類型的元素，說明元素無序且唯一
2.分析add()方法，保證唯一性的原理（底層依賴於hashCode()和equals()方法，保證了元素的唯一性）
3.存儲自定義對象，如何保證元素的唯一性？（存儲相同元素，發現無法保證元素的唯一性）

3.TreeSet（查看api，得出結論）
3.1 元素順序：使用元素的自然順序對元素進行排序，或者根據創建 set時提供的 Comparator進行排序，
具體取決於使用的構造方法。
3.2 底層算法：二叉樹（畫圖進行講解）
3.3 元素要求, 加入自定義JavaBean

package com.edu_03;

import java.util.Iterator;
import java.util.TreeSet;

/**
 * 1.創建集合存儲Integer類型的元素（20,18,23,22,17,24,19,18,24），
 * 分析如何保證元素唯一性，以及排序的規則。 二叉樹
 * 
 * TreeSet集合特點：
 * 1.保證元素的唯一性
 * 2.實現了元素的排序
 *
 *如何保證以上的特點？
 *基於二叉樹的數據結構。
 *
 */

public class TreeSetDemo {
public static void main(String[] args) {
    TreeSet<Integer> ts = new TreeSet<Integer>();
    ts.add(20);
    ts.add(18);
    ts.add(23);
    ts.add(22);
    ts.add(17);
    ts.add(24);
    ts.add(19);
    ts.add(18);
    ts.add(24);
    //兩種遍歷TreeSet()的方法
    Iterator it = ts.iterator();
    while(it.hasNext())
    {
        System.out.print(it.next() + "  ");
    }
    for(int i : ts)
    {
        System.out.println(i);
    }

}
}

案例演練：
1.創建集合存儲Integer類型的元素（20,18,23,22,17,24,19,18,24），分析如何保證元素唯一性，以及排序的規則。二叉樹
（首先講解二叉樹數據結構是怎麼存入元素的，根據compareTo()方法的返回值來確定要存入元素的安放位置）
2.存儲字符串並遍歷（字母a-z排序）
3.存入學生對象（姓名，年齡），1.按年齡排序，2.姓名排序（自然排序實現Comparable接口，並重寫comparaTo()方法）
4.創建set集合的時候，傳入Comparator（比較器排序）進行排序，進行排序（比較器排序）

//自然排序，實現Comparable接口，並且重寫comparaTo()方法
package com.edu_05;

import java.util.Comparator;

public class ComparatorImp implements Comparator<Student>{

    //comparaTo(Student s)這個方法如出一轍
    @Override
    public int compare(Student s1, Student s2) {
        /**
         * s1---this
         * s2---s
         * 需求：先按照年齡對學生對象進行排序？？如果學生的年齡相同，
         * 利用姓名對學生進行排序
         */
        //int num = s1.getAge() - s2.getAge(); 
        int num = s2.getAge() - s1.getAge(); 
        //如果年齡相同用姓名進行比較
        int num2 = num==0?s1.getName().compareTo(s2.getName()):num;

        return num2;
    }   
}
//創建學生類
package com.edu_05;

public class Student{
    private String name;
    private int age;
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Student() {
        super();
        // TODO 自動生成的構造函數存根
    }
    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;
    }


    //重寫toString()方法
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }


}
package com.edu_05;

import java.util.TreeSet;


/**
 * TreeSet集合利用比較器排序的方法對集合元素進行排序。 
 * TreeSet(Comparator comparator)
 * 我們目前所看到的這個構造方法，是需要一個Comparator這個接口的參數？
 * 但是我們能直接傳一個接口嗎？不能，因爲接口是不能被實例化，所以我們在這裏
 * 只能傳遞一個接口的實現類對象，讓這個接口的實現類，去實現接口中的
 * compare(Student s1,Student s2),在這個方法裏面我們需要
 * 書寫我們的排序邏輯
 * 
 * 
 */

public class Test {
    public static void main(String[] args) {
        // 創建一個擁有比較器對象的集合
        TreeSet<Student> ts = new TreeSet<Student>(new ComparatorImp());

        //創建學生對象
        Student s1 = new Student("aanbingbing",30);
        Student s2 = new Student("aanbingbing",20);
        Student s3 = new Student("cichen",40);
        Student s4 = new Student("eibingbing",35);
        Student s5 = new Student("fanwei",30);

        //將創建的學生對象存儲集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);

        //遍歷
        for (Student student : ts) {
            System.out.println(student);
        }

    }

}

4.Set的遍歷
4.1Iterator：
4.2foreach：

5.HashSet與TreeSet的相同點與不同點
相同點：
單列集合，元素不可重複
不同點
1. 底層存儲的數據結構不同
HashSet底層用的是HashMap哈希表結構存儲，而TreeSet底層用的是TreeMap樹結構存儲
2.存儲時保證數據唯一性依據不同
HashSet是通過複寫hashCode()方法和equals()方法來保證的，而TreeSet通過Compareable接口的compareTo()方法來保證的
3.有序性不一樣
HashSet無序，TreeSet有序
* 這種情況的數據，屬於一一對應的映射關係。這種關係的集合在java叫Map。
* Map：將鍵映射到值的對象。一個映射不能包含重複的鍵；每個鍵最多隻能映射到一個值。

• Map接口中的方法概述(創建集合測試方法)：
• A:刪除功能
• void clear():移除集合中的所有鍵值對元素
• V remove(Object key):根據鍵移除鍵值對元素，並返回值
• B:判斷功能
• boolean containsKey(Object key):判斷集合中是否包含指定的鍵
• boolean containsValue(Object value):判斷集合中是否包含指定的值
• boolean isEmpty():判斷集合是否爲空
• C:獲取功能
• Set

package com.edu_07;

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

/**
 * C:獲取功能 Set<Map.Entry<K,V>> entrySet()：獲取鍵值對對象的集合， 遍歷鍵值對對象，
 * 利用getKey(),getValue()取出鍵和值（理解即可）
 * 
 * V get(Object key):根據鍵獲取值 Set<K> keySet():獲取所有的鍵 Collection<V> values():獲取所有的值
 * 
 */
public class MapDemo2 {
    public static void main(String[] args) {
        // 創建map集合
        Map<String, String> map = new HashMap<String, String>();

        // 給集合添加元素
        map.put("it001", "周杰倫");
        map.put("it002", "羅玉鳳");
        map.put("it003", "如花");
        map.put("it004", "王力宏");

        // 遍歷,根據鍵拿到了集合的值
        System.out.println(map.get("it001"));
        System.out.println(map.get("it002"));
        System.out.println(map.get("it003"));
        System.out.println(map.get("it004"));

        System.out.println("------------------");

        /*//通過鍵找值，俗稱通過丈夫找妻子（必須掌握）
        // Set<K> keySet():獲取所有的鍵的set集合
        Set<String> keySet = map.keySet();
        for (String s : keySet) {
            // System.out.println(s);
            System.out.println("key:" + s + "--" + "value:" + map.get(s));
        }*/

    }

}

2.HashMap
2.1元素順序：元素順序不可預測
2.2底層算法：哈希算法
2.3對鍵沒有要求（僅僅相對於TreeMap來說）
知識點demo演練：
1.存入（String,String）主要講解遍歷方式，鍵：丈夫 值：妻子
2.存入（String,Student）鍵：String(國籍) 值：Student
3.存入（Student，String），鍵是同一個對象的時候要把之前存入的元素擠出去，想要實現這樣的效果的話，
需要重寫javabean裏面的hashCode()和equals()方法

package com.edu_08;

import java.util.HashMap;
import java.util.Set;

/**
 *   2.HashMap
     2.1元素順序：元素順序不可預測
     2.2底層算法：哈希算法
     2.3對鍵沒有要求(只是相對於TreeMap而言的)
 *
 *   HashMap:集合特點
 *   1.存入和取出順序不一致
 *
 */
public class HashMapDemo {
    public static void main(String[] args) {
        //創建集合對象
        HashMap<String, String> hm = new HashMap<String, String>();
        //給集合中添加元素
        hm.put("鄧超", "孫儷");
        hm.put("汪峯", "章子怡");
        hm.put("周杰倫", "昆凌");
        hm.put("習大大", "彭媽媽");


        //通過鍵找值的方法，遍歷這個集合
        //返回的是一個HashSet集合
        Set<String> keySet = hm.keySet();
        //通過遍歷鍵找值
        for (String key : keySet) { 
            System.out.println("key:"+key+"--"+"value:"+hm.get(key));
        }

    }

}

3.Treemap
3.1元素順序：元素順序與鍵的排序規則有關
3.2底層算法：Tree算法
3.
知識點demo演練：
1.存入（Integer,String），主要驗證排序方式
2.存入（Student，String），鍵：Student 值：地址

package com.edu_11;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/**
 * 3.Treemap
     3.1元素順序：元素順序與鍵的排序規則有關
     3.2底層算法：Tree算法
     3.3元素要求：對鍵有要求，要求鍵必須實現一定的排序規則

     知識點demo演練：
     1.存入（Integer,String），主要驗證排序方式
     2.存入（Student，String），鍵：Student   值：地址
 * @author Administrator
 *
 */
public class TreeSetDemo {
    public static void main(String[] args) {
        // 1.存入（Integer,String），主要驗證排序方式
        //創建集合
        TreeMap<Integer, String> tm = new TreeMap<Integer, String>();

        //給集合添加元素
        tm.put(1, "張學友");
        tm.put(3, "黎明");
        tm.put(2, "郭富城");
        tm.put(4, "劉德華");

        //遍歷集合
        //根據鍵取值,只需要掌握這種就行
        Set<Integer> keySet = tm.keySet();
        for (Integer key : keySet) {
            System.out.println("key:"+key+"--"+"value:"+tm.get(key));
        }

    }

}

4.遍歷（畫圖進行講解）
集合遍歷：1.獲取建的集合 2.遍歷鍵 3.根據鍵找值foreach()
1.foreach()：根據丈夫找妻子（根據鍵找值）
2.entrySet()：（Set