Java中ArrayList用法詳細講解
1、基本用法
ArrayList是一個泛型容器，新建ArrayList需要實例化泛型參數(shù)，比如：
ArrayList<Integer> intList = new ArrayList<Integer>(); ArrayList<String> strList = new ArrayList<String>();
ArrayList的主要方法有：
public boolean add(E e) //添加元素到末尾 public boolean isEmpty() //判斷是否為空 public int size() //獲取長度 public E get(int index) //訪問指定位置的元素 public int indexOf(Object o) //查找元素， 如果找到，返回索引位置，否則返回-1 public int lastIndexOf(Object o) //從后往前找 public boolean contains(Object o) //是否包含指定元素，依據(jù)是equals方法的返回值 public E remove(int index) //刪除指定位置的元素， 返回值為被刪對象 //刪除指定對象，只刪除第一個相同的對象，返回值表示是否刪除了元素 //如果o為null，則刪除值為null的元素 public boolean remove(Object o) public void clear() //刪除所有元素 //在指定位置插入元素，index為0表示插入最前面，index為ArrayList的長度表示插到最后面 public void add(int index, E element) public E set(int index, E element) //修改指定位置的元素內容
這些方法簡單直接，就不多解釋了，我們看個簡單示例：
ArrayList<String> strList = new ArrayList<String>();
strList.add("老馬");
strList.add("編程");
for(int i=0; i<strList.size(); i++){
System.out.println(strList.get(i));
}
2、基本原理
可以看出，ArrayList的基本用法是比較簡單的，它的基本原理也是比較簡單的。Array-List的內部有一個數(shù)組elementData，一般會有一些預留的空間，有一個整數(shù)size記錄實際的元素個數(shù)（基于Java 7）?，如下所示：
private transient Object[] elementData; private int size;
我們暫時可以忽略transient這個關鍵字。各種public方法內部操作的基本都是這個數(shù)組和這個整數(shù)，elementData會隨著實際元素個數(shù)的增多而重新分配，而size則始終記錄實際的元素個數(shù)。
下面，我們具體來看下add和remove方法的實現(xiàn)。add方法的主要代碼為：
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
它首先調用ensureCapacityInternal確保數(shù)組容量是夠的，ensureCapacityInternal的代碼是：
private void ensureCapacityInternal(int minCapacity) {
if(elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
它先判斷數(shù)組是不是空的，如果是空的，則首次至少要分配的大小為DEFAULT_CAPACITY,DEFAULT_CAPACITY的值為10，接下來調用ensureExplicitCapacity，主要代碼為：
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if(minCapacity - elementData.length > 0)
grow(minCapacity);
}
modCount++是什么意思呢？modCount表示內部的修改次數(shù)，modCount++當然就是增加修改次數(shù)，為什么要記錄修改次數(shù)呢？我們待會解釋。
如果需要的長度大于當前數(shù)組的長度，則調用grow方法，其主要代碼為：
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//右移一位相當于除2，所以，newCapacity相當于oldCapacity的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果擴展1.5倍還是小于minCapacity，就擴展為minCapacity
if(newCapacity - minCapacity < 0)
newCapacity = minCapacity;
elementData = Arrays.copyOf(elementData, newCapacity);
}
代碼中已有注釋說明，不再贅述。我們再來看remove方法的代碼：
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1; //計算要移動的元素個數(shù)
if(numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
elementData[--size] = null; //將size減1，同時釋放引用以便原對象被垃圾回收
return oldValue;
}
它也增加了modCount，然后計算要移動的元素個數(shù)，從index往后的元素都往前移動一位，實際調用System.arraycopy方法移動元素。elementData[–size]= null；這行代碼將size減1，同時將最后一個位置設為null，設為null后不再引用原來對象，如果原來對象也不再被其他對象引用，就可以被垃圾回收。
其他方法大多是比較簡單的，我們就不贅述了。上面的代碼中，為便于理解，我們刪減了一些邊界情況處理的代碼，完整代碼要晦澀復雜一些，但接口一般都是簡單直接的，這就是使用容器類的好處，這也是計算機程序中的基本思維方式，封裝復雜操作，提供簡化接口。
3、迭代
理解了ArrayList的基本用法和原理，接下來，我們來看一個ArrayList的常見操作：迭代。我們看一個迭代操作的例子，循環(huán)打印ArrayList中的每個元素，ArrayList支持foreach語法：
ArrayList<Integer> intList = new ArrayList<Integer>();
intList.add(123);
intList.add(456);
intList.add(789);
for(Integer a : intList){
System.out.println(a);
}
當然，這種循環(huán)也可以使用如下代碼實現(xiàn)：
for(int i=0; i<intList.size(); i++){
System.out.println(intList.get(i));
}
不過，foreach看上去更為簡潔，而且它適用于各種容器，更為通用。
這種foreach語法背后是怎么實現(xiàn)的呢？其實，編譯器會將它轉換為類似如下代碼：
Iterator<Integer> it = intList.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
接下來，我們解釋其中的代碼。
3.1、 迭代器接口
ArrayList實現(xiàn)了Iterable接口，Iterable表示可迭代，Java7中的定義為：
public interface Iterable<T> {
Iterator<T> iterator();
}
定義很簡單，就是要求實現(xiàn)iterator方法。iterator方法的聲明為：
public Iterator<E> iterator()
它返回一個實現(xiàn)了Iterator接口的對象，Java 7中Iterator 接口的定義為：
public interface Iterator<E> {
boolean hasNext();
E next();
void remove();
}
hasNext()判斷是否還有元素未訪問，next()返回下一個元素，remove()刪除最后返回的元素，只讀訪問的基本模式類似于：
Iterator<Integer> it = intList.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
我們待會再看迭代中間要刪除元素的情況。
只要對象實現(xiàn)了Iterable接口，就可以使用foreach語法，編譯器會轉換為調用Iterable和Iterator接口的方法。初次見到Iterable和Iterator，可能會比較容易混淆，我們再澄清一下：
- Iterable表示對象可以被迭代，它有一個方法iterator()，返回Iterator對象，實際通過Iterator接口的方法進行遍歷；
- 如果對象實現(xiàn)了Iterable，就可以使用foreach語法；
- 類可以不實現(xiàn)Iterable，也可以創(chuàng)建Iterator對象。
需要了解的是，Java 8對Iterable添加了默認方法forEach和spliterator，對Iterator增加了默認方法forEachRemaining和remove，具體可參見API文檔。
3.2、ListIterator
除了iterator(), ArrayList還提供了兩個返回Iterator接口的方法：
public ListIterator<E> listIterator() public ListIterator<E> listIterator(int index)
ListIterator擴展了Iterator接口，增加了一些方法，向前遍歷、添加元素、修改元素、返回索引位置等，添加的方法有：
public interface ListIterator<E> extends Iterator<E> {
boolean hasPrevious();
E previous();
int nextIndex();
int previousIndex();
void set(E e);
void add(E e);
}
listIterator()方法返回的迭代器從0開始，而listIterator(int index)方法返回的迭代器從指定位置index開始。比如，從末尾往前遍歷，代碼為：
public void reverseTraverse(List<Integer> list){
ListIterator<Integer> it = list.listIterator(list.size());
while(it.hasPrevious()){
System.out.println(it.previous());
}
}
3.3、迭代的陷阱
關于迭代器，有一種常見的誤用，就是在迭代的中間調用容器的刪除方法。比如，要刪除一個整數(shù)ArrayList中所有小于100的數(shù)，直覺上，代碼可以這么寫：
public void remove(ArrayList<Integer> list){
for(Integer a : list){
if(a<=100){
list.remove(a);
}
}
}
但運行時會拋出異常：
java.util.ConcurrentModificationException
發(fā)生了并發(fā)修改異常，為什么呢？因為迭代器內部會維護一些索引位置相關的數(shù)據(jù)，要求在迭代過程中，容器不能發(fā)生結構性變化，否則這些索引位置就失效了。所謂結構性變化就是添加、插入和刪除元素，只是修改元素內容不算結構性變化。
如何避免異常呢？可以使用迭代器的remove方法，如下所示：
public static void remove(ArrayList<Integer> list){
Iterator<Integer> it = list.iterator();
while(it.hasNext()){
if(it.next()<=100){
it.remove();
}
}
}
迭代器如何知道發(fā)生了結構性變化，并拋出異常？它自己的remove方法為何又可以使用呢？我們需要看下迭代器實現(xiàn)的原理。
3.4、迭代器實現(xiàn)的原理
我們來看下ArrayList中iterator方法的實現(xiàn)，代碼為：
public Iterator<E> iterator() {
return new Itr();
}
新建了一個Itr對象，Itr是一個成員內部類，實現(xiàn)了Iterator接口，聲明為：
private class Itr implements Iterator<E>
它有三個實例成員變量，為：
int cursor; //下一個要返回的元素位置 int lastRet = -1; //最后一個返回的索引位置，如果沒有，為-1 int expectedModCount = modCount;
cursor表示下一個要返回的元素位置，lastRet表示最后一個返回的索引位置，expected-ModCount表示期望的修改次數(shù)，初始化為外部類當前的修改次數(shù)modCount，回顧一下，成員內部類可以直接訪問外部類的實例變量。每次發(fā)生結構性變化的時候modCount都會增加，而每次迭代器操作的時候都會檢查expectedModCount是否與modCount相同，這樣就能檢測出結構性變化。
我們來具體看下，它是如何實現(xiàn)Iterator接口中的每個方法的，先看hasNext()，代碼為：
public boolean hasNext() {
return cursor ! = size;
}
cursor與size比較，比較直接，看next方法：
public E next() {
checkForComodification();
int i = cursor;
if(i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if(i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
首先調用了checkForComodification，它的代碼為：
final void checkForComodification() {
if(modCount ! = expectedModCount)
throw new ConcurrentModificationException();
}
所以，next前面部分主要就是在檢查是否發(fā)生了結構性變化，如果沒有變化，就更新cursor和lastRet的值，以保持其語義，然后返回對應的元素。remove的代碼為：
public void remove() {
if(lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
它調用了ArrayList的remove方法，但同時更新了cursor、lastRet和expectedModCount的值，所以它可以正確刪除。不過，需要注意的是，調用remove方法前必須先調用next，比如，通過迭代器刪除所有元素，直覺上，可以這么寫：
public static void removeAll(ArrayList<Integer> list){
Iterator<Integer> it = list.iterator();
while(it.hasNext()){
it.remove();
}
}
實際運行，會拋出異常java.lang.IllegalStateException，正確寫法是：
public static void removeAll(ArrayList<Integer> list){
Iterator<Integer> it = list.iterator();
while(it.hasNext()){
it.next();
it.remove();
}
}
當然，如果只是要刪除所有元素，ArrayList有現(xiàn)成的方法clear()。
listIterator()的實現(xiàn)使用了另一個內部類ListItr，它繼承自Itr，基本思路類似，我們就不贅述了。
3.5、迭代器的好處
為什么要通過迭代器這種方式訪問元素呢？直接使用size()/get(index)語法不也可以嗎？在一些場景下，確實沒有什么差別，兩者都可以。不過，foreach語法更為簡潔一些，更重要的是，迭代器語法更為通用，它適用于各種容器類。
此外，迭代器表示的是一種關注點分離的思想，將數(shù)據(jù)的實際組織方式與數(shù)據(jù)的迭代遍歷相分離，是一種常見的設計模式。需要訪問容器元素的代碼只需要一個Iterator接口的引用，不需要關注數(shù)據(jù)的實際組織方式，可以使用一致和統(tǒng)一的方式進行訪問。
而提供Iterator接口的代碼了解數(shù)據(jù)的組織方式，可以提供高效的實現(xiàn)。在ArrayList中， size/get(index)語法與迭代器性能是差不多的，但在后續(xù)介紹的其他容器中，則不一定，比如LinkedList，迭代器性能就要高很多。
從封裝的思路上講，迭代器封裝了各種數(shù)據(jù)組織方式的迭代操作，提供了簡單和一致的接口。
4、ArrayList實現(xiàn)的接口
4.1、Coolection
Collection表示一個數(shù)據(jù)集合，數(shù)據(jù)間沒有位置或順序的概念，Java 7中的接口定義為：
public interface Collection<E> extends Iterable<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection<? > c);
boolean addAll(Collection<? extends E> c);
boolean removeAll(Collection<? > c);
boolean retainAll(Collection<? > c);
void clear();
boolean equals(Object o);
int hashCode();
}
這些方法中，除了兩個toArray方法和幾個xxxAll()方法外，其他我們已經(jīng)介紹過了。toArray方法我們待會再介紹。這幾個xxxAll()方法的含義基本也是可以顧名思義的， addAll表示添加，removeAll表示刪除，containsAll表示檢查是否包含了參數(shù)容器中的所有元素，只有全包含才返回true, retainAll表示只保留參數(shù)容器中的元素，其他元素會進行刪除。Java 8對Collection接口添加了幾個默認方法，包括removeIf、stream、spliterator等，具體可參見API文檔。
抽象類AbstractCollection對這幾個方法都提供了默認實現(xiàn)，實現(xiàn)的方式就是利用迭代器方法逐個操作。比如，我們看removeAll方法，代碼為：
public boolean removeAll(Collection<? > c) {
boolean modified = false;
Iterator<? > it = iterator();
while(it.hasNext()) {
if(c.contains(it.next())) {
it.remove();
modified = true;
}
}
return modified;
}
代碼比較簡單，就不解釋了。ArrayList繼承了AbstractList，而AbstractList又繼承了AbstractCollection, ArrayList對其中一些方法進行了重寫，以提供更為高效的實現(xiàn)，具體不再介紹。
4.2、List
List表示有順序或位置的數(shù)據(jù)集合，它擴展了Collection，增加的主要方法有（Java 7）?：
boolean addAll(int index, Collection<? extends E> c); E get(int index); E set(int index, E element); void add(int index, E element); E remove(int index); int indexOf(Object o); int lastIndexOf(Object o); ListIterator<E> listIterator(); ListIterator<E> listIterator(int index); List<E> subList(int fromIndex, int toIndex);
這些方法都與位置有關，容易理解，就不介紹了。Java 8對List接口增加了幾個默認方法，包括sort、replaceAll和spliterator; Java 9增加了多個重載的of方法，可以根據(jù)一個或多個元素生成一個不變的List，具體就不介紹了，可參看API文檔。
4.3、RandomAccess
RandomAccess的定義為：
public interface RandomAccess {
}
沒有定義任何代碼。這有什么用呢？這種沒有任何代碼的接口在Java中被稱為標記接口，用于聲明類的一種屬性。
這里，實現(xiàn)了RandomAccess接口的類表示可以隨機訪問，可隨機訪問就是具備類似數(shù)組那樣的特性，數(shù)據(jù)在內存是連續(xù)存放的，根據(jù)索引值就可以直接定位到具體的元素，訪問效率很高。
有沒有聲明RandomAccess有什么關系呢？主要用于一些通用的算法代碼中，它可以根據(jù)這個聲明而選擇效率更高的實現(xiàn)。比如，Collections類中有一個方法binarySearch，在List中進行二分查找，它的實現(xiàn)代碼就根據(jù)list是否實現(xiàn)了RandomAccess而采用不同的實現(xiàn)機制，如下所示：
public static <T>
int binarySearch(List<? extends Comparable<? super T>> list, T key) {
if(list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
return Collections.indexedBinarySearch(list, key);
else
return Collections.iteratorBinarySearch(list, key);
}
5、ArrayList的其他方法
ArrayList中還有一些其他方法，包括構造方法、與數(shù)組的相互轉換、容量大小控制等，我們來看下。ArrayList還有兩個構造方法：
public ArrayList(int initialCapacity) public ArrayList(Collection<? extends E> c)
第一個方法以指定的大小initialCapacity初始化內部的數(shù)組大小，代碼為：
this.elementData = new Object[initialCapacity];
在事先知道元素長度的情況下，或者，預先知道長度上限的情況下，使用這個構造方法可以避免重新分配和復制數(shù)組。第二個構造方法以一個已有的Collection構建，數(shù)據(jù)會新復制一份。
ArrayList中有兩個方法可以返回數(shù)組：
public Object[] toArray() public <T> T[] toArray(T[] a)
第一個方法返回是Object數(shù)組，代碼為：
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
第二個方法返回對應類型的數(shù)組，如果參數(shù)數(shù)組長度足以容納所有元素，就使用該數(shù)組，否則就新建一個數(shù)組，比如：
ArrayList<Integer> intList = new ArrayList<Integer>(); intList.add(123); intList.add(456); intList.add(789); Integer[] arrA = new Integer[3]; intList.toArray(arrA); Integer[] arrB = intList.toArray(new Integer[0]); System.out.println(Arrays.equals(arrA, arrB));
輸出為true，表示兩種方式都是可以的。
Arrays中有一個靜態(tài)方法asList可以返回對應的List，如下所示：
Integer[] a = {1,2,3};
List<Integer> list = Arrays.asList(a);
需要注意的是，這個方法返回的List，它的實現(xiàn)類并不是本節(jié)介紹的ArrayList，而是Arrays類的一個內部類，在這個內部類的實現(xiàn)中，內部用的數(shù)組就是傳入的數(shù)組，沒有拷貝，也不會動態(tài)改變大小，所以對數(shù)組的修改也會反映到List中，對List調用add、remove方法會拋出異常。
要使用ArrayList完整的方法，應該新建一個ArrayList，如下所示：
List<Integer> list = new ArrayList<Integer>(Arrays.asList(a));
ArrayList還提供了兩個public方法，可以控制內部使用的數(shù)組大小，一個是：
public void ensureCapacity(int minCapacity)
它可以確保數(shù)組的大小至少為minCapacity，如果不夠，會進行擴展。如果已經(jīng)預知ArrayList需要比較大的容量，調用這個方法可以減少ArrayList內部分配和擴展的次數(shù)。
另一個方法是：
public void trimToSize()
它會重新分配一個數(shù)組，大小剛好為實際內容的長度。調用這個方法可以節(jié)省數(shù)組占用的空間。
6、ArrayList特點分析
對于ArrayList，它的特點是內部采用動態(tài)數(shù)組實現(xiàn)，這決定了以下幾點。
- 可以隨機訪問，按照索引位置進行訪問效率很高，用算法描述中的術語，效率是O(1)，簡單說就是可以一步到位。
- 除非數(shù)組已排序，否則按照內容查找元素效率比較低，具體是O(N), N為數(shù)組內容長度，也就是說，性能與數(shù)組長度成正比。
- 添加元素的效率還可以，重新分配和復制數(shù)組的開銷被平攤了，具體來說，添加N個元素的效率為O(N)。
- 插入和刪除元素的效率比較低，因為需要移動元素，具體為O(N)。
總結
到此這篇關于Java中ArrayList用法的文章就介紹到這了,更多相關Java ArrayList用法內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要介紹了JAVA 循環(huán)結構的相關資料，文中講解的非常細致，示例代碼幫助大家更好的理解和學習，感興趣的朋友可以了解下2021-08-08
這篇文章主要為大家詳細介紹了Java實現(xiàn)三子棋小游戲簡易版，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-05-05
springboot 獲取訪問接口的請求的IP地址的實現(xiàn)
本文主要介紹了springboot獲取訪問接口的請求的IP地址的實現(xiàn)，文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-07-07
基于SpringBoot整合SSMP案例(開啟日志與分頁查詢條件查詢功能實現(xiàn))
這篇文章主要介紹了基于SpringBoot整合SSMP案例(開啟日志與分頁查詢條件查詢功能實現(xiàn)),本文通過實例代碼給大家介紹的非常詳細,對大家的學習或工作具有一定的參考借鑒價值,需要的朋參考下吧2023-11-11
這篇文章主要為大家介紹了spring-boot項目啟動遲緩異常排查解決記錄，突然在本地啟動不起來了，表象特征就是在本地IDEA上運行時，進程卡住也不退出，應用啟動時加載相關組件的日志也不輸出2022-02-02
Maven Shade插件它可以幫助你在構建項目時打包所有依賴項,并將其打包到一個單獨的JAR文件中,本文就介紹一下Maven Shade插件的具體使用,具有一定參考價值,感興趣的可以了解一下2023-08-08
這篇文章運用實例代碼給大家介紹了利用Java怎樣獲取文件名、類名、方法名和行號，有需要的可以參考借鑒，下面一起來看看吧。2016-08-08
本文主要介紹了Mybatis自定義攔截器實現(xiàn)權限功能,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧2024-12-12
詳解 Java中日期數(shù)據(jù)類型的處理之格式轉換的實例
這篇文章主要介紹了詳解 Java中日期數(shù)據(jù)類型的處理之格式轉換的實例的相關資料,日期以及時間格式處理，在Java中時間格式一般會涉及到的數(shù)據(jù)類型包括Calendar類和Date類，需要的朋友可以參考下2017-08-08
Java zookeeper圖形化工具ZooInspector用法詳解
這篇文章主要介紹了Java zookeeper圖形化工具ZooInspector用法詳解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2020-07-07