前言
什么是線性表？
跟著我往下看（這里只講順序存儲(chǔ)方式的線性表）：
不明白凉唐？繼續(xù)往下看
下面開(kāi)始進(jìn)入正題：
ArrayList就是使用順序結(jié)構(gòu)線性表帜讲，分析學(xué)習(xí)的最好例子，繼承了AbstractList慕爬，實(shí)現(xiàn)了List。ArrayList在工作中經(jīng)常用到屏积，所以要弄懂這個(gè)類是極其重要的医窿。
構(gòu)造圖如下:
藍(lán)色線條：繼承
綠色線條：接口實(shí)現(xiàn)
正文
ArrayList簡(jiǎn)介
ArrayList定義
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
ArrayList 是一個(gè)數(shù)組隊(duì)列，相當(dāng)于 動(dòng)態(tài)數(shù)組炊林。與Java中的數(shù)組相比姥卢，它的容量能動(dòng)態(tài)增長(zhǎng)。它繼承于AbstractList渣聚，實(shí)現(xiàn)了List, RandomAccess, Cloneable, java.io.Serializable這些接口独榴。
ArrayList 繼承了AbstractList，實(shí)現(xiàn)了List奕枝。它是一個(gè)數(shù)組隊(duì)列棺榔，提供了相關(guān)的添加、刪除隘道、修改掷豺、遍歷等功能。
ArrayList 實(shí)現(xiàn)了RandmoAccess接口薄声，即提供了隨機(jī)訪問(wèn)功能当船。RandmoAccess是java中用來(lái)被List實(shí)現(xiàn)，為L(zhǎng)ist提供快速訪問(wèn)功能的默辨。在ArrayList中德频，我們即可以通過(guò)元素的序號(hào)快速獲取元素對(duì)象；這就是快速隨機(jī)訪問(wèn)缩幸。稍后壹置，我們會(huì)比較List的“快速隨機(jī)訪問(wèn)”和“通過(guò)Iterator迭代器訪問(wèn)”的效率竞思。
ArrayList 實(shí)現(xiàn)了Cloneable接口，即覆蓋了函數(shù)clone()钞护，能被克隆盖喷。
ArrayList 實(shí)現(xiàn)java.io.Serializable接口，這意味著ArrayList支持序列化难咕，能通過(guò)序列化去傳輸课梳。
和Vector不同，ArrayList中的操作不是線程安全的余佃！所以暮刃，建議在單線程中才使用ArrayList，而在多線程中可以選擇Vector或者CopyOnWriteArrayList爆土。
ArrayList屬性
顧名思義哈椭懊，ArrayList就是用數(shù)組實(shí)現(xiàn)的List容器，既然是用數(shù)組實(shí)現(xiàn)步势，當(dāng)然底層用數(shù)組來(lái)保存數(shù)據(jù)啦
/**
*保存ArrayList中數(shù)據(jù)的數(shù)組
*/
private transient Object[] elementData;
/**
*ArrayList中實(shí)際數(shù)據(jù)的數(shù)量
*/
private int size;
/**
* 用于空實(shí)例的共享空數(shù)組實(shí)例氧猬，就是默認(rèn)空構(gòu)造中使用，默認(rèn)使elementData = EMPTY_ELEMENTDATA
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 默認(rèn)初始容量
*/
private static final int DEFAULT_CAPACITY = 10;
ArrayList包含了兩個(gè)重要的對(duì)象：elementData 和 size坏瘩。
(1) elementData 是"Object[]類型的數(shù)組"盅抚，它保存了添加到ArrayList中的元素。實(shí)際上桑腮，elementData是個(gè)動(dòng)態(tài)數(shù)組，我們能通過(guò)構(gòu)造函數(shù) ArrayList(int initialCapacity)來(lái)執(zhí)行它的初始容量為initialCapacity蛉幸；如果通過(guò)不含參數(shù)的構(gòu)造函數(shù)ArrayList()來(lái)創(chuàng)建ArrayList破讨，則elementData的容量默認(rèn)是10。elementData數(shù)組的大小會(huì)根據(jù)ArrayList容量的增長(zhǎng)而動(dòng)態(tài)的增長(zhǎng)奕纫，具體的增長(zhǎng)方式提陶，請(qǐng)參考源碼分析中的ensureCapacity()函數(shù)。
(2) size 則是動(dòng)態(tài)數(shù)組的實(shí)際大小匹层。
ArrayList構(gòu)造函數(shù)
// ArrayList帶容量大小的構(gòu)造函數(shù)隙笆。
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
// 新建一個(gè)數(shù)組
this.elementData = new Object[initialCapacity];
}
/**
*舊版，ArrayList無(wú)參構(gòu)造函數(shù)升筏。默認(rèn)容量是10撑柔。
** /
public ArrayList() {
this(10);
}
/**
*新版sdk中，會(huì)讓初始容量為空您访，
*在擴(kuò)容時(shí)判斷elementData = EMPTY_ELEMENTDATA铅忿，為空時(shí)再動(dòng)
*態(tài)增加容量
*/
public ArrayList() {
super();
this.elementData = EMPTY_ELEMENTDATA;
}
//即下面這個(gè)方法，后面會(huì)提到這個(gè)方法
private void ensureCapacityInternal(int minCapacity) {
if (elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
......
}
// 構(gòu)造一個(gè)包含指定元素的list灵汪，這些元素的是按照Collection的迭代器返回的順序排列的
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
size = elementData.length;
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}
- 第一個(gè)構(gòu)造方法使用提供的initialCapacity來(lái)初始化elementData數(shù)組的大小檀训。
- 第二個(gè)構(gòu)造方法調(diào)用第一個(gè)構(gòu)造方法并傳入?yún)?shù)10柑潦，即默認(rèn)elementData數(shù)組的大小為10。
- 第三個(gè)構(gòu)造方法則將提供的集合轉(zhuǎn)成數(shù)組返回給elementData（返回若不是Object[]將調(diào)用Arrays.copyOf方法將其轉(zhuǎn)為Object[]）峻凫。
API方法摘要
ArrayList源碼解析(基于JDK1.6.0_45)
增加
/**
* 添加一個(gè)元素
*/
public boolean add(E e) {
// 進(jìn)行擴(kuò)容檢查
ensureCapacity( size + 1); // Increments modCount
// 將e增加至list的數(shù)據(jù)尾部渗鬼，容量+1
elementData[size ++] = e;
return true;
}
/**
* 在指定位置添加一個(gè)元素
*/
public void add(int index, E element) {
// 判斷索引是否越界，這里會(huì)拋出多么熟悉的異常荧琼。譬胎。。
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: " +size);
// 進(jìn)行擴(kuò)容檢查
ensureCapacity( size+1); // Increments modCount
// 對(duì)數(shù)組進(jìn)行復(fù)制處理铭腕，目的就是空出index的位置插入element银择，并將index后的元素位移一個(gè)位置
System. arraycopy(elementData, index, elementData, index + 1,
size - index);
// 將指定的index位置賦值為element
elementData[index] = element;
// list容量+1
size++;
}
/**
* 增加一個(gè)集合元素
*/
public boolean addAll(Collection<? extends E> c) {
//將c轉(zhuǎn)換為數(shù)組
Object[] a = c.toArray();
int numNew = a.length ;
//擴(kuò)容檢查
ensureCapacity( size + numNew); // Increments modCount
//將c添加至list的數(shù)據(jù)尾部
System. arraycopy(a, 0, elementData, size, numNew);
//更新當(dāng)前容器大小
size += numNew;
return numNew != 0;
}
/**
* 在指定位置，增加一個(gè)集合元素
*/
public boolean addAll(int index, Collection<? extends E> c) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: " + index + ", Size: " + size);
Object[] a = c.toArray();
int numNew = a.length ;
ensureCapacity( size + numNew); // Increments modCount
// 計(jì)算需要移動(dòng)的長(zhǎng)度（index之后的元素個(gè)數(shù)）
int numMoved = size - index;
// 數(shù)組復(fù)制累舷，空出第index到index+numNum的位置浩考，即將數(shù)組index后的元素向右移動(dòng)numNum個(gè)位置
if (numMoved > 0)
System. arraycopy(elementData, index, elementData, index + numNew,
numMoved);
// 將要插入的集合元素復(fù)制到數(shù)組空出的位置中
System. arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
/**
* 數(shù)組容量檢查，不夠時(shí)則進(jìn)行擴(kuò)容
*/
public void ensureCapacity( int minCapacity) {
modCount++;
// 當(dāng)前數(shù)組的長(zhǎng)度
int oldCapacity = elementData .length;
// 最小需要的容量大于當(dāng)前數(shù)組的長(zhǎng)度則進(jìn)行擴(kuò)容
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
// 新擴(kuò)容的數(shù)組長(zhǎng)度為舊容量的1.5倍+1
int newCapacity = (oldCapacity * 3)/2 + 1;
// 如果新擴(kuò)容的數(shù)組長(zhǎng)度還是比最小需要的容量小被盈，則以最小需要的容量為長(zhǎng)度進(jìn)行擴(kuò)容
if (newCapacity < minCapacity)
newCapacity = minCapacity;
// minCapacity is usually close to size, so this is a win:
// 進(jìn)行數(shù)據(jù)拷貝析孽，Arrays.copyOf底層實(shí)現(xiàn)是System.arrayCopy()
elementData = Arrays.copyOf( elementData, newCapacity);
}
}
刪除
/**
* 根據(jù)索引位置刪除元素
*/
public E remove( int index) {
// 數(shù)組越界檢查
RangeCheck(index);
modCount++;
// 取出要?jiǎng)h除位置的元素，供返回使用
E oldValue = (E) elementData[index];
// 計(jì)算數(shù)組要復(fù)制的數(shù)量
int numMoved = size - index - 1;
// 數(shù)組復(fù)制只怎，就是將index之后的元素往前移動(dòng)一個(gè)位置
if (numMoved > 0)
System. arraycopy(elementData, index+1, elementData, index,
numMoved);
// 將數(shù)組最后一個(gè)元素置空（因?yàn)閯h除了一個(gè)元素袜瞬，然后index后面的元素都向前移動(dòng)了，所以最后一個(gè)就沒(méi)用了）身堡，好讓gc盡快回收
// 不要忘了size減一
elementData[--size ] = null; // Let gc do its work
return oldValue;
}
/**
* 根據(jù)元素內(nèi)容刪除邓尤，只刪除匹配的第一個(gè)
*/
public boolean remove(Object o) {
// 對(duì)要?jiǎng)h除的元素進(jìn)行null判斷
// 對(duì)數(shù)據(jù)元素進(jìn)行遍歷查找，知道找到第一個(gè)要?jiǎng)h除的元素贴谎，刪除后進(jìn)行返回汞扎，如果要?jiǎng)h除的元素正好是最后一個(gè)那就慘了，時(shí)間復(fù)雜度可達(dá)O(n) 擅这。澈魄。。
if (o == null) {
for (int index = 0; index < size; index++)
// null值要用==比較
if (elementData [index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
// 非null當(dāng)然是用equals比較了
if (o.equals(elementData [index])) {
fastRemove(index);
return true;
}
}
return false;
}
/*
* Private remove method that skips bounds checking and does not
* return the value removed.
*/
private void fastRemove(int index) {
modCount++;
// 原理和之前的add一樣仲翎，還是進(jìn)行數(shù)組復(fù)制痹扇，將index后的元素向前移動(dòng)一個(gè)位置，不細(xì)解釋了溯香，
int numMoved = size - index - 1;
if (numMoved > 0)
System. arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size ] = null; // Let gc do its work
}
/**
* 數(shù)組越界檢查
*/
private void RangeCheck(int index) {
if (index >= size )
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: " +size);
}
增加和刪除方法到這里就解釋完了鲫构，代碼是很簡(jiǎn)單，主要需要特別關(guān)心的就兩個(gè)地方：1.數(shù)組擴(kuò)容玫坛，2.數(shù)組復(fù)制芬迄，這兩個(gè)操作都是極費(fèi)效率的，最慘的情況下(添加到list第一個(gè)位置，刪除list最后一個(gè)元素或刪除list第一個(gè)索引位置的元素)時(shí)間復(fù)雜度可達(dá)O(n)禀梳。
還記得上面那個(gè)坑嗎（為什么提供一個(gè)可以指定容量大小的構(gòu)造方法 ）杜窄？看到這里是不是有點(diǎn)明白了呢，簡(jiǎn)單解釋下：如果數(shù)組初試容量過(guò)小算途，假設(shè)默認(rèn)的10個(gè)大小塞耕，而我們使用ArrayList的主要操作時(shí)增加元素，不斷的增加嘴瓤，一直增加扫外，不停的增加，會(huì)出現(xiàn)上面后果廓脆？那就是數(shù)組容量不斷的受挑釁筛谚，數(shù)組需要不斷的進(jìn)行擴(kuò)容，擴(kuò)容的過(guò)程就是數(shù)組拷貝System.arraycopy的過(guò)程停忿，每一次擴(kuò)容就會(huì)開(kāi)辟一塊新的內(nèi)存空間和數(shù)據(jù)的復(fù)制移動(dòng)驾讲，這樣勢(shì)必對(duì)性能造成影響。那么在這種以寫(xiě)為主（寫(xiě)會(huì)擴(kuò)容席赂，刪不會(huì)縮容）場(chǎng)景下吮铭，提前預(yù)知性的設(shè)置一個(gè)大容量，便可減少擴(kuò)容的次數(shù)颅停，提高了性能谓晌。
上面兩張圖分別是數(shù)組擴(kuò)容和數(shù)組復(fù)制的過(guò)程，需要注意的是癞揉，數(shù)組擴(kuò)容伴隨著開(kāi)辟新建的內(nèi)存空間以創(chuàng)建新數(shù)組然后進(jìn)行數(shù)據(jù)復(fù)制纸肉，而數(shù)組復(fù)制不需要開(kāi)辟新內(nèi)存空間，只需將數(shù)據(jù)進(jìn)行復(fù)制喊熟。
上面講增加元素可能會(huì)進(jìn)行擴(kuò)容柏肪，而刪除元素卻不會(huì)進(jìn)行縮容，如果在已刪除為主的場(chǎng)景下使用list逊移，一直不停的刪除而很少進(jìn)行增加预吆，那么會(huì)出現(xiàn)什么情況龙填？再或者數(shù)組進(jìn)行一次大擴(kuò)容后胳泉，我們后續(xù)只使用了幾個(gè)空間，會(huì)出現(xiàn)上面情況岩遗？當(dāng)然是空間浪費(fèi)啦啦啦扇商，怎么辦呢？
/**
* 將底層數(shù)組的容量調(diào)整為當(dāng)前實(shí)際元素的大小宿礁，來(lái)釋放空間案铺。
*/
public void trimToSize() {
modCount++;
// 當(dāng)前數(shù)組的容量
int oldCapacity = elementData .length;
// 如果當(dāng)前實(shí)際元素大小 小于 當(dāng)前數(shù)組的容量，則進(jìn)行縮容
if (size < oldCapacity) {
elementData = Arrays.copyOf( elementData, size );
}
更新
/**
* 將指定位置的元素更新為新元素
*/
public E set( int index, E element) {
// 數(shù)組越界檢查
RangeCheck(index);
// 取出要更新位置的元素梆靖，供返回使用
E oldValue = (E) elementData[index];
// 將該位置賦值為行的元素
elementData[index] = element;
// 返回舊元素
return oldValue;
}
查找
/**
* 查找指定位置上的元素
*/
public E get( int index) {
RangeCheck(index);
return (E) elementData [index];
}
是否包含
/**
* Returns <tt>true</tt> if this list contains the specified element.
* More formally, returns <tt>true</tt> if and only if this list contains
* at least one element <tt>e</tt> such that
* <tt>(o==null ? e==null : o.equals(e))</tt>.
*
* @param o element whose presence in this list is to be tested
* @return <tt> true</tt> if this list contains the specified element
*/
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
/**
* Returns the index of the first occurrence of the specified element
* in this list, or -1 if this list does not contain the element.
* More formally, returns the lowest index <tt>i</tt> such that
* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
* or -1 if there is no such index.
*/
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData [i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData [i]))
return i;
}
return -1;
}
/**
* Returns the index of the last occurrence of the specified element
* in this list, or -1 if this list does not contain the element.
* More formally, returns the highest index <tt>i</tt> such that
* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
* or -1 if there is no such index.
*/
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData [i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData [i]))
return i;
}
return -1;
}
contains主要是檢查indexOf控汉，也就是元素在list中出現(xiàn)的索引位置也就是數(shù)組下標(biāo)笔诵，再看indexOf和lastIndexOf代碼是不是很熟悉，沒(méi)錯(cuò)姑子，和public boolean remove(Object o) 的代碼一樣乎婿，都是元素null判斷，都是循環(huán)比較街佑，不多說(shuō)了谢翎。。沐旨。但是要知道森逮，最差的情況（要找的元素是最后一個(gè)）也是很慘的。磁携。褒侧。
容量判斷
/**
* Returns the number of elements in this list.
*
* @return the number of elements in this list
*/
public int size() {
return size ;
}
/**
* Returns <tt>true</tt> if this list contains no elements.
*
* @return <tt> true</tt> if this list contains no elements
*/
public boolean isEmpty() {
return size == 0;
}
由于使用了size進(jìn)行計(jì)數(shù)，發(fā)現(xiàn)list大小獲取和判斷真的好容易颜武。
總結(jié)：
(01) ArrayList 實(shí)際上是通過(guò)一個(gè)數(shù)組去保存數(shù)據(jù)的璃搜。當(dāng)我們構(gòu)造ArrayList時(shí)；若使用默認(rèn)構(gòu)造函數(shù)鳞上，則ArrayList的默認(rèn)容量大小是10这吻。
(02) 當(dāng)ArrayList容量不足以容納全部元素時(shí)，ArrayList會(huì)重新設(shè)置容量：新的容量=“原始容量 + 原始容量*2”篙议。
(03) ArrayList的克隆函數(shù)唾糯，即是將全部元素克隆到一個(gè)數(shù)組中。
(04) ArrayList實(shí)現(xiàn)java.io.Serializable的方式鬼贱。當(dāng)寫(xiě)入到輸出流時(shí)移怯，先寫(xiě)入“容量”，再依次寫(xiě)入“每一個(gè)元素”这难；當(dāng)讀出輸入流時(shí)舟误，先讀取“容量”，再依次讀取“每一個(gè)元素”姻乓。
ArrayList遍歷方式
ArrayList支持3種遍歷方式
(01) 第一種嵌溢，通過(guò)迭代器遍歷饭聚。即通過(guò)Iterator去遍歷漓踢。
Integer value = null;
Iterator iter = list.iterator();
while (iter.hasNext()) {
value = (Integer)iter.next();
}
(02) 第二種，隨機(jī)訪問(wèn)乡翅，通過(guò)索引值去遍歷剪个。
由于ArrayList實(shí)現(xiàn)了RandomAccess接口秧骑，它支持通過(guò)索引值去隨機(jī)訪問(wèn)元素。
Integer value = null;
int size = list.size();
for (int i=0; i<size; i++) {
value = (Integer)list.get(i);
}
(03) 第三種，for循環(huán)遍歷乎折。如下：
Integer value = null;
for (Integer integ:list) {
value = integ;
}
下面通過(guò)一個(gè)實(shí)例绒疗，比較這3種方式的效率，實(shí)例代碼(ArrayListRandomAccessTest.java)如下：
import java.util.*;
import java.util.concurrent.*;
/*
* @desc ArrayList遍歷方式和效率的測(cè)試程序骂澄。
*
* @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.size(); 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");
}
}
運(yùn)行結(jié)果：
iteratorThroughRandomAccess：3 ms
iteratorThroughIterator：8 ms
iteratorThroughFor2：5 ms
由此可見(jiàn)忌堂，遍歷ArrayList時(shí)，使用隨機(jī)訪問(wèn)(即酗洒，通過(guò)索引序號(hào)訪問(wèn))效率最高士修，而使用迭代器的效率最低！
ArrayList示例
本文通過(guò)一個(gè)實(shí)例(ArrayListTest.java)樱衷，介紹 ArrayList 中常用API的用法棋嘲。
import java.util.*;
/*
* @desc ArrayList常用API的測(cè)試程序
* @author skywang
* @email kuiwu-wang@163.com
*/
public class ArrayListTest {
public static void main(String[] args) {
// 創(chuàng)建ArrayList
ArrayList list = new ArrayList();
// 將“”
list.add("1");
list.add("2");
list.add("3");
list.add("4");
// 將下面的元素添加到第1個(gè)位置
list.add(0, "5");
// 獲取第1個(gè)元素
System.out.println("the first element is: "+ list.get(0));
// 刪除“3”
list.remove("3");
// 獲取ArrayList的大小
System.out.println("Arraylist size=: "+ list.size());
// 判斷l(xiāng)ist中是否包含"3"
System.out.println("ArrayList contains 3 is: "+ list.contains(3));
// 設(shè)置第2個(gè)元素為10
list.set(1, "10");
// 通過(guò)Iterator遍歷ArrayList
for(Iterator iter = list.iterator(); iter.hasNext(); ) {
System.out.println("next is: "+ iter.next());
}
// 將ArrayList轉(zhuǎn)換為數(shù)組
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());
}
}
運(yùn)行結(jié)果：
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
總結(jié)
ArrayList和LinkedList的區(qū)別
- ArrayList是實(shí)現(xiàn)了基于動(dòng)態(tài)數(shù)組的數(shù)據(jù)結(jié)構(gòu)，LinkedList基于鏈表的數(shù)據(jù)結(jié)構(gòu)矩桂。
- 對(duì)于隨機(jī)訪問(wèn)get和set沸移，ArrayList覺(jué)得優(yōu)于LinkedList，因?yàn)長(zhǎng)inkedList要移動(dòng)指針侄榴。
- 對(duì)于新增和刪除操作add和remove雹锣，LinkedList比較占優(yōu)勢(shì)，因?yàn)锳rrayList要移動(dòng)數(shù)據(jù)癞蚕。
ArrayList和Vector的區(qū)別
- Vector和ArrayList幾乎是完全相同的,唯一的區(qū)別在于Vector是同步類(synchronized)蕊爵，屬于強(qiáng)同步類。因此開(kāi)銷就比ArrayList要大桦山，訪問(wèn)要慢攒射。正常情況下,大多數(shù)的Java程序員使用ArrayList而不是Vector,因?yàn)橥酵耆梢杂沙绦騿T自己來(lái)控制。
- Vector每次擴(kuò)容請(qǐng)求其大小的2倍空間恒水，而ArrayList是1.5倍会放。
- Vector還有一個(gè)子類Stack.
