Java集合 - 集合知識點總結概述

集合概述

---

• 概念：物件的容器，定義了對多個物件進項操作的的常用方法。可實現陣列的功能。

• 和陣列的區別：

1. 陣列長度固定，集合長度不固定。

2. 陣列可以儲存基本型別和引用型別，集合只能儲存引用型別。

• 位置： java.util.*;

 

Collection體系集合

---

Collection父介面

---

• 特點：代表一組任意型別的物件，無序、無下標、不能重複。

• 方法：

  • boolean add(Object obj) //新增一個物件。
  • boolean addAll(Collection c) //講一個集合中的所有物件新增到此集合中。
  • void clear() //清空此集合中的所有物件。
  • boolean contains(Object o) //檢查此集合中是否包含o物件。
  • boolean equals(Object o) //比較此集合是否與指定物件相等。
  • boolean isEmpty() //判斷此集合是否為空。
  • boolean remove(Object o) //在此集合中移除o物件。
  • int size() //返回此集合中的元素個數。
  • Object[] toArray() //姜此集合轉換成陣列。

/**
 * Collection介面的使用（一）
 * 1.新增元素
 * 2.刪除元素
 * 3.遍歷元素
 * 4.判斷
 */
public class Demo01 {
    public static void main(String[] args) {
        //建立集合
        Collection collection = new ArrayList();

//      * 1.新增元素
        collection.add("西瓜");
        collection.add("蘋果");
        collection.add("榴蓮");
        System.out.println(collection.size());
        System.out.println(collection.toString());

//      * 2.刪除元素
        collection.remove("西瓜");
        System.out.println("刪除之後："+collection.size());

//      * 3.遍歷元素
        //3.1 使用增強for
        for (Object object:collection) {
            String s = (String) object;
            System.out.println(s);
        }
        //3.2 使用迭代器（迭代器專門用來遍歷集合的一種方式）
        //hasnext();判斷是否有下一個元素
        //next();獲取下一個元素
        //remove();刪除當前元素
        Iterator it = collection.iterator();
        while (it.hasNext()){
            String s = (String) it.next();
            System.out.println(s);
            //刪除操作
            //collection.remove(s);引發錯誤：併發修改異常
            //iterator.remove();應使用迭代器的方法

//      * 4.判斷
            System.out.println(collection.contains("蘋果"));//true 是否存在蘋果
            System.out.println(collection.isEmpty());//false 是否有資料，沒有資料為true，有資料為false
        }
    }
}

/**
 * Collection介面的使用（二）
 * 1.新增元素
 * 2.刪除元素
 * 3.遍歷元素
 * 4.判斷
 */
public class Demo02 {
    public static void main(String[] args) {

        //建立Collection物件
        Collection collection = new ArrayList();

        //建立Student物件
        Student s1 = new Student("張三",18);
        Student s2 = new Student("李四",19);
        Student s3 = new Student("王五",20);

        //1.新增資料
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        //collection.add(s3);可重複新增相同物件
        System.out.println("元素個數為："+collection.size());
        System.out.println(collection.toString());

        //2.刪除資料
        collection.remove(s1);
        System.out.println("元素個數為："+collection.size());
        System.out.println(collection.toString());

        //3.遍歷資料
        //3.1 增強for迴圈
        for (Object object:collection) {
            Student s = (Student) object;
            System.out.println(object);
        }

        //3.2 迭代資料
        //迭代過程中不能使用Collection的刪除方法，即Collection.remove()
        Iterator it = collection.iterator();
        while (it.hasNext()){
            Student s = (Student) it.next();
            System.out.println(s);
            //刪除
            //it.remove();
        }

        //4判斷
        System.out.println(collection.contains("張三"));//false
        System.out.println(collection.contains(s2));//true
        System.out.println(collection.isEmpty());//false
    }
}

/**
 * 學生類
 */
public class Student {
    private String name;
    private int age;

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

    //無參構造
    public Student() {
    }

    //重寫toString
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //get/set靜態屬性
    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;
    }
}

 

Collection子介面

---

List集合

• 特點：有序、有下標、元素可以重複。

• 方法：

  • void add(int index,Object o) //在index位置插入物件o。
  • boolean addAll(index,Collection c) //將一個集合中的元素新增到此集合中的index位置。
  • Object get(int index) //返回集合中指定位置的元素。
  • List subList(int fromIndex,int toIndex) //返回fromIndex和toIndex之間的集合元素。

/**
 * List子介面的使用（一）
 * 特點：1.有序有下標 2.可以重複
 *
 * 1.新增元素
 * 2.刪除元素
 * 3.遍歷元素
 * 4.判斷
 * 5.獲取位置
 */
public class Demo03 {
    public static void main(String[] args) {

        //1.建立list集合物件
        List list = new ArrayList<>();

        //2.新增元素
        list.add("迪迦");
        list.add("艾斯");
        list.add(0,"賽文");//根據index下標插入資料
        System.out.println("元素個數為："+list.size());
        System.out.println(list.toString());

        //3.刪除資料
        list.remove(1);
        //list.remove("迪迦");意思同上，一個是根據角標，一個是根據內容
        System.out.println("刪除之後："+list.size());
        System.out.println(list.toString());

        //4.遍歷元素
        //4.1 因為有下標，所以可以使用for迴圈
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //4.2 使用增強for迴圈
        for (Object object:list) {
            String s = (String) object;
            System.out.println(s);
        }
        //4.3 使用迭代器
        Iterator it = list.iterator();
        while (it.hasNext()){
            String s = (String) it.next();
            System.out.println(s);
        }
        //4.4 使用列表迭代器
        ListIterator listIterator = list.listIterator();
        //從前往後遍歷
        while (listIterator.hasNext()){
            String s = (String) listIterator.next();
            System.out.println(s);
        }
        //從後往前遍歷(此時“遍歷指標”已經指向末尾了)
        while (listIterator.hasPrevious()){
            String s = (String) listIterator.previous();
            System.out.println(s);
        }

        //5.判斷
        System.out.println(list.contains("賽文"));//true
        System.out.println(list.isEmpty());//false

        //6.獲取位置
        System.out.println(list.indexOf("艾斯"));//1
    }
}

/**
 * List子介面的使用（二）
 * 1.新增元素
 * 2.刪除元素
 * 3.遍歷元素
 * 4.判斷
 * 5.獲取位置
 */
public class Demo04 {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        //1.新增基本型別數字資料（自動裝箱）
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(40);
        System.out.println("元素個數為："+list.size());
        System.out.println(list.toString());

        //2.刪除資料
        list.remove(0);//根據下標刪除
        //list.remove(40);下標越界
        list.remove(new Integer(40));//根據內容刪除，將基本型別轉成引用型別
        System.out.println("刪除後："+list.size());
        System.out.println(list.toString());

        //3.遍歷元素
        //3.1 使用for迴圈
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //3.2 使用增強for迴圈
        for (Object object:list) {
            int s = (int) object;
            System.out.println(s);
        }
        //3.3 使用迭代器
        Iterator it = list.iterator();
        while (it.hasNext()){
            int s = (int) it.next();
            System.out.println(s);
        }
        //3.4 使用列表迭代器
        ListIterator listIterator = list.listIterator();
        //從前往後遍歷
        while (listIterator.hasNext()){
            int s = (int) listIterator.next();
            System.out.println(s);
        }
        //從後往前遍歷(此時“遍歷指標”已經指向末尾了)
        while (listIterator.hasPrevious()){
            int s = (int) listIterator.previous();
            System.out.println(s);
        }

        //4.判斷
        System.out.println(list.contains(20));//true
        System.out.println(list.isEmpty());//false

        //5.獲取位置
        System.out.println(list.indexOf(30));//1

        //6.補充方法sublist,根據角標範圍，返回集合元素，含頭不含尾
        List list1 = list.subList(0,2);
        System.out.println(list1.toString());//20,30
    }
}

---

List實現類

ArrayList【重點】

• 陣列結構實現，查詢快、增刪慢；
• JDK1.2版本，執行效率快、執行緒不安全。

/**
 * ArrayList的使用
 * 儲存結構：陣列；
 * 特點：查詢遍歷速度快，增刪慢。
 * 1.新增元素
 * 2.刪除元素
 * 3.遍歷元素
 * 4.判斷
 * 5.查詢
 */
public class Demo05 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList<>();
        //1.新增元素
        Student s1 = new Student("鋼鐵俠",3);
        Student s2 = new Student("蜘蛛俠",4);
        Student s3 = new Student("蝙蝠俠",5);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s3);
        System.out.println("元素個數："+arrayList.size());
        System.out.println(arrayList.toString());

        //2.刪除元素
        arrayList.remove(s3);
        System.out.println("刪除後："+arrayList.size());
        System.out.println(arrayList.toString());
        //arrayList.remove(new Student("唐", 21));
        //注：這樣可以刪除嗎（不可以）？顯然這是兩個不同的物件。
        //假如兩個物件屬性相同便認為其是同一物件，那麼如何修改程式碼？

        //3.遍歷元素
        //3.1使用迭代器
        Iterator it = arrayList.iterator();
        while (it.hasNext()){
            Student s = (Student) it.next();
            System.out.println(s);
        }
        //3.2使用列表迭代器
        ListIterator listIterator = arrayList.listIterator();
        //從前往後遍歷
        while (listIterator.hasNext()){
            Student s = (Student) listIterator.next();
            System.out.println(s);
        }
        //從後往前遍歷
        while (listIterator.hasPrevious()){
            Student s = (Student) listIterator.previous();
            System.out.println(s);
        }

        //4.判斷
        System.out.println(arrayList.isEmpty());//false
        //System.out.println(arrayList.contains(new Student("鋼鐵俠", 3)));
        //注：與上文相同的問題。

        //5.查詢
        System.out.println(arrayList.indexOf(s1));
    }
}

注：Object裡的equals(this==obj)用地址和當前物件比較，如果想實現程式碼中的問題，可以在學生類中重寫equals方法：

    //重寫equls方法
    @Override
    public boolean equals(Object obj) {
        //1.是否為同一物件
        if (this == obj){
            return true;
        }
        //2.判斷是否為空
        if (obj == null){
            return false;
        }
        //3.判斷是否是Student型別
        if (this instanceof Student){
            Student s = (Student) obj;
            //4.比較屬性
            if (this.name.equals(s.getName())&&this.age==s.age){
                return true;
            }
        }
        return false;
    }

ArrayList原始碼分析：

• 預設容量大小：private static final int DEFAULT_CAPACITY = 10;

• 存放元素的陣列：transient Object[] elementData;

• 實際元素個數：private int size;

• 建立物件時呼叫的無參建構函式：

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//Arraylist無參構造方法
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

這段原始碼說明當你沒有向集合中新增任何元素時，集合容量為0。那麼預設的10個容量怎麼來的呢？這就得看看add方法的原始碼了：

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

假設你new了一個陣列，當前容量為0，size當然也為0。這時呼叫add方法進入到ensureCapacityInternal(size + 1);該方法原始碼如下：

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

由於一開始Arraylist的無參構造方法，就是將 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 賦值給了 elementData  ，所以if的條件是成立的。

if語句中 minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); 就是在 DEFAULT_CAPACITY 和 minCapacity 中返回一個最大的引數， DEFAULT_CAPACITY 是Arrarylist中一開始就定義的靜態常量，大小為10。 minCapacity 傳入的值為size+1也就是 1

DEFAULT_CAPACITY值大，因此返回DEFAULT_CAPACITY的值為10，這個值作為引數又傳入ensureExplicitCapacity()方法中，進入該方法檢視原始碼：

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

我們先不要管modCount這個變數，可以理解為這個變數是記錄陣列修改次數。

因為elementData陣列長度為0，minCapacity為10，所以if條件成立，呼叫grow方法，重要的部分來了，這個程式碼就是陣列擴容的程式碼，現在我們進入到grow方法的原始碼中：

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;　　//oldCapactity=0
        int newCapacity = oldCapacity + (oldCapacity >> 1);　　//oldCapacity=0；(oldCapacity >> 1)0右移一位還是0；因此newCapacity=0
        if (newCapacity - minCapacity < 0)  //0-10=-10,if條件成立
            newCapacity = minCapacity;　　　 //newCapacity=10
        if (newCapacity - MAX_ARRAY_SIZE > 0)  //MAX_ARRAY_SIZE這個值大家也可以進去看下，是好幾個億，這個條件基本上永遠不會成立。可以忽略不看，瞭解即可
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);　　//copyOf(elementData,newCapacity)建立一個新的陣列elementDate，陣列長度為newCapacity即就是10
    }

這個方法先宣告瞭一個oldCapacity變數將陣列長度賦給它，其值為0；又宣告瞭一個newCapacity變數其值為oldCapacity+一個增量，可以發現這個增量是和原陣列長度有關的量，當然在這裡也為0。第一個if條件滿足，newCapacity的值為10（這就是預設的容量，不理解的話再看看前面）。第二個if條件不成立，也可以不用注意，因為MAX_ARRAY_SIZE的定義如下：

這個值太大了以至於第二個if條件沒有了解的必要。

最後一句話就是為elementData陣列賦予了新的長度，Arrays.copyOf()方法返回的陣列是新的陣列物件，原陣列物件不會改變，該拷貝不會影響原來的陣列。copyOf()的第二個自變數指定要建立的新陣列長度，如果新陣列的長度超過原陣列的長度，則保留陣列預設值。

這時候再回到add的方法中，接著就向下執行elementData[size++] = e,將add傳入的值e賦值給陣列elementData，下標index為[size++]。到這裡為止關於ArrayList就講解得差不多了，當陣列長度為10的時候你們可以試著過一下原始碼，查一下每次的增量是多少（答案是每次擴容為原來的1.5倍）。

 

---

 Vector

• 陣列結構實現，查詢快、增刪慢；

• JDK1.0版本，執行效率慢、執行緒安全。

/**
 * Vector的演示使用
 *
 *1.新增資料
 *2.刪除資料
 *3.遍歷
 *4.判斷
 */
public class Demo01 {
    public static void main(String[] args) {
        //1.建立Vector物件
        Vector v = new Vector<>();

        //2.新增資料
        v.add("孫悟空");
        v.add("豬八戒");
        v.add("沙和尚");
        System.out.println("元素個數為："+v.size());
        System.out.println(v.toString());

        //3.刪除資料
        v.remove("沙和尚");
        //v.remove(2);效果同上
        System.out.println("刪除後："+v.size());
        System.out.println(v.toString());

        //4.遍歷
        //使用列舉
        Enumeration elements = v.elements();
        while (elements.hasMoreElements()){
            System.out.println(elements.nextElement());
        }

        //5.判斷
        System.out.println(v.isEmpty());
        System.out.println(v.contains("孫悟空"));
    }
}

 

---

LinkedList

• 連結串列結構實現，增刪快，查詢慢。

/**
 * LinkedList的用法
 * 儲存結構：雙向連結串列
 * 1.建立物件
 * 2.新增元素
 * 3.刪除元素
 * 4.遍歷
 * 5.判斷
 */
public class Demo01 {
    public static void main(String[] args) {
        //1.建立LinkedList物件
        LinkedList link = new LinkedList<>();

        //2.新增元素
        Student s1 = new Student("python",1);
        Student s2 = new Student("Java",2);
        Student s3 = new Student("go",3);
        link.add(s1);
        link.add(s2);
        link.add(s3);
        link.add(s3);
        System.out.println("元素個數為："+link.size());
        System.out.println(link.toString());

        //3.刪除元素
        link.remove(s3);
        link.remove(new Student("go",3));
        System.out.println("刪除後："+link.size());
        System.out.println(link.toString());

        //4.遍歷
        //4.1 使用for迴圈遍歷
        for (int i = 0; i < link.size(); i++) {
            System.out.println(link.get(i));
        }
        //4.2 使用增強for
        for (Object object:link) {
            Student s = (Student) object;
            System.out.println(s.toString());
        }
        //4.3 使用迭代器
        Iterator it = link.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4.4 使用列表迭代器
        ListIterator listIterator = link.listIterator();
        //從前往後遍歷
        while (listIterator.hasNext()){
            System.out.println(listIterator.next());
        }
        //從後往前遍歷
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }

        //5.判斷
        System.out.println(link.isEmpty());
        System.out.println(link.contains(s1));
        System.out.println(link.contains(new Student("Java",2)));
    }
}

 

LinkedList原始碼分析

LinkedList首先有三個屬性：

• 連結串列大小：transient int size = 0;
• （指向）第一個結點/頭結點： transient Node<E> first;
• （指向）最後一個結點/尾結點：transient Node<E> last;

關於Node型別我們再進入到類裡看看：

    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

首先item存放的是實際資料；next指向下一個結點而prev指向上一個結點。

Node帶參構造方法的三個引數分別是前一個結點、儲存的資料、後一個結點，呼叫這個構造方法時將它們賦值給當前物件。

LinkedList是如何新增元素的呢？先看看add方法：

    public boolean add(E e) {
        linkLast(e);
        return true;
    }

進入到linkLast方法：

    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

假設剛開始new了一個LinkedList物件，first和last屬性都為空，呼叫add進入到linkLast方法。

首先建立一個Node變數 l 將last（此時為空）賦給它，然後new一個newNode變數儲存資料，並且它的前驅指向l，後繼指向null；再把last指向newNode。如下圖所示：

如果滿足if條件，說明這是新增的第一個結點，將first指向newNode：

至此，LinkedList物件的第一個資料新增完畢。假設需要再新增一個資料，我們可以再來走一遍，過程同上不再贅述，圖示如下：

---

ArrayList和LinkedList區別

• ArrayList：必須開闢連續空間，查詢快，增刪慢。
• LinkedList：無需開闢連續空間，查詢慢，增刪快。

---

泛型概述

• Java泛型是JDK1.5中引入的一個新特性，其本質是引數化型別，把型別作為引數傳遞。
• 常見形式有泛型類、泛型介面、泛型方法。
• 語法：
  • <T,…> T稱為型別佔位符，表示一種引用型別。
• 好處：
  • 提高程式碼的重用性。
  • 防止型別轉換異常，提高程式碼的安全性。

泛型類

/**
 * 泛型類
 * 語法：類名<T>
 * T是型別佔位符，表示一種引用型別，編寫多個使用逗號隔開
 *
 */
public class MyGeneric<T> {
    //1.建立泛型變數
    //不能使用new來建立，因為泛型是不確定的型別，也可能擁有私密的構造方法
    T t;
    //2.泛型作為方法的引數
    public void show(T t){
        System.out.println(t);
    }

    //3.泛型作為方法的返回值
    public T getT(){
        return t;
    }
}

/**
 * 注意：
 * 1.泛型只能使用引用型別
 * 2.不同泛型型別的物件不能相互賦值
 */
public class TestGeneric {
    public static void main(String[] args) {
        //使用泛型類建立物件
        MyGeneric<String> stringMyGeneric = new MyGeneric<>();
        stringMyGeneric.t = "葫蘆娃";
        stringMyGeneric.show("火娃");

        MyGeneric<Integer> integerMyGeneric = new MyGeneric<>();
        integerMyGeneric.t=20;
        integerMyGeneric.show(30);
        Integer integer = integerMyGeneric.getT();
        System.out.println(integer);
    }
}

泛型介面

/**
 * 泛型介面
 * 語法：介面名<T>
 * 注意：不能建立泛型靜態常量
 */
public interface MyInterface<T> {
    //建立常量
    String nameString="金剛大芭比";

    //介面方法
    T server(T t);
}

/**
 * 實現介面時確定泛型類
 */
public class MyInterfaceImpl implements MyInterface<String> {

    @Override
    public String server(String s) {
        System.out.println(nameString);
        System.out.println(s);
        return s;
    }
}

//測試
public class Application {
    public static void main(String[] args) {
        MyInterfaceImpl myInterface = new MyInterfaceImpl();
        myInterface.server("xxx");
    }
}

/**
 * 實現介面時不確定泛型類
 */
public class MyInterfaceImpl2<T> implements MyInterface<T>{
    @Override
    public T server(T t) {
        System.out.println(nameString);
        System.out.println(t);
        return t;
    }
}

//測試
public class Application {
    public static void main(String[] args) {
        MyInterfaceImpl2<Integer> integerMyInterfaceImpl2 = new MyInterfaceImpl2<>();
        integerMyInterfaceImpl2.server(20);
    }
}

泛型方法

/**
 * 泛型方法
 * 語法：<T> 返回型別
 */
public class MyGenericMethod {
    public <T> void show(T t){
        System.out.println("泛型方法"+t);
    }
}

//測試
public class Application {
    public static void main(String[] args) {
        MyGenericMethod myGenericMethod = new MyGenericMethod();
        myGenericMethod.show("金剛");
        myGenericMethod.show(18);
    }
}

泛型集合

• 概念：引數化型別、型別安全的集合，強制集合元素的型別必須一致。
• 特點：
  • 編譯時即可檢查，而非執行時丟擲異常。
  • 訪問時，不必型別轉換（拆箱）。
  • 不同泛型指尖引用不能相互賦值，泛型不存在多型。

之前我們在建立LinkedList型別物件的時候並沒有使用泛型，但是進到它的原始碼中會發現：

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{//略

它是一個泛型類，而我之前使用的時候並沒有傳遞，說明java語法是允許的，這個時候傳遞的型別是Object類，雖然它是所有類的父類，可以儲存任意的型別，但是在遍歷、獲取元素時需要原來的型別就要進行強制轉換。這個時候就會出現一些問題，假如往連結串列裡儲存了許多不同型別的資料，在強轉的時候就要判斷每一個原來的型別，這樣就很容易出現錯誤。

---

Set集合概述

Set子介面

• 特點：無序、無下標、元素不可重複。
• 方法：全部繼承自Collection中的方法。

/**
 * 測試Set介面的使用
 * 特點：1.無序，沒有下標；2.重複
 * 1.新增資料
 * 2.刪除資料
 * 3.遍歷【重點】
 * 4.判斷
 */
public class Demo01 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        //1.新增資料
        set.add("火娃");
        set.add("金娃");
        set.add("木娃");
        set.add("水娃");
        //set.add("水娃");無法新增元素相同資料
        System.out.println("元素個數為："+set.size());
        System.out.println(set.toString());

        //2.刪除資料
        set.remove("水娃");
        System.out.println("刪除後："+set.size());
        System.out.println(set.toString());

        //3.遍歷
        //3.1 使用增強for迴圈
        for (String s:set) {
            System.out.println(s);
        }
        //3.2 使用迭代器
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //4. 判斷
        System.out.println(set.isEmpty());//false
        System.out.println(set.contains("火娃"));//true
    }
}

Set實現類

HashSet【重點】

• 基於HashCode計算元素存放位置。
• 當存入元素的雜湊碼相同時，會呼叫equals進行確認，如結果為true，則拒絕後者存入。

/**
 * 人類
 */
public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

/**
 * HashSet集合的使用
 * 儲存結構：雜湊表（陣列+連結串列+紅黑樹）
 * 1.新增元素
 * 2.刪除元素
 * 3.遍歷
 * 4.判斷
 */
public class Demo02 {
    public static void main(String[] args) {
        HashSet<Person> hashSet=new HashSet<>();
        Person p1=new Person("tang",21);
        Person p2=new Person("he", 22);
        Person p3=new Person("yu", 21);
        //1.新增元素
        hashSet.add(p1);
        hashSet.add(p2);
        hashSet.add(p3);
        //重複，新增失敗
        hashSet.add(p3);
        //直接new一個相同屬性的物件，依然會被新增，不難理解。
        //假如相同屬性便認為是同一個物件，怎麼修改？
        hashSet.add(new Person("yu", 21));
        System.out.println(hashSet.toString());
        //2.刪除元素
        hashSet.remove(p2);
        //3.遍歷
        //3.1 增強for
        for (Person person : hashSet) {
            System.out.println(person);
        }
        //3.2 迭代器
        Iterator<Person> iterator=hashSet.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        //4.判斷
        System.out.println(hashSet.isEmpty());
        //直接new一個相同屬性的物件結果輸出是false，不難理解。
        //注：假如相同屬性便認為是同一個物件，該怎麼做？
        System.out.println(hashSet.contains(new Person("tang", 21)));
    }
}

注：hashSet儲存過程：

1. 根據hashCode計算儲存的位置，如果位置為空，則直接儲存，否則執行第二步。
2. 執行equals方法，如果方法返回true，則認為是重複，拒絕儲存，否則形成連結串列。

儲存過程實際上就是重複依據，要實現“注”裡的問題，可以重寫hashCode和equals程式碼：

@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
}
@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Person other = (Person) obj;
    if (age != other.age)
        return false;
    if (name == null) {
        if (other.name != null)
            return false;
    } else if (!name.equals(other.name))
        return false;
    return true;
}

 

hashCode方法裡為什麼要使用31這個數字大概有兩個原因：

1. 31是一個質數，這樣的數字在計算時可以儘量減少雜湊衝突。
2. 可以提高執行效率，因為31*i=(i<<5)-i，31乘以一個數可以轉換成移位操作，這樣能快一點；但是也有網上一些人對這兩點提出質疑。

---

TreeSet

• 基於排序順序實現不重複。
• 實現了SortedSet介面，對集合元素自動排序。
• 元素物件的型別必須實現Comparable介面，指定排序規則。
• 通過CompareTo方法確定是否為重複元素。

/**
 * 使用TreeSet儲存資料
 * 儲存結構：紅黑樹
 * 要求：元素類必須實現Comparable介面，compareTo方法返回0，認為是重複元素
 */
public class Demo01 {
    public static void main(String[] args) {

        TreeSet<Person> treeSet = new TreeSet<>();

        Person p1 = new Person("it",12);
        Person p2 = new Person("he",12);
        Person p3 = new Person("she",12);

        //1.新增元素
        treeSet.add(p1);
        treeSet.add(p2);
        treeSet.add(p3);
        treeSet.add(p3);//相同無法新增
        //注：直接新增會報型別錯誤，需要實現Comparable介面
        System.out.println("元素個數為："+treeSet.size());
        System.out.println(treeSet.toString());

        //2.刪除元素
        treeSet.remove(p3);
        treeSet.remove(new Person("she",12));
        System.out.println(treeSet.toString());

        //3.遍歷
        //3.1 增強for迴圈
        for (Person person:treeSet) {
            System.out.println(person);
        }
        //3.2 迭代器
        Iterator<Person> iterator = treeSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        
        //4.判斷
        System.out.println(treeSet.contains(new Person("it",12)));
    }
}

 執行報錯，因為treeset是紅黑樹，當前程式碼沒有定義比較的屬性，需要重寫Comparable方法

先檢視Comparable介面的原始碼，發現只有一個compareTo抽象方法，在Person類中實現它：

public class Person implements Comparable<Person> {
    @Override
    public int compareTo(Person o) {
        int n1 = this.getName().compareTo(o.getName());//名字相同，返回0，不同返回其他數字
        int n2 = this.getAge()-o.getAge();//比較年齡
        return n1==0?n2:n1;//名字相同，返回n2，名字不同，返回n1
    }
}

再次執行TreeSet的Demo01，執行成功

除了實現Comparable介面裡的比較方法，還有另外一種方法，TreeSet也提供了一個帶比較器Comparator的構造方法，使用匿名內部類來實現它：

/**
 * TreeSet的使用
 * Comparator：實現定製比較（比較器）
 */
public class Demo02 {
    public static void main(String[] args) {
        TreeSet<Person> person = new TreeSet<Person>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                // 先按年齡比較
                // 再按姓名比較
                int n1=o1.getAge()-o2.getAge();
                int n2=o1.getName().compareTo(o2.getName());
                return n1==0?n2:n1;
            }
        });
        Person p1 = new Person("it",12);
        Person p2 = new Person("he",12);
        Person p3 = new Person("she",12);

        //1.新增元素
        person.add(p1);
        person.add(p2);
        person.add(p3);
        //注：直接新增會報型別錯誤，需要實現Comparable介面
        System.out.println("元素個數為："+person.size());
        System.out.println(person.toString());
    }
}

接下來我們來做一個小案例：

/**
 * 要求：使用TreeSet集合實現字串按照長度進行排序
 * helloworld tangrui hechengyang wangzixu yuguoming
 * Comparator介面實現定製比較
 */
public class Demo03 {
    public static void main(String[] args) {
        TreeSet<String> s = new TreeSet<>(new Comparator<String>() {
            @Override
            //1.先比較長度
            //2.在比較字串
            public int compare(String o1, String o2) {
                int n1 = o1.length()-o2.length();
                int n2 = o1.compareTo(o2);
                return n1==0?n2:n1;
            }
        });
        s.add("hello world");
        s.add("hello Java");
        s.add("hello Python");
        System.out.println(s.toString());
    }
}

 

 

---

Map體系集合

• Map介面的特點：

  1. 用於儲存任意鍵值對(Key-Value)。
  2. 鍵：無序、無下標、不允許重複（唯一）。
  3. 值：無序、無下標、允許重複。
  

---

Map集合概述

• 特點：儲存一對資料（Key-Value），無序、無下標，鍵不可重複。

• 方法：

  • V put(K key,V value)//將物件存入到集合中，關聯鍵值。key重複則覆蓋原值。

• Object get(Object key)//根據鍵獲取相應的值。

  • Set<K>//返回所有的key
  • Collection<V> values()//返回包含所有值的Collection集合。
  • Set<Map.Entry<K,V>>//鍵值匹配的set集合

/**
 * Map介面的使用
 * 特點：1.儲存鍵值對 2.鍵不能重複，值可以重複 3.無序
 */
public class Demo01 {
    public static void main(String[] args) {
        //建立Map集合
        HashMap<String, String> map = new HashMap<>();

        //1.新增元素
        map.put("cn","中國");
        map.put("uk","英國");
        map.put("usa","美國");
        map.put("cn","Chinse");//相同key新增，會替換之前的value值
        System.out.println("元素個數為："+map.size());
        System.out.println(map.toString());

        //2.刪除
        map.remove("usa");
        System.out.println("刪除後元素個數為："+map.size());
        System.out.println(map.toString());

        //3.遍歷
        //3.1 使用keyset(),先獲取key，再使用get(key)方法獲取value值
        Set<String> keySet = map.keySet();
        for (String key:keySet) {
            System.out.println(key+"-----"+map.get(key));
        }
        //簡寫
        for (String s:map.keySet()) {
            System.out.println(s+"-----"+map.get(s));
        }
        //3.2 使用entrySet()方法;效率更高，把key和value都拿出來了，不需要為了value再去多做一遍查詢key的操作
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String,String> entry:entries) {
            System.out.println(entry.getKey()+"------"+entry.getValue());
        }
        //簡寫
        for (Map.Entry<String,String> entry:map.entrySet()) {
            System.out.println(entry.getKey()+"------"+entry.getValue());
        }


    }
}

keySet遍歷和entrySet的區別

 

---

Map集合的實現類

HashMap【重點】

• JDK1.2版本，執行緒不安全，執行效率快；允許用null作為key或是value。

/**
 * 學生類
 */
public class Student {
    private String name;
    private int 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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

/**
 * HashMap的使用
 * 儲存結構：雜湊表（陣列+連結串列+紅黑樹）
 */
public class Demo01 {
    public static void main(String[] args) {
        HashMap<Student, String> hashMap = new HashMap<>();
        Student p1 = new Student("趙一",11);
        Student p2 = new Student("王二",11);
        Student p3 = new Student("張三",11);
        Student p4 = new Student("李四",11);
        //1.新增元素
        hashMap.put(p1,"北京");
        hashMap.put(p2,"上海");
        hashMap.put(p3,"廣州");
        hashMap.put(p4,"曹縣");
        hashMap.put(p4,"曹縣(山東)");//不能新增重複的key，但是會將value更新

        //?，上面已經有一個李四的key了，通過這個還可以繼續新增，那能不能讓系統根據key的資料判重，而不是根據記憶體地址？
        hashMap.put(new Student("李四",11),"南京");
        System.out.println("元素個數為："+hashMap.size());
        System.out.println(hashMap.toString());

        //2.刪除元素
        hashMap.remove(p2);
        System.out.println(hashMap.toString());

        //3.遍歷
        //3.1 使用keySet遍歷
        for (Student s:hashMap.keySet()) {
            System.out.println(s+"------"+hashMap.get(s));
        }
        //3.2 使用entrySet遍歷
        for (Map.Entry<Student,String> entry:hashMap.entrySet()) {
            System.out.println(entry.getKey()+"------"+entry.getValue());
        }

        //4.判斷
        System.out.println(hashMap.containsKey(p1));
        System.out.println(hashMap.containsKey(new Student("李四",11)));
        System.out.println(hashMap.containsValue("曹縣(山東)"));
    }
}

 

• 注：和之前說過的HashSet類似，重複依據是hashCode和equals方法，重寫即可：

@Override
  public int hashCode() {
      final int prime = 31;
      int result = 1;
      result = prime * result + id;
      result = prime * result + ((name == null) ? 0 : name.hashCode());
      return result;
  }
  @Override
  public boolean equals(Object obj) {
      if (this == obj)
          return true;
      if (obj == null)
          return false;
      if (getClass() != obj.getClass())
          return false;
      Student other = (Student) obj;
      if (id != other.id)
          return false;
      if (name == null) {
          if (other.name != null)
              return false;
      } else if (!name.equals(other.name))
          return false;
      return true;
  }

 

HashMap原始碼分析

• 預設初始化容量：static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

  • 陣列最大容量：static final int MAXIMUM_CAPACITY = 1 << 30;

• 預設載入因子：static final float DEFAULT_LOAD_FACTOR = 0.75f;

• 連結串列調整為紅黑樹的連結串列長度閾值（JDK1.8）：static final int TREEIFY_THRESHOLD = 8;

• 紅黑樹調整為連結串列的連結串列長度閾值（JDK1.8）：static final int UNTREEIFY_THRESHOLD = 6;

• 連結串列調整為紅黑樹的陣列最小閾值（JDK1.8）：static final int MIN_TREEIFY_CAPACITY = 64;

• HashMap儲存的陣列：transient Node<K,V>[] table;

• HashMap儲存的元素個數：transient int size;

• 預設載入因子是什麼？
  • 就是判斷陣列是否擴容的一個因子。假如陣列容量為100，如果HashMap的儲存元素個數超過了100*0.75=75，那麼就會進行擴容。
• 連結串列調整為紅黑樹的連結串列長度閾值是什麼？
  • 假設在陣列中下標為3的位置已經儲存了資料，當新增資料時通過雜湊碼得到的儲存位置又是3，那麼就會在該位置形成一個連結串列，當連結串列過長時就會轉換成紅黑樹以提高執行效率，這個閾值就是連結串列轉換成紅黑樹的最短連結串列長度；
• 紅黑樹調整為連結串列的連結串列長度閾值是什麼？
  • 當紅黑樹的元素個數小於該閾值時就會轉換成連結串列。
• 連結串列調整為紅黑樹的陣列最小閾值是什麼？
  • 並不是只要連結串列長度大於8就可以轉換成紅黑樹，在前者條件成立的情況下，陣列的容量必須大於等於64才會進行轉換。

HashMap的陣列table儲存的就是一個個的Node<K,V>型別，很清晰地看到有一對鍵值，還有一個指向next的指標（以下只擷取了部分原始碼）：

static class Node<K,V> implements Map.Entry<K,V> {
      final K key;
      V value;
      Node<K,V> next;
  }

之前的程式碼中在new物件時呼叫的是HashMap的無參構造方法，進入到該構造方法的原始碼檢視一下：

public HashMap() {
      this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
  }

發現沒什麼內容，只是賦值了一個預設載入因子；而在上文我們觀察到原始碼中table和size都沒有賦予初始值，說明剛建立的HashMap物件沒有分配容量，並不擁有預設的16個空間大小，這樣做的目的是為了節約空間，此時table為null，size為0。

當我們往物件裡新增元素時呼叫put方法：

public V put(K key, V value) {
      return putVal(hash(key), key, value, false, true);
  }

put方法把key和value傳給了putVal，同時還傳入了一個hash(Key)所返回的值，這是一個產生雜湊值的方法，再進入到putVal方法（部分原始碼）：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                    boolean evict) {
      Node<K,V>[] tab; Node<K,V> p; int n, i;
      if ((tab = table) == null || (n = tab.length) == 0)
          n = (tab = resize()).length;
      if ((p = tab[i = (n - 1) & hash]) == null)
          tab[i] = newNode(hash, key, value, null);
      else{
          //略
      }
  }

這裡面建立了一個tab陣列和一個Node變數p，第一個if實際是判斷table是否為空，而我們現在只關注剛建立HashMap物件時的狀態，此時tab和table都為空，滿足條件，執行內部程式碼，這條程式碼其實就是把resize()所返回的結果賦給tab，n就是tab的長度，resize顧名思義就是重新調整大小。檢視resize()原始碼（部分）：

final Node<K,V>[] resize() {
      Node<K,V>[] oldTab = table;
      int oldCap = (oldTab == null) ? 0 : oldTab.length;
      int oldThr = threshold;
      if (oldCap > 0);
      else if (oldThr > 0);
      else {               // zero initial threshold signifies using defaults
          newCap = DEFAULT_INITIAL_CAPACITY;
          newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
      } 
      @SuppressWarnings({"rawtypes","unchecked"})
      Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
      table = newTab;
      return newTab;
  }

該方法首先把table及其長度賦值給oldTab和oldCap；threshold是閾值的意思，此時為0，所以前兩個if先不管，最後else裡newCap的值為預設初始化容量16；往下建立了一個newCap大小的陣列並將其賦給了table，剛建立的HashMap物件就在這裡獲得了初始容量。然後我們再回到putVal方法，第二個if就是根據雜湊碼得到的tab中的一個位置是否為空，為空便直接新增元素，此時陣列中無元素所以直接新增。至此HashMap物件就完成了第一個元素的新增。當新增的元素超過16*0.75=12時，就會進行擴容：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict){
      if (++size > threshold)
          resize();
  }

擴容的程式碼如下（部分）：

final Node<K,V>[] resize() {
      int oldCap = (oldTab == null) ? 0 : oldTab.length;
      int newCap;
      if (oldCap > 0) {
          if (oldCap >= MAXIMUM_CAPACITY) {//略}
          else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                   oldCap >= DEFAULT_INITIAL_CAPACITY)
      }
  }

核心部分是else if裡的移位操作，也就是說每次擴容都是原來大小的兩倍。

• *注**：額外說明的一點是在JDK1.8以前連結串列是頭插入，JDK1.8以後連結串列是尾插入。

---

HashSet原始碼分析

瞭解完HashMap之後，再回過頭來看之前的HashSet原始碼，為什麼放在後面寫你們看一下原始碼就知道了（部分）：

public class HashSet<E>
      extends AbstractSet<E>
      implements Set<E>, Cloneable, java.io.Serializable
  {
      private transient HashMap<E,Object> map;
      private static final Object PRESENT = new Object();
      public HashSet() {
          map = new HashMap<>();
      }
  }

可以看見HashSet的儲存結構就是HashMap，那它的儲存方式是怎樣的呢？可以看一下add方法：

public boolean add(E e) {
      return map.put(e, PRESENT)==null;
  }

很明瞭地發現它的add方法呼叫的就是map的put方法，把元素作為map的key傳進去的。。

Hashtable

• JDK1.0版本，執行緒安全，執行效率慢；不允許null作為key或是value。

• 初始容量11，載入因子0.75。

  這個集合在開發過程中已經不用了，稍微瞭解即可。

Properties

• Hashtable的子類，要求key和value都是String。通常用於配置檔案的讀取。

它繼承了Hashtable的方法，與流關係密切，此處不詳解。

TreeMap

• 實現了SortedMap介面（是Map的子介面），可以對key自動排序。

/**
 * TreeMap的使用
 * 儲存結構：紅黑樹
 */
public class Demo3 {
    public static void main(String[] args) {
        TreeMap<Student, Integer> treeMap=new TreeMap<Student, Integer>();
        Student s1=new Student("tang", 36);
        Student s2=new Student("yu", 101);
        Student s3=new Student("he", 10);
        //1.新增元素
        treeMap.put(s1, 21);
        treeMap.put(s2, 22);
        treeMap.put(s3, 21);
        //不能直接列印，需要實現Comparable介面，因為紅黑樹需要比較大小
        System.out.println(treeMap.toString());
        //2.刪除元素
        treeMap.remove(new Student("he", 10));
        System.out.println(treeMap.toString());
        //3.遍歷
        //3.1 使用keySet()
        for (Student key : treeMap.keySet()) {
            System.out.println(key+" "+treeMap.get(key));
        }
        //3.2 使用entrySet()
        for (Entry<Student, Integer> entry : treeMap.entrySet()) {
            System.out.println(entry.getKey()+" "+entry.getValue());
        }
        //4.判斷
        System.out.println(treeMap.containsKey(s1));
        System.out.println(treeMap.isEmpty());        
    }
}

在學生類中實現Comparable介面：

public class Student implements Comparable<Student>{
    @Override
    public int compareTo(Student o) {
        int n1=this.id-o.id;
        return n1;
}

除此之外還可以使用比較器來定製比較：

TreeMap<Student, Integer> treeMap2=new TreeMap<Student, Integer>(new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        // 略
        return 0;
    }            
});

 

TreeSet原始碼

和HashSet類似，放在TreeMap之後講便一目瞭然（部分）：

public class TreeSet<E> extends AbstractSet<E>
    implements NavigableSet<E>, Cloneable, java.io.Serializable
{
    private transient NavigableMap<E,Object> m;
    private static final Object PRESENT = new Object();
    TreeSet(NavigableMap<E,Object> m) {
        this.m = m;
    }
    public TreeSet() {
        this(new TreeMap<E,Object>());
    }
}

TreeSet的儲存結構實際上就是TreeMap，再來看其儲存方式：

public boolean add(E e) {
    return m.put(e, PRESENT)==null;
}

它的add方法呼叫的就是TreeMap的put方法，將元素作為key傳入到儲存結構中。

---

Collections工具類

• 概念：集合工具類，定義了除了存取以外的集合常用方法。

• 方法：

  • public static void reverse(List<?> list)//反轉集合中元素的順序
  • public static void shuffle(List<?> list)//隨機重置集合元素的順序
  • public static void sort(List<T> list)//升序排序（元素型別必須實現Comparable介面）

/**
 * 演示Collections工具類的使用
 *
 */
public class Demo4 {
    public static void main(String[] args) {
        List<Integer> list=new ArrayList<Integer>();
        list.add(20);
        list.add(10);
        list.add(30);
        list.add(90);
        list.add(70);
        
        //sort排序
        System.out.println(list.toString());
        Collections.sort(list);
        System.out.println(list.toString());
        System.out.println("---------");
        
        //binarySearch二分查詢
        int i=Collections.binarySearch(list, 10);
        System.out.println(i);
        
        //copy複製
        List<Integer> list2=new ArrayList<Integer>();
        for(int i1=0;i1<5;++i1) {
            list2.add(0);
        }
        //該方法要求目標元素容量大於等於源目標
        Collections.copy(list2, list);
        System.out.println(list2.toString());
        
        //reserve反轉
        Collections.reverse(list2);
        System.out.println(list2.toString());
        
        //shuffle 打亂
        Collections.shuffle(list2);
        System.out.println(list2.toString());
        
        //補充：list轉成陣列
        Integer[] arr=list.toArray(new Integer[0]);
        System.out.println(arr.length);
        //補充：陣列轉成集合 
        String[] nameStrings= {"tang","he","yu"};
        //受限集合，不能新增和刪除
        List<String> list3=Arrays.asList(nameStrings);
        System.out.println(list3);
        
        //注：基本型別轉成集合時需要修改為包裝類
    }
}