jdk集合常用方法分析之ArrayList&LinkedList&以及两者的对比分析

集合使用注意事项：

1、集合当中只能放置对象的引用，无法放置原生数据类型，我们需要使用原生数据类型的包装类才能加入到集合当中去(JDK5之后会进行自动的装箱和拆箱操作，表面上看集合中是可以直接放置原生数据类型进去，但实质上是进过自动装箱成对象操作的)；

2、集合当中放置的都是Object类型，因此取出来的也是Object类型(可以放置任意类型的数据)，那么必须要使用强制类型转换将其转换为真正的类型(放置进去的类型)。

ArrayList

ArrayList常用方法：

boolean add(E e)
void add(int index, E element)
void clear()
E get(int index)
int indexOf(Object o)
boolean isEmpty()
E remove(int index)
boolean remove(Object o)
int size()
Object[] toArray()

ArrayList常用方法分析：

1、构造方法

List list = new ArrayList();

ArrayList底层采用数组实现，当使用不带参数的构造方法生成ArrayList对象时，实际上会在底层生成一个长度为10的Object类型数组来存放对象(的地址)。详见jdk源码：

public ArrayList() {
    this(10);
}

public ArrayList(int initialCapacity) {
    super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
    this.elementData = new Object[initialCapacity];
}

private transient Object[] elementData;

2、add()方法

如果添加的元素个数超过了10个，那么ArrayList底层会新生成一个数组，长度为原数组的1.5倍+1；

然后将原数组的内容复制到新数组当中，并且后续增加的内容都会放到新数组中；当新数组无法容纳增加的元素时，重复该过程。详见jdk源码：

public boolean add(E e) {
    ensureCapacity(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

public void ensureCapacity(int minCapacity) {
    modCount++;
    int oldCapacity = elementData.length;
    if (minCapacity > oldCapacity) {
        Object oldData[] = elementData;
        int newCapacity = (oldCapacity * 3)/2 + 1;
            if (newCapacity < minCapacity)
        newCapacity = minCapacity;
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
    }
}

public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
}

public void add(int index, E element) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(
        "Index: "+index+", Size: "+size);

    ensureCapacity(size+1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}

public static native void arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length);

3、size()方法

返回List的长度

public int size() {
    return size;
}

private int size;

4、remove()方法

public E remove(int index) {
    RangeCheck(index);

    modCount++;
    E oldValue = (E) elementData[index];

    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    elementData[--size] = null; // Let gc do its work
    return oldValue;
}

public static native void arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length);

5、ArrayList常用方法总结：

1、对于ArrayList所有方法都不是同步的，而Vector大部分的public的方法都是同步的；

2、对于ArrayList元素的，添加和删除操作，需要将被删除或者添加到元素的后续元素向前或者向后移动，代价比较高。但是查找速度非常快(由数组的特点来决定的)；

3、ArrayList在添加或者删除元素的时候，是需要移动大量元素的借助System.arraycopy()来实现拷贝移动；在查找时，可依靠数组下标快速定位；

LinkedList

LinkedList常用方法有：

public void addFirst(E e)
public void addLast(E e)
public E getFirst()
public E getLast()
public E peek()
public E pop()
E remove(int index)
public void push(E e)

LinkedList常用方法分析：

1、构造方法

LinkedList list = new LinkedList();

public LinkedList() {
        //初始化时，将结点的前驱和后续都指向自己(header).形成了循环。
        header.next = header.previous = header;
}

//LinkedList头结点的定义:
private transient Entry<E> header = new Entry<E>(null, null, null);

private transient Entry<E> header = new Entry<E>(null, null, null);

  private static class Entry<E> {
    E element;
    Entry<E> next;
    Entry<E> previous;

    Entry(E element, Entry<E> next, Entry<E> previous) {
        this.element = element;
        this.next = next;
        this.previous = previous;
    }
}

其中element就是我们想LinkedList中所添加到元素，然后Entry又构造好了向前与向后的引用previous和next，最后将生成的这个Entry对象加入到了链表当中；

换句话说，LinkedList中所维护的是一个个的Entry对象。

2、add()方法

public boolean add(E e) {
    addBefore(e, header);
        return true;
}

private Entry<E> addBefore(E e, Entry<E> entry) {
    Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
    newEntry.previous.next = newEntry;
    newEntry.next.previous = newEntry;
    size++;
    modCount++;
    return newEntry;
}

3、remove()方法

调用remove()方法的时候只是改变了它的previous和next所指向的对象

public E remove(int index) {
        return remove(entry(index));
}

private E remove(Entry<E> e) {
    if (e == header)
        throw new NoSuchElementException();

    E result = e.element;
    e.previous.next = e.next;
    e.next.previous = e.previous;
    e.next = e.previous = null;
    e.element = null;
    size--;
    modCount++;
        return result;
}

ArrayList和LinkedList比较

1、ArrayList底层采用数组实现，它本质上是对象引用的一个可变长的数组；LinkedList底层采用双向链表实现；

2、当执行插入或者删除操作时(本质上是由双向循环链表的特点决定的)，采用LinkedList比较好；

3、当执行查找操作时(本质上是由数组的特点决定的)，采用ArrayList比较好；

常见面试题：

问题1：ArrayList的大小是如何自动增加的？你能分享一下你的代码吗？

当试图在arraylist中增加一个对象的时候，Java会去检查arraylist，以确保已存在的数组中有足够的容量来存储这个新的对象；

如果没有足够容量的话，那么就会新建一个长度更长的数组，旧的数组就会使用Arrays.copyOf方法被复制到新的数组中去，现有的数组引用指向了新的数组；

//ArrayList Add方法：
public boolean add(E e){
    ensureCapacity(size+1); //Increment modCount!!
    elementData[size++] = e;
    return true;
}
 
//ensureCapacity方法：处理ArrayList的大小
public void ensureCapacity(int minCapacity) {
    modCount++;
    int oldCapacity = elementData.length;
    if (minCapacity > oldCapacity) {
    Object oldData[] = elementData;
    int newCapacity = (oldCapacity * 3)/2 + 1;
    if (newCapacity < minCapacity)
        newCapacity = minCapacity;
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
    }
}

一定要注意如下三点：

1）新建了一个数组；

2）旧数组的对象被复制到了新的数组中；

3）并且现有的数组指向新的数组；

问题2：什么情况下你会使用ArrayList？什么时候你会选择LinkedList？

多数情况下，当遇到访问元素比插入或者是删除元素更加频繁的时候，应该使用ArrayList；

另外一方面，当你在某个特别的索引中，插入或者是删除元素更加频繁，或者压根就不需要访问元素的时候，应该会选择LinkedList；

这里的主要原因是：

1）在ArrayList中访问元素的最糟糕的时间复杂度是”1″，而在LinkedList中可能就是”n”了；

2）在ArrayList中增加或者删除某个元素，通常会调用System.arraycopy方法，这是一种极为消耗资源的操作，因此，在频繁的插入或者是删除元素的情况下，LinkedList的性能会更加好一点。

问题3：如何复制某个ArrayList到另一个ArrayList中去？写出你的代码？ 

1）使用clone()方法，比如ArrayList newArray = oldArray.clone();

2）使用ArrayList构造方法，比如：ArrayList myObject = new ArrayList(myTempObject);

3）使用Collection的copy方法。

注意1和2是浅拷贝(shallow copy)。

问题4：ArrayList的增加或者删除某个对象的运行过程？效率很低吗？解释一下为什么？

在ArrayList中增加或者是删除元素，要调用System.arraycopy这种效率很低的操作，如果遇到了需要频繁插入或者是删除的时候，你可以选择其他的Java集合，比如LinkedList。

在ArrayList的某个索引i处添加元素：

 public void add(int index, E element) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(
        "Index: "+index+", Size: "+size);

    ensureCapacity(size+1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
    }

删除ArrayList的某个索引i处的元素：

public E remove(int index) {
    RangeCheck(index);

    modCount++;
    E oldValue = (E) elementData[index];

    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    elementData[--size] = null; // Let gc do its work

    return oldValue;
    }

 

问题5：ArrayList、LinkedList以及Vector的区别？

1）ArrayList底层是使用数组来实现的，并且该数组的类型是Object类型的；

2）List list = new ArrayList();时，底层会生成一个长度为10的数组来存放对象；

3）对于ArrayList与Vector来说，底层都是采用数组方式来实现，该数组是一个Object类型的数组；

4）对于ArrayList，所以的方法都不是同步的，对于Vector，大部分public的方法都是同步的。(对比记忆StringBuffer和StringBuilder)；

5）对于ArrayList，查找速度非常快，删除、增加操作非常慢，本质上是由数组的特点来决定的；

6）对于LinkedList，底层采用双向循环链表实现。查找非常慢，增加、删除操作非常快，本质上是由双向循环链表来决定的；

7）ArrayList是线程不安全的，但是效率高；Vector线程安全，但是效率低；