【Java程序优化】- 深度剖析 List 性能分析

标签：list   foreach   arraylist   linkedlist   

List 是重要的数据结构之一。最常用的的便是： ArrayList、Vector 和 LinkedList 三种了，他们类图如下图所示：

由上图可知，这三种 List 都实现了 Collection 和 List 接口。

这三种不同的实现中，ArrayList 和 Vector 使用了数组实现，封装了对内部数组的操作。它们俩唯一的区别是 ArrayList 没有任何一个方法是同步的，而 Vector 则是做了线程同步。我们之后均以 ArrayList 为例进行讲解。

LinkList 使用了双向链表数据结构，并且维护了 first 和 last 两个成员变量来指示链表的头和尾。这和 ArrayList 是截然不同的实现技术，也决定了它们适用于不同的场景中。

LinkedList 是由一系列表项连接而成的。一个表项总是分为三个部分，分别是：元素内容，前驱表项 和 后驱表项，如下图所示：

在 JDK 的视线中，不管 LinkedList 是否为空，链表中总是有一个 header 表项，它即表示链表的开始，也表示链表的结尾。

下面以增加和删除为例，比较 ArrayList 和 LinkList 的不同之处。

1、增加元素到列表尾端

在 ArrayList 中增加元素到队列端尾的代码如下：

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 确保内部数组有足够的空间
        elementData[size++] = e;
        return true;
    }

	/**
	 * 分配的最大内存。
	 * 有些虚拟机会为数组保留了一些头部内容，试图分配更多的空间会引起内存溢出
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
    private void ensureCapacityInternal(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1); //计划扩容到现在容量的1.5倍
        if (newCapacity - minCapacity < 0) //如果新容量小于最小需要的，则使用最小需要的
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity); //进行新旧数组的复制
    }
    
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

可以看到，只要 ArrayList 的当前容量很大，add() 操作的效率是非常高的。只有当 ArrayList 对容量的需求超过当前数组的大小时，才需要扩容。扩容过程中，会进行大量的数组复制操作。当数组复制时，最终调用 Arrays.copyof() 方法。

LinkedList 的 add() 操作实现如下，它将任意元素增加到队列的尾端：

   public boolean add(E e) {
        linkLast(e);
        return true;
    }

  void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

分别使用 ArrayList 和 LinkedList 运行以下代码：

public class ListTest {
	public static void testArrayList() {
		Object obj = new Object();
		List list = new ArrayList<>();
		for (int i = 0; i < 500000; i++) {
			list.add(obj);
		}
	}

	public static void testLinkedList() {
		Object obj = new Object();
		List list = new LinkedList<>();
		for (int i = 0; i < 500000; i++) {
			list.add(obj);
		}
	}

	public static void main(String[] args){
		testArrayList();
		testLinkedList();
	}
}

可以看到，ArrayList 的性能比 LinkedList 性能高出 4 倍左右。

2、增加元素到列表任意位置

在 ArrayList 中，任意位置插入的实现代码如下：

    public void add(int index, E element) {
        rangeCheckForAdd(index); //数组越界检查

        ensureCapacityInternal(size + 1);  // 增加modCount值
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index); //index 之后的元素都需要后移一个单位
        elementData[index] = element;
        size++;
    }

而LinkedList 此时就显示出了优势：

    public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

public class ListTest {
	public static void testArrayList() {
		Object obj = new Object();
		List list = new ArrayList<>();
		for (int i = 0; i < 50000; i++) {
			list.add(0, obj);
		}
	}

	public static void testLinkedList() {
		Object obj = new Object();
		List list = new LinkedList<>();
		for (int i = 0; i < 50000; i++) {
			list.add(0, obj);
		}
	}

	public static void main(String[] args) {
		testArrayList();
		testLinkedList();
	}
}

然后每次都插入中间位置： 

list.add(list.size()>>1, obj);

我们再插入末尾位置：

list.add(list.size(), obj);

因此通过对比以上三种情况下的插入操作，我们得到如下结论：当插入的位置靠前的时候，ArrayList 的性能是由于 LinkedList 的。而当插入的位置越来越靠后， ArrayList 的性能变得比 LinkedList 越来越好。

这是因为： ArrayList 的性能损耗主要在于每次插入需要复制数组，LinkedList 的性能损耗则在循环遍历链表找插入位置元素的上面。当插入位置靠前的时候，ArrayList 会花费大量的时间在复制数组上面，而 LinkedList 遍历链表找插入位置的时间消耗确是最少的。随着插入位置越来越靠后， ArrayList 需要复制的数组越来越小，消耗的时间越来越少。而 LinkedList 寻找的时间越来越多（确切的说，当插入位置为中间的时候，LinkedList 寻找的时间是最多的 ）或者说是比不上 ArrayList 复制数组时间的减少速度。

3、删除任意位置元素

对于 ArrayList 来说， remove() 方法和 add() 方法雷同。在任意位置移除元素后，都要进行数组的重组。实现如下：

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

        modCount++;
        E oldValue = 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;
    }

对于 LinkedList ，删除操作的实现如下：

public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }
Node<E> node(int index) {
        // assert isElementIndex(index);

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

删除的性能对比和增加的性能对比可以参照插入操作的性能对比。

4、容量参数

容量参数是ArrayList 和 Vector 等基于数组的 List 的特有性能参数，它表示初始化数组大小。每一次数组元素数量超过其现有大小的时候，它表会进行一次扩容，数组的扩容会导致整个数组进行一次内存复制。因此合理的数组大小有助于减少数组扩容的次数，从而提高系统性能。

默认情况下， ArrayList 的数组初始大小为10，每次进行扩容将新的数组大小设置为原来的1.5倍。

5、遍历列表

在 JDK1.5 之后，至少有三种遍历的方式：ForEach、迭代器、for循环。

package bupt.xiaoye.charpter2.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class TestFor {
	public static void testForEach(List list) {
		Object temp;
		for(Object t : list)
			temp = t;
	}

	public static void testFor(List list) {
		Object temp;
		for (int i = 0; i < 1000000; i++) {
			temp = list.get(i);
		}
	}
	public static void testIterator(List list) {
		Object temp;
		for(Iterator<Object> it = list.iterator();it.hasNext();){
			temp = it.next();
		}
	}

	public static void main(String[] args) {
		Object obj = new Object();
		List list = new ArrayList();
		for (int i = 0; i < 1000000; i++) {
			list.add(obj);
		}
		testFor(list);
		testForEach(list);
		testIterator(list);
	}
}

可以看到，直接for循环效率最高，其次是迭代器和 ForEach操作。

作为语法糖，其实 ForEach 编译成 字节码之后，使用的是迭代器实现的，反编译后，testForEach方法如下：

	public static void testForEach(List list) {
		for (Iterator iterator = list.iterator(); iterator.hasNext();) {
			Object t = iterator.next();
			Object obj = t;
		}
	}

【Java程序优化】- 深度剖析 List 性能分析

标签：list   foreach   arraylist   linkedlist   

原文地址：http://blog.csdn.net/zq602316498/article/details/39163899