ArrayList与LinkedList分析

最新推荐文章于 2024-09-14 18:52:56 发布

lk231_java

最新推荐文章于 2024-09-14 18:52:56 发布

阅读量80

点赞数

分类专栏： java 文章标签：数据结构与算法 java

本文链接：https://blog.csdn.net/lk231_java/article/details/83941017

版权

java 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

先看看ArrayList源码


public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
//其中有一个成员变量
 private transient E[] elementData;

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

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
	this(10);
    }

由此我们可以看出它的底层其实是用数组来维护的，而且默认数组大小为10，当我们向ArrayList添加一个对象时，此对象交由数组来指向，当添加的对象超过10时


  public boolean add(E o) {
	ensureCapacity(size + 1);  // Increments modCount!!
	elementData[size++] = o;
	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;
	    elementData = (E[])new Object[newCapacity];
	    System.arraycopy(oldData, 0, elementData, 0, size);
	}
    }

我们可以看到会生成一个新的对象数组，长度为原长度的1.5倍加上1，当再次超过重复此过程

再来看看LinkedList


public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Queue<E>, Cloneable, java.io.Serializable
{
    private transient Entry<E> header = new Entry<E>(null, null, null);
    private transient int size = 0;

   /**
     * Appends the specified element to the end of this list.
     *
     * @param o element to be appended to this list.
     * @return <tt>true</tt> (as per the general contract of
     * <tt>Collection.add</tt>).
     */
    public boolean add(E o) {
	addBefore(o, header);
        return true;
    }
   private Entry<E> addBefore(E o, Entry<E> e) {
	Entry<E> newEntry = new Entry<E>(o, e, e.previous);
	newEntry.previous.next = newEntry;
	newEntry.next.previous = newEntry;
	size++;
	modCount++;
	return newEntry;
    }

   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;
	}
    }

很明显LinkedList的底层是用双向链表来实现的，当向LinkedList添加一个对象时候，实际上在底层生成了一个Entry对象，并将添加的对象赋给其成员变量element，然后Entry会构造前后引用，使得前后链接，简单说LinkedList维护的并不是对象本身，其实是Entry对象

从上面可以看出
ArrayList是用数组来实现，所以查询的效率要高，而LinkedList是用链表来实现，所以其插入和删除的效率要高，但是两者都不是线程安全的，所以在实际开发中都要进行同步