Java基礎【七】 - List集合彙總

List接口特色

List 接口存儲一組容許重複，有序（插入順序）的對象，有下標，插入順序做爲遍歷的順序。

List接口的三個經常使用實現類

使用場景

一、對插入元素數據的速度要求不高，可是要求快速訪問元素數據，則使用ArrayList。
二、對訪問元素數據速度不作要求不高，可是對插入和刪除元素數據速度要求高的狀況，則使用LinkedList。
三、有多線程對集合元素進行操做時候，則使用Vector，可是如今通常再也不使用Vector，如需在多線程下使用，能夠用CopyOnWriteArrayList，在java.util.concurrent包下。
四、有需求是但願後保存的數據先讀取出來，則使用Stack；基於數組實現的，是棧，它繼承與Vector。

List轉數組方法

ArrayList<String> list=new ArrayList<String>();
String[] strings = new String[list.size()];
list.toArray(strings);

數組轉成List

String[] s = {"a","b","c"};
List list = java.util.Arrays.asList(s);

性能測試

/*
 * 性能測試，經過插入、隨機讀取和刪除對ArrayList、LinkedList、Vector和Stack進行測試！
 * 結論：看LinkedList
 *  插入10萬個元素，LinkedList所花時間最短：17 ms。
 *  刪除10萬個元素，LinkedList所花時間最短： 9 ms。
 *  遍歷10萬個元素，LinkedList所花時間最長：10255 ms；而ArrayList、Stack和Vector則相差很少，都只用了幾秒。
 *  (1) 對於須要快速插入，刪除元素，應該使用LinkedList。
 *  (2) 對於須要快速隨機訪問元素，應該使用ArrayList。
 * 
 */

public class ListTest {

    private static final int COUNT = 100000; //十萬

    private static ArrayList<Object> arrayList = new ArrayList<Object>();
    private static LinkedList<Object> linkedList = new LinkedList<Object>();
    private static Vector<Object> vector = new Vector<Object>();
    private static Stack<Object> stack = new Stack<Object>();

    public static void main(String[] args) {
        System.out.println("....開始測試插入元素..........");

        // 插入元素測試
        insertData(arrayList,"ArrayList") ;
        insertData(linkedList,"LinkedList") ;
        insertData(vector,"Vector") ;
        insertData(stack,"Stack") ;

        System.out.println("....開始測試讀取元素..........");

        // 隨機讀取元素測試
        readAccessData(arrayList,"ArrayList") ;
        readAccessData(linkedList,"LinkedList") ;
        readAccessData(vector,"Vector") ;
        readAccessData(stack,"Stack") ;

        System.out.println("....開始測試刪除元素..........");

        // 隨機讀取元素測試
        deleteData(arrayList,"ArrayList") ;
        deleteData(linkedList,"LinkedList") ;
        deleteData(vector,"Vector") ;
        deleteData(stack,"Stack") ;



    }


    /**
     * 指定的List 的子類中插入元素，並統計插入的時間
     * @param list List 的子類
     * @param name 子類的名稱
     */
    private static void insertData(List<Object> list,String name) {
        long startTime = System.currentTimeMillis();

        // 向list的位置0插入COUNT個數
        for (int i=0; i<COUNT; i++){
            list.add(0, i);
        }

        long endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println(name + " : 插入 "+COUNT+"元素， 使用的時間是 " + interval+" ms");
    }

    /**
     * 指定的List 的子類中刪除元素，並統計刪除的時間
     * @param list List 的子類
     * @param name 子類的名稱
     */
    private static void deleteData(List<Object> list,String name) {
        long startTime = System.currentTimeMillis();

        // 刪除list第一個位置元素
        for (int i=0; i<COUNT; i++)
            list.remove(0);

        long endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println(name + " : 刪除 "+COUNT+"元素， 使用的時間是 " + interval+" ms");
    }

    /**
     * 指定的List 的子類中讀取元素，並統計讀取的時間
     * @param list List 的子類
     * @param name 子類的名稱
     */
    private static void readAccessData(List<Object> list,String name) {
        long startTime = System.currentTimeMillis();

        // 讀取list元素
        for (int i = 0; i < COUNT; i++)
            list.get(i);

        long endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println(name + " : 隨機讀取 "+COUNT+"元素， 使用的時間是 " + interval+" ms");
    }
}

輸出結果：

....開始測試插入元素..........
ArrayList : 插入 100000元素， 使用的時間是 970 ms
LinkedList : 插入 100000元素， 使用的時間是 17 ms
Vector : 插入 100000元素， 使用的時間是 968 ms
Stack : 插入 100000元素， 使用的時間是 888 ms
....開始測試讀取元素..........
ArrayList : 隨機讀取 100000元素， 使用的時間是 6 ms
LinkedList : 隨機讀取 100000元素， 使用的時間是 10255 ms
Vector : 隨機讀取 100000元素， 使用的時間是 8 ms
Stack : 隨機讀取 100000元素， 使用的時間是 4 ms
....開始測試刪除元素..........
ArrayList : 刪除 100000元素， 使用的時間是 1460 ms
LinkedList : 刪除 100000元素， 使用的時間是 9 ms
Vector : 刪除 100000元素， 使用的時間是 1472 ms
Stack : 刪除 100000元素， 使用的時間是 894 ms

若是內容對你有幫助但願點贊收藏謝謝！！！