java arraylist 实例_Java ArrayList详细介绍和使用示例

①对ArrayList的整体认识

ArrayList是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。它继承了AbstractList,实现了List，RandomAccess，Cloneable，java.io.Serializable这些接口。

ArrayList继承了AbstractList,实现了List.它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。

ArrayList实现了RandomAccess接口，即提供了随机访问功能，RandomAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。稍后，我们会比较List的快速随机访问和通过Iterator迭代器访问的效率。

ArrayList实现了Cloneable接口，即覆盖了函数clone(),能被克隆。

ArrayList实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。

和Vector不同，ArrayList中的操作不是线程安全的，所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或则CopyOnWriteArrayList.

②ArrayList构造函数

// 默认构造函数

ArrayList()

// capacity是ArrayList的默认容量大小。当由于增加数据导致容量不足时，容量会添加上一次容量大小的一半。

ArrayList(int capacity)

// 创建一个包含collection的ArrayList

ArrayList(Collection extends E> collection)

③ArrayList的API

// Collection中定义的API

boolean add(E object)

boolean addAll(Collection extends E> collection)

void clear()

boolean contains(Object object)

boolean containsAll(Collection> collection)

boolean equals(Object object)

int hashCode()

boolean isEmpty()

Iterator iterator()

boolean remove(Object object)

boolean removeAll(Collection> collection)

boolean retainAll(Collection> collection)

int size()

T[] toArray(T[] array)

Object[] toArray()

// AbstractCollection中定义的API

void add(int location, E object)

boolean addAll(int location, Collection extends E> collection)

E get(int location)

int indexOf(Object object)

int lastIndexOf(Object object)

ListIterator listIterator(int location)

ListIterator listIterator()

E remove(int location)

E set(int location, E object)

List subList(int start, int end)

// ArrayList新增的API

Object clone()

void ensureCapacity(int minimumCapacity)

void trimToSize()

void removeRange(int fromIndex, int toIndex)

④ArrayList的继承关系

java.lang.Object

↳ java.util.AbstractCollection

↳ java.util.AbstractList

↳ java.util.ArrayList

public class ArrayList extends AbstractList

implements List, RandomAccess, Cloneable, java.io.Serializable {}

ArrayList包含了两个重要的对象：elementData 和 size。

(01) elementData 是"Object[]类型的数组"，它保存了添加到ArrayList中的元素。实际上，elementData是个动态数组，我们能通过构造函数 ArrayList(int initialCapacity)来执行它的初始容量为initialCapacity；如果通过不含参数的构造函数ArrayList()来创建ArrayList，则elementData的容量默认是10。elementData数组的大小会根据ArrayList容量的增长而动态的增长，具体的增长方式，请参考源码分析中的ensureCapacity()函数。

(02) size 则是动态数组的实际大小。

⑤ArrayList源码代码作出分析

源码请参考链接http://www.cnblogs.com/skywang12345/p/3308556.html

ArrayList实际上是通过一个数组去保存数据的。当我们构造ArrayList时，若使用默认构造函数，则ArrayList的默认容量大小是10.

当ArrayList容量不足以容纳全部元素时，ArrayList会重新设置容量：新的容量=“原始容量*3/2+1”

ArrayList的克隆函数，即是将全部元素克隆到一个数组中。

ArrayList实现java.io.Serializable的方式。当写入到输出流时，先写入容量，再依次写入每一个元素，当读出输入流时，先读取容量，再依次读取每一个元素。

⑥ArrayList支持3种遍历方式

(01) 第一种，通过迭代器遍历。即通过Iterator去遍历。

Integer value=null;

Iterator iter=list.iterator();

while(iter.hasNext){

value=(Integer)iter.next();

}

(02) 第二种，随机访问，通过索引值去遍历。

由于ArrayList实现了RandomAccess接口，它支持通过索引值去随机访问元素。

Integer value==null;

int size=list.size();

for(int i=0;i

value=(Integer)list.get(i);

}

(03) 第三种，for循环遍历。如下：

Integer value=null;

for (Integer integ:list){

value=integ;

}

下面通过一个实例，比较这3种方式的效率，实例代码(ArrayListRandomAccessTest.java)如下

import java.util.*;

import java.util.concurrent.*;

/*

* @desc ArrayList遍历方式和效率的测试程序。

*

* @author skywang

*/

public class ArrayListRandomAccessTest {

public static void main(String[] args) {

List list = new ArrayList();

for (int i=0; i<100000; i++)

list.add(i);

//isRandomAccessSupported(list);

iteratorThroughRandomAccess(list) ;

iteratorThroughIterator(list) ;

iteratorThroughFor2(list) ;

}

private static void isRandomAccessSupported(List list) {

if (list instanceof RandomAccess) {

System.out.println("RandomAccess implemented!");

} else {

System.out.println("RandomAccess not implemented!");

}

}

public static void iteratorThroughRandomAccess(List list) {

long startTime;

long endTime;

startTime = System.currentTimeMillis();

for (int i=0; i

list.get(i);

}

endTime = System.currentTimeMillis();

long interval = endTime - startTime;

System.out.println("iteratorThroughRandomAccess：" + interval+" ms");

}

public static void iteratorThroughIterator(List list) {

long startTime;

long endTime;

startTime = System.currentTimeMillis();

for(Iterator iter = list.iterator(); iter.hasNext(); ) {

iter.next();

}

endTime = System.currentTimeMillis();

long interval = endTime - startTime;

System.out.println("iteratorThroughIterator：" + interval+" ms");

}

public static void iteratorThroughFor2(List list) {

long startTime;

long endTime;

startTime = System.currentTimeMillis();

for(Object obj:list)

;

endTime = System.currentTimeMillis();

long interval = endTime - startTime;

System.out.println("iteratorThroughFor2：" + interval+" ms");

}

}

运行结果：

iteratorThroughRandomAccess：3 ms

iteratorThroughIterator：8 ms

iteratorThroughFor2：5 ms

由此可见，遍历ArrayList时，使用随机访问(即，通过索引序号访问)效率最高，而使用迭代器的效率最低！

⑦ArrayList示例

import java.util.*;

/*

* @desc ArrayList常用API的测试程序

* @author skywang

* @email kuiwu-wang@163.com

*/

public class ArrayListTest {

public static void main(String[] args) {

// 创建ArrayList

ArrayList list = new ArrayList();

// 将“”

list.add("1");

list.add("2");

list.add("3");

list.add("4");

// 将下面的元素添加到第1个位置

list.add(0, "5");

// 获取第1个元素

System.out.println("the first element is: "+ list.get(0));

// 删除“3”

list.remove("3");

// 获取ArrayList的大小

System.out.println("Arraylist size=: "+ list.size());

// 判断list中是否包含"3"

System.out.println("ArrayList contains 3 is: "+ list.contains(3));

// 设置第2个元素为10

list.set(1, "10");

// 通过Iterator遍历ArrayList

for(Iterator iter = list.iterator(); iter.hasNext(); ) {

System.out.println("next is: "+ iter.next());

}

// 将ArrayList转换为数组

String[] arr = (String[])list.toArray(new String[0]);

for (String str:arr)

System.out.println("str: "+ str);

// 清空ArrayList

list.clear();

// 判断ArrayList是否为空

System.out.println("ArrayList is empty: "+ list.isEmpty());

}

}

运行结果

the first element is: 5

Arraylist size=: 4

ArrayList contains 3 is: false

next is: 5

next is: 10

next is: 2

next is: 4

str: 5

str: 10

str: 2

str: 4

ArrayList is empty: true