Java 從入門到進階之路（二十四）

在之前的文章我們介紹了一下 Java 中的  集合框架中的Collection 的泛型，本章我們來看一下 Java 集合框架中的Collection 的子介面 List。

Collection 介面有 3 種子型別，List、Set 和 Queue，其中 List 和 Set 的區別是 Set 中不能存放相同的元素，而 List 中可以，本章我們就來介紹一下 List。

 

 

 從上圖我們可以知道 List 有兩個例項類，ArrayList 和 LinkedList，

ArrayList 是陣列實現，查詢快，增上慢，由於是陣列實現，在增和刪的時候牽扯到陣列的增容，以及靠背元素，所以慢，陣列是可以直接按索引查詢，所以查詢時較快。

LinkedList 是連結串列實現，增刪快，查詢慢，由於連結串列實現，增加時只要讓前一個元素記住自己就可以了，刪除時讓前一個元素記住後一個元素，後一個元素記住前一個元素，這樣的增刪效率高但查詢時需要一個一個遍歷，所以效率低。

LinkedList 我們可以形象的比作老式手錶的鏈子，一節扣一節，增刪時只需要開啟兩個之間的節扣即可，不需要牽扯到其他節扣。

ArrayList 和 LinkedList 都有各自的優缺點，在用的時候可以根據需求自行選擇，避免效能消耗。在現在計算機計算能力越來越強，做的也不是大型專案的時候，這兩個之間的效能差異我們其實是可以忽略的。

接下來我們就來看一下 List 介面的一些基礎用法，如下：

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

/**
 * java.util.List
 * 可重複集合，並且有序
 * 特點是可以根據下表操作元素
 * ArrayList：使用陣列實現，查詢更快
 * LinkedList：使用連結串列實現，增刪更快（收尾增刪效果更明顯）
 */

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        /**
         * E set(int index, E e)
         * 將給定元素設定到制定位置上，返回原位置的元素
         * 所以是替換元素操作
         * 如果超出了元素的長度，則使用 add 新增，否則編譯錯誤
         * */
        String old = list.set(1, "2"); // 將下標為 1 的元素改為 2，返回值則是被替換的元素
        System.out.println(old); // two
        System.out.println(list); // [one, 2, three, four]

        /**
         * E get(int index)
         * 獲取給定下標對應的元素
         * */
        String two = list.get(1); // 獲取第二個元素
        System.out.println(two); // 2

        /**
         * 可以通過傳統的迴圈遍歷 List 集合
         * */
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i)); // one 2 three four
        }
    }
}

在上面的程式碼中，我們通過 set 和 get 方法來設定和獲取我們想要的下標的元素，當然還有其他方法，如下：

/**
 * List 集合提供了一對過載的 add，remove 方法
 * void add(int index, E e)
 * 將給定元素插入到指定位置，
 * 如果不指定下標，則插入到末尾
 * <p>
 * E remove(int index)
 * 從集合中刪除指定位置的元素，並將其返回
 */

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");

        list.add(1, "2"); // 將下標為 1 的元素插入 2
        System.out.println(list); // [one, 2, two, three, four]

        String string = list.remove(1); // 將下標為 1 的元素刪除，返回值為該元素
        System.out.println(string); // 2
        System.out.println(list); // [one, two, three, four]
    }
}

我們在將 Collection 的時候講過 add 和 remove 方法，在 List 中這兩個方法被過載了，可以根據需求插入和刪除想要刪除的下標的元素，那如果我們想要獲取兩個下標之間的元素和刪除兩個下標之間的元素該怎麼辦呢，如下：

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

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        System.out.println(list); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        List<Integer> subList = list.subList(2, 5); // 獲取下標從 2 到 5 的元素，含 2 不含 5
        System.out.println(subList); // [2, 3, 4]
        // 將 subList 中每個元素擴大 10 倍
        for (int i = 0; i < subList.size(); i++) {
            subList.set(i, subList.get(i) * 10);
        }
        System.out.println(subList); // [20, 30, 40]
        /**
         * 對子集的修改，就是修改原集合相應內容
         * */
        System.out.println(list); // [0, 1, 20, 30, 40, 5, 6, 7, 8, 9]
        /**
         * 刪除集合中 2-5 的元素
         * */
        list.subList(2, 5).clear();
        System.out.println(list); // [0, 1, 5, 6, 7, 8, 9]
    }
}

我們說集合和陣列有很多相似的地方，那課可以進行相互轉換呢，當然是可以的，如下：

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

public class Main {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<String>();
        collection.add("one");
        collection.add("two");
        collection.add("three");
        collection.add("four");
        System.out.println(collection); // [one, two, three, four]
        /**
         * 集合提供了一個 toArray，可以將當前集合轉換為陣列
         * */
        // Object[] array = collection.toArray(); // 不常用
        /**
         * collection.size() 表示要轉換的陣列的 length
         * 如果大於給定的 collection 的 size，則自動填充完整 array
         * 如果小於給定的 collection 的 size，則自動建立給你一樣長度的 size
         * */
        String[] array = collection.toArray(new String[collection.size()]);
        System.out.println(array.length); // 4
        for (String string : array) {
            System.out.println(string); // one two three four
        }

        String[] array1 = collection.toArray(new String[6]);
        System.out.println(array.length); // 4
        for (String string : array1) {
            System.out.println(string); // one two three four null null
        }

        String[] array2 = collection.toArray(new String[1]);
        System.out.println(array.length); // 4
        for (String string : array2) {
            System.out.println(string); // one two three four
        }
    }
}

在上面的程式碼中我們實現了集合轉換為陣列的方法，接下來我們再看一下陣列轉換為集合的方法：

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

/**
 * 陣列轉換為集合
 * 需要注意，轉換隻能轉換為 List 集合
 * 使用的是陣列的工具類 Arrays 的靜態方法 asList
 * 只能轉換為 List 集合的主要原因是：Set 不能存放重複元素
 * 所以若轉換為 Set 集合可能會出現丟失元素的情況
 */
public class Main {
    public static void main(String[] args) {
        String[] array = {"one", "two", "three", "four"};
        List<String> list = Arrays.asList(array);
        System.out.println(list); // [one, two, three, four]

        /**
         * 向集合中新增元素，會出現編譯錯誤
         * 相當於在原陣列新增元素
         * 該集合時由陣列轉換過來的，那麼該集合就表示原來的陣列
         * 所以對集合的操作就是對陣列的操作
         * 那麼新增元素會導致原陣列擴容
         * 那麼久不能表示原來的陣列了
         * 所以不允許向該集合新增元素
         */
        // list.add("five"); // 編譯錯誤 Exception in thread "main" java.lang.UnsupportedOperationException

        /**
         * 若希望增刪元素，需要另外建立一個集合
         * */
        /**
         * 所有的集合都提供了一個帶有 Collection 型別引數的構造方法
         * 該構造方法稱為：複製構造器
         * 作用是在建立當前集合的同時，
         * 集合中包含給定集合中的所有元素
         * */
        // List<String> list1 = new ArrayList<String>(list); // 複製構造器，一步到位
        List<String> list1 = new ArrayList<String>();
        list1.addAll(list);
        list1.add("five");
        System.out.println(list1); // [one, 2, three, four, five]

        /**
         * 修改集合元素，陣列元素也會改變
         * */
        list.set(1, "2");
        System.out.println(list); // [one, 2, three, four]
        for (String string : array) {
            System.out.println(string); // one 2 three four
        }
    }
}