典型回答

这三者都是实现集合框架中的 List ，也就是所谓的有序集合，因此具体功能也比较近似，比如都提供按照位置进行定位、添加或者删除的操作，都提供迭代器以遍历其内容等。但因为具体的设计区别，在行为、性能、线程安全等方面，表现又有很大不同。

Vector 是 Java 早期提供的线程安全的动态数组，如果不需要线程安全，并不建议选择，毕竟同步是额外开销的。Vector 内部是使用对象数组来保存数据，可以根据需要自动的增加容量，当数组已满时，会创建新的数组，并拷贝原有数组数据。

ArrayList 是应用更加广泛的动态数组实现，它本身不是线程安全的，所以性能要好很多。与 Vector 近似，ArrayList 也是可以根据需要调整容量，不过两者的调整逻辑有所区别， Vector 在扩容时会提高 1 倍，而 ArrayList 则是增加 50%。

LinkedList 顾名思义是 Java 提供的双向链表，所以它不需要像上面两种那样调整容量，它也不是线程安全的。

• Vector 和 ArrayList 作为动态数组，其内部元素以数组形式顺序存储的，所以非常适合随机访问的场合。除了尾部插入和删除元素，往往性能会相对较差，比如我们在中间位置插入一个元素，需要移动后续所有元素。
• LinkedList 进行节点插入、删除却要高效得多，但是随机访问性能则要比动态数组慢。

知识扩展

关于 Vector

Vector 底层是用数组实现的，相关的方法都加了同步检查，因此 “线程安全，效率低”。比如，indexOf 方法就增加了 synchronized 同步标记。

public synchronized int indexOf(Object o, int index) {
        if (o == null) {
            for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index ; i < elementCount ; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

Vector 下有一个子类 Stack ，本质上也是由动态数组实现的，只不过还实现了先进后出的功能（在 get、set、add 方法的基础上追加了 pop、peek 等方法），所以叫栈。

不过，由于 Stack 执行效率比较低（方法上同样加了 synchronized 关键字），就被双端队列 ArrayDeque 取代了。

关于 ArrayList

数组的大小是固定的，一旦创建的时候指定了大小，就不能再调整了。也就是说，如果数组满了，就不能再添加任何元素了。 ArrayList 在数组的基础上实现了自动扩容，并且提供了比数组更丰富的预定义方法（各种增删改查），非常灵活。

public class ArrayListTest {
    public static void main(String[] args) {
        //实例化ArrayList容器
        List<String> list  = new ArrayList<>();
        
        //添加元素
        boolean flag1 = list.add("a");
        boolean flag2 = list.add("b");
        boolean flag3 = list.add("c");
        boolean flag4 = list.add("d");
        System.out.println(flag1+"\t"+flag2+"\t"+flag3+"\t"+flag4);
		
		//删除元素
        boolean flag4 = list.remove("a");
        System.out.println(flag4);
        
        //获取容器中元素的个数
        int size = list.size();
        System.out.println(size);
        
        //判断容器是否为空
        boolean empty = list.isEmpty();
        System.out.println(empty);
        
        //容器中是否包含指定的元素
        boolean value = list.contains("b");
        System.out.println(value);
                
        //清空容器
        list.clear();
        Object[] objects1 = list.toArray();
      
		System.out.println(Arrays.toString(objects1));
   }
}

ArrayList 增删改查的时间复杂度

1）通过下标（也就是 get(int index)）访问一个元素的时间复杂度为 O(1)，因为是直达的，无论数据增大多少倍，耗时都不变。

public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

2）默认添加一个元素（调用 add() 方法时）的时间复杂度为 O(1)，因为是直接添加到数组末尾的，但需要考虑到数组扩容时消耗的时间。

3）删除一个元素（调用 remove(Object) 方法时）的时间复杂度为 O(n)，因为要遍历列表，数据量增大几倍，耗时也增大几倍；如果是通过下标删除元素时，要考虑到数组的移动和复制所消耗的时间。

4）查找一个未排序的列表时间复杂度为 O(n)（调用 indexOf() 或者 lastIndexOf() 方法时），因为要遍历列表；查找排序过的列表时间复杂度为 O(log n)，因为可以使用二分查找法，当数据增大 n 倍时，耗时增大 logn 倍（这里的 log 是以 2 为底的，每找一次排除一半的可能）

ArrayList 和 Vector 区别

• Vector 是线程安全的，源码中有很多的 synchronized 可以看出，而 ArrayList 不是。导致 Vector 效率比 ArrayList 低；

• ArrayList 和 Vector 都采用线性连续存储空间，当存储空间不足的时候，ArrayList 默认增加为原来大小的 1.5 倍，Vector 默认增加为原来大小的 2 倍；

• Vector可以设置 capacityIncrement ，而 ArrayList 不可以，从字面理解 capacity 就是容量，Increment 是容量增长的参数。

• Arraylist 和 Vector 默认情况下，初始化大小为 10 的 object 数组 。

关于 LinkedList

LinkedList 底层用双向链表实现的存储。特点：查询效率低，增删效率高，线程不安全。

双向链表也叫双链表，是链表的一种，它的每个数据节点中都有两个指针，分别指向前一个节点和后一个节点。 所以，从双向链表中的任意一个节点开始，都可以很方便地找到所有节点。

在 LinkedList 中有一个私有的静态内部类，叫 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;
    }
}

它由三部分组成：

• 节点上的元素
• 下一个节点
• 上一个节点
  
• 对于第一个节点来说，prev 为 null；
• 对于最后一个节点来说，next 为 null；
• 其余的节点呢，prev 指向前一个，next 指向后一个。

如何选用ArrayList、LinkedList、Vector?

• 需要线程安全时，用 Vector。
• 不存在线程安全问题时，并且查找较多用ArrayList（一般使用它）
• 不存在线程安全问题时，增加或删除元素较多用LinkedList

LinkedList容器的使用（非List标准）

public class LinkedListTest {
    public static void main(String[] args) {
        System.out.println("-------LinkedList-------------");
        
        //将指定元素插入到链表开头
        LinkedList<String> linkedList1 = new LinkedList<>();
        linkedList1.addFirst("a");
        linkedList1.addFirst("b");
        linkedList1.addFirst("c");
        
        for (String str : linkedList1){
            System.out.println(str);
       }
        System.out.println("----------------------");
        
        //将指定元素插入到链表结尾
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.addLast("a");
        linkedList.addLast("b");
        linkedList.addLast("c");
        
        for (String str : linkedList){
            System.out.println(str);
       }     
        System.out.println("---------------------------");
        
        //返回此链表的第一个元素      
		System.out.println(linkedList.getFirst());
		
        //返回此链表的最后一个元素
        System.out.println(linkedList.getLast());
        System.out.println("-----------------------");
        
        //移除此链表中的第一个元素，并返回这个元素
        linkedList.removeFirst();
        
        //移除此链表中的最后一个元素，并返回这个元素
        linkedList.removeLast();
        
        for (String str : linkedList){
            System.out.println(str);
       }
        System.out.println("-----------------------");
        
        linkedList.addLast("c");
        //从此链表所表示的堆栈处弹出一个元素,等效于removeFirst
        linkedList.pop();
        for (String str : linkedList){
            System.out.println(str);
       }
        System.out.println("-------------------");
        
        //将元素推入此链表所表示的堆栈 这个等效于addFisrt(E e)
        linkedList.push("h");
        for (String str : linkedList){
            System.out.println(str);
       }
   }
}

ArrayList 和 LinkedList 遍历元素时究竟谁快？

1）ArrayList
遍历 ArrayList 找到某个元素的话，通常有两种形式：

• get(int)，根据索引找元素

public E get(int index) {
    Objects.checkIndex(index, size);
    return elementData(index);
}

由于 ArrayList 是由数组实现的，所以根据索引找元素非常的快，一步到位。

• indexOf(Object)，根据元素找索引

public int indexOf(Object o) {
    return indexOfRange(o, 0, size);
}

int indexOfRange(Object o, int start, int end) {
    Object[] es = elementData;
    if (o == null) {
        for (int i = start; i < end; i++) {
            if (es[i] == null) {
                return i;
            }
        }
    } else {
        for (int i = start; i < end; i++) {
            if (o.equals(es[i])) {
                return i;
            }
        }
    }
    return -1;
}

根据元素找索引的话，就需要遍历整个数组了，从头到尾依次找。

2）LinkedList
遍历 LinkedList 找到某个元素的话，通常也有两种形式：

• get(int)，找指定位置上的元素

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

既然需要调用 node(int) 方法，就意味着需要前后半段遍历了。

• indexOf(Object)，找元素所在的位置

public int indexOf(Object o) {
    int index = 0;
    if (o == null) {
        for (LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (x.item == null)
                return index;
            index++;
        }
    } else {
        for (LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item))
                return index;
            index++;
        }
    }
    return -1;
}

需要遍历整个链表，和 ArrayList 的 indexOf() 类似。

那在我们对集合遍历的时候，通常有两种做法，一种是使用 for 循环，一种是使用迭代器（Iterator）。

如果使用的是 for 循环，可想而知 LinkedList 在 get 的时候性能会非常差，因为每一次外层的 for 循环，都要执行一次 node(int) 方法进行前后半段的遍历。

LinkedList.Node<E> node(int index) {
    // assert isElementIndex(index);

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

那如果使用的是迭代器呢？

LinkedList<String> list = new LinkedList<String>();
for (Iterator<String> it = list.iterator(); it.hasNext();) {
    it.next();
}

迭代器只会调用一次 node(int) 方法，在执行 list.iterator() 的时候：先调用 AbstractSequentialList 类的 iterator() 方法，再调用 AbstractList 类的 listIterator() 方法，再调用 LinkedList 类的 listIterator(int) 方法，如下图所示。

最后返回的是 LinkedList 类的内部私有类 ListItr 对象：

public ListIterator<E> listIterator(int index) {
    checkPositionIndex(index);
    return new LinkedList.ListItr(index);
}

private class ListItr implements ListIterator<E> {
    private LinkedList.Node<E> lastReturned;
    private LinkedList.Node<E> next;
    private int nextIndex;
    private int expectedModCount = modCount;

    ListItr(int index) {
        // assert isPositionIndex(index);
        next = (index == size) ? null : node(index);
        nextIndex = index;
    }

    public boolean hasNext() {
        return nextIndex < size;
    }

    public E next() {
        checkForComodification();
        if (!hasNext())
            throw new NoSuchElementException();

        lastReturned = next;
        next = next.next;
        nextIndex++;
        return lastReturned.item;
    }
}

执行 ListItr 的构造方法时调用了一次 node(int) 方法，返回第一个节点。在此之后，迭代器就执行 hasNext() 判断有没有下一个，执行 next() 方法下一个节点。

由此，可以得出这样的结论：遍历 LinkedList 的时候，千万不要使用 for 循环，要使用迭代器。

也就是说，for 循环遍历的时候，ArrayList 花费的时间远小于 LinkedList；迭代器遍历的时候，两者性能差不多。