ArrayList 和 LinkedList 的比较

1.集合框架

---

关于ArrayList 如图：

关于LinkedList 如图：

我们可以从两个图中看到，两个类都继承了List 接口，主要不一样表现在 其ArrayList 主要是基于顺序表的实现 而 LinkedList 基于链表的实现。

---

2.查找的共同点

---

  首先从时间复杂度和空间复杂度分析，在查找中ArrayList 的时间复杂度为O(n)，空间复杂度为O（1）。而LinkedList的时间复杂度也为O(n)，空间复杂度也为O(1)。

如ArrayList 查找的代码：

 public int indexOf(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if(elem[i] == toFind) {
                return i;
            }
        }
        return -1;
    }

如LinkedList 查找的代码：

 private ListNode searchPrevIndex(int index) {
        ListNode cur = head;
        int count = 0;
        while (count != index-1) {
            cur = cur.next;
            count++;
        }
        return cur;
    }

从代码中我们可以看到，查找一个数，都是把自己遍历一遍，然后找到，两者基本相似，只是语法不一样。

---

3.新增和删除的区别

---

（1）新增：

对于ArrayList 在新增的时候，需要考虑扩容问题，实现的其实就是一个动态数组，

而对于LinkedList 在新增的时候只需要改变节点的引用就可以，相对ArrayList 比较好。

如ArrayList 的代码：

 public void add(int data) {
        //1. 判断是否满了 满了要扩容
        if(isFull()) {
            elem = Arrays.copyOf(elem,2*elem.length);
        }
        elem[usedSize] = data;
        usedSize++;
    }

LinkedList 代码：

 public void addIndex(int index, int data) throws IndexException{
        if(index < 0 || index > size()) {
            throw new IndexException("index不合法的: "+index);
        }
        ListNode node = new ListNode(data);
        if(head == null) {
            head = node;
            return;
        }
        if(index == 0) {
            addFirst(data);
            return;
        }
        if(index == size()) {
            addLast(data);
            return;
        }
        //中间插入
        ListNode cur = searchPrevIndex(index);
        node.next = cur.next;
        cur.next = node;
    }

上述的LinkedList 的代码是对于带头的单链表举例的。

我们可以从中看到，这里的ArrayList 新增时可能会开辟额外的新空间，空间利用率比较大。

别看这里的LinkedList的代码比较多，这里体现数据结构的严谨性，这里的空间利用率时非常高的。

---

（2）删除

对于删除，这里LinkedList 就比ArrayList 好的多了，

我们可以知道，在数组中在删除元素过后，我们需要把删除这个元素的后面的元素，都向前移动一位。这时间复杂度可就高了。

关于LinkedList 我们只需要把删除元素的前一个元素的next 等于后一个元素就可以了，只需要 一步，比ArrayList 好多了。

如 ArrayList 的代码：

 public void remove(int toRemove) {
        if(isEmpty()) {
            throw new EmptyException("顺序表为空,不能删除");
        }
        int index = indexOf(toRemove);
        for (int i = index; i < usedSize-1; i++) {
            elem[i] = elem[i+1];
        }
        usedSize--;
    }

如LinkedList 代码：

 public void remove(int key) {

        if(head == null) {
            return;
        }
        if(head.val == key) {
            head = head.next;
            return;
        }
        ListNode cur = findPrevKey(key);
        if(cur == null) {
            return;//没有你要删除的数字
        }
        ListNode del = cur.next;
        cur.next = del.next;
    }

这里他们的时间复杂度分别为：O(n)  和  O(1)。

---

总结：

ArrayList：

1.在查找元素中，相对简单。因为链表必须从头开始访问，否则找不到。

2.在删除中比较mafan，因为需要移动整个数组的元素。

3.新增时需要对其扩容。

LinkedList：

1.在新增元素时简单，只需要改变相应节点即可。删除也是。

2.查找比较麻烦，需要从头开始访问。

与 ArrayList 相比，LinkedList 的增加和删除的操作效率更高，而查找和修改的操作效率较低。