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线程安全，但是效率低；