在分析之前，我們線看一下具體的ArrayList 和 LinkedList 源碼分析

其實(shí)看完源碼后，我們多多少少能得出如下的結(jié)論

線性存儲(chǔ)

1. 隨機(jī)訪問優(yōu)勢(shì)

 public E get(int index) {
        //檢查下標(biāo)是否符合
        rangeCheck(index);
         
        //直接通過下標(biāo)訪問，還有更快的么
        return elementData(index);
    }

2, 插入性能堪憂困難

刪除也會(huì)哦

    //添加數(shù)據(jù)操作
    public boolean add(E e) {
        //先執(zhí)行擴(kuò)容
        ensureCapacityInternal(size + 1); // Increments modCount!!
        //添加數(shù)據(jù)
        elementData[size++] = e;
        return true;
    }
    
    //確認(rèn)新的容量是否符合， 返回符合的容量
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

    //使用指定容量擴(kuò)容
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    } 
    
    //擴(kuò)容操作
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            //可以在這里看到，容量一旦不夠，就需要進(jìn)行擴(kuò)容，關(guān)鍵這個(gè)擴(kuò)容是需要，復(fù)制完整的原始數(shù)據(jù)
            grow(minCapacity);
    }
    
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

鏈?zhǔn)酱鎯?chǔ)

1.訪問元素困難

    //暴力遍歷查找，所以在大數(shù)據(jù)查找的時(shí)候簡(jiǎn)直是災(zāi)難
    Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

2. 毫無壓力的插入

沒有擴(kuò)容之后，操作看起來變得復(fù)雜，其實(shí)沒了拷貝之后，性能飛起

 public boolean addAll(int index, Collection<? extends E> c) {
        //檢查下標(biāo)參數(shù)
        checkPositionIndex(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;

        Node<E> pred, succ;
        if (index == size) {
            succ = null;
            pred = last;
        } else {
            succ = node(index);
            pred = succ.prev;
        }

        //重點(diǎn)在這里，創(chuàng)建鏈結(jié)構(gòu)
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }

        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }

        
        size += numNew;
        
        //記錄修改次數(shù)
        modCount++;
        return true;
    }

總結(jié)

上面這些實(shí)際上是都是在極度條件的下判斷出來的, 只有在幾百條數(shù)據(jù)的時(shí)候，并且沒有刪除數(shù)據(jù)，適合日志這種類型的，我個(gè)人還是建議使用 ArrrayList， 為什么 ？

• 真實(shí)存儲(chǔ)的是引用（4字節(jié)），創(chuàng)建數(shù)據(jù)存儲(chǔ)空間，和ArrayList，LinkedList 沒關(guān)系
• 在創(chuàng)建的時(shí)候，盡量給予相當(dāng)?shù)娜萘浚@樣ArrayList的性能能達(dá)到最佳的水平
• 這兩種數(shù)據(jù)結(jié)構(gòu)都不支持，并非修改， 支持并發(fā)訪問
• 頻繁的在插入數(shù)據(jù)，例如，排序, 刪除, 還是自覺使用鏈?zhǔn)酱鎯?chǔ)吧