java性能优化读书笔记之三《程序优化===集合优化（list）》

说明：本文内容是针对于java集合的性能优化

1. 数据结构

请参考博客数据结构

2. List接口

概述

List是java重要结构之一， 它们的类图如下：



ArrayList和Vector是基于数组数据机构实现的。内部的操作都是对数组进行插入、删除，修改，遍历。可以说ArrayList和Vector是一个可扩容的动态数组。ArrayList与Vector不同之处在于Vector是线程安全的。

LinkList是基于双向链表数据结构实现的。内部的操作是对链表的节点（node）进行插入、删除、修改遍历。

结构图（数组）



结构图（链表）

3. 使用场景

LinkList在元素添加、删除效率比arrayList高，arrayList删除的元素越靠前，效率越低。

arryList在元素查询比LinkList高

4. 源码分析

无参的构造函数

代码清单：

/**
* Constructs an empty list with the specified initial capacity.
*
* @param   initialCapacity   the initial capacity of the list
* @exception IllegalArgumentException if the specified initial capacity
*            is negative
*/
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}

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

从源码中获悉，arrayList默认的初始化容器大小为10。

add方法

代码清单

/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
//调用此方法，判断容器是否需要扩容
ensureCapacity(size + 1);  // Increments modCount!!
//新元素赋值到指定的位置（size++)
elementData[size++] = e;
return true;
}

/**
* Increases the capacity of this <tt>ArrayList</tt> instance, if
* necessary, to ensure that it can hold at least the number of elements
* specified by the minimum capacity argument.
*
* @param   minCapacity   the desired minimum capacity
*/
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);
}
}

从源码中获取当容器所需的最小容量大于本身的容器大小。需要进行容器容量扩容。扩容的大小计算法则为

(oldCapacity * 3)/2 + 1

linkList就不讲了

5. List优化点

list容器在添加、删除频繁操作时，请使用linkList。list容器在遍历元素频繁操作时，请使用arrayList。具体场景具体分析

在特定的场景清楚list容器的容量，自己给定list容器的容量。不要使用默认的容器的容量（默认的大小为10）。这样做好处在于避免由于默认的容器容量比较小。导致list容器的容量频繁的扩容。（一般减少代码的运行，就能提高程序性能）

arrayList和linkList性能比较

package org.com.program.data;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
/**
* arrayList 添加的性能低于linkedList（在一定数据量）,指定arrayList容量，添加的性能高于linkedList
* arrayList 查询的效率大幅度高于linkedList
* arrayList 删除元素越靠前，效率越低。linkedList没有变化
* @author Administrator
*
*/

public class List01 {
private List<Object> arrayList = null;
private List<Object> linkedList = null;
private long startTime;
private long endTime;

@Before
public void listAdd() {
arrayList = new ArrayList<Object>();

//#######arrayList 与linkedList添加功能性能比较
startTime = System.currentTimeMillis();
for(int i=0; i<5000000; i++) {
arrayList.add(i);
}

endTime = System.currentTimeMillis();
System.out.println("arrayList to add  time{}:"+(endTime-startTime));

linkedList = new LinkedList<Object>();

startTime = System.currentTimeMillis();
for(int i=0; i<5000000; i++) {
linkedList.add(i);
}

endTime = System.currentTimeMillis();
System.out.println("linkedList to add time{}:"+(endTime-startTime));
}

@Test
public void listQuery() {

//#######arrayList 与linkedList查询功能性能比较
startTime = System.currentTimeMillis();
for(int i=0; i<50000; i++) {
arrayList.get(i);
}
endTime = System.currentTimeMillis();
System.out.println("arrayList to query time{}:"+(endTime-startTime));

//#######arrayList 与linkedList查询功能性能比较
startTime = System.currentTimeMillis();
for(int i=0; i<50000; i++) {
linkedList.get(i);
}
endTime = System.currentTimeMillis();
System.out.println("linkedList to query time{}:"+(endTime-startTime));

}

@After
public void listDel() {

//#######arrayList 与linkedList删除功能性能比较
startTime = System.currentTimeMillis();
arrayList.remove(0);

endTime = System.currentTimeMillis();
System.out.println("arrayList to del  time{}:"+(endTime-startTime));

startTime = System.currentTimeMillis();

linkedList.remove(0);

endTime = System.currentTimeMillis();
System.out.println("linkedList to del time{}:"+(endTime-startTime));
}
}

arrayList和linkList性能比较===》性能结果



给定arrayList容量大小与默认的arrayList容器大小性能比较

package org.com.program.data;

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

import org.junit.Test;
/**
* 给定arrayList容量大小与默认的arrayList容器容量大小性能比较
* @author Administrator
*
*/

public class List03 {

private List<Object> arrayList = null;
private long startTime =0L;
private long endTime = 0L;

//默认arrayList容器容量（10）
@Test
public void defaultCapacity() {
arrayList = new ArrayList<Object>();

startTime = System.currentTimeMillis();
for(int i=0; i<5000000; i++) {
arrayList.add(i);
}

endTime = System.currentTimeMillis();
System.out.println("arryList default capacity to add time{}:"+(endTime-startTime));
}

//指定arrayList容器容量（5000000）
@Test
public void specifiedCapacity() {
arrayList = new ArrayList<Object>(5000000);

startTime = System.currentTimeMillis();
for(int i=0; i<5000000; i++) {
arrayList.add(i);
}

endTime = System.currentTimeMillis();
System.out.println("arryList specified capacity to add time{}:"+(endTime-startTime));
}
}

给定arrayList容量大小与默认的arrayList容器大小性能结果