開篇前言--ArrayList中的基本方法

前面的博文中，小編主要簡單介紹java集合的總體架構，在接下來的博文中，小編將詳細介紹里面的各個類，通過demo、對比，來對java集合類進行更加深入的理解和認識，希望可以幫助有有需要的小伙伴們`(*∩_∩*)′，不足之處，還請小伙伴們多多指教哦`(*∩_∩*)′。今天這篇博文，小編主要介紹List接口中的ArrayList集合，ArrayList即數組列表，so，她肯定和數組有一定的關系，我們知道List集合的特征有兩個，一個是有序；第二個List里面的集合可以重復，既然ArrayList實現了List接口，那么毫無疑問，她肯定也存在這兩個特征，我們來看一個簡單的demo。新建一個class，命名為ArrayListTest，編寫相關代碼，如下所示：

package j2se.demo;import java.util.ArrayList;public class ArrayListTest {public static void main(String[] args) {ArrayList arrayList = new ArrayList();arrayList.add("hello");arrayList.add("world");arrayList.add("java");String s1=(String) arrayList.get(0);String s2=(String)arrayList.get(1);String s3=(String)arrayList.get(2);System.out.println(s1);System.out.println(s2);System.out.println(s3);}} 運行效果如下所示：

以上是ArrayList的基本用法，接著，我們來修改代碼，ArrayList可以添加重復的元素，我們來看下面的代碼部分：

package j2se.demo;import java.util.ArrayList;public class ArrayListTest {public static void main(String[] args) {ArrayList arrayList = new ArrayList();arrayList.add("hello");arrayList.add("world");arrayList.add("java");arrayList.add("java");String s1=(String) arrayList.get(0);String s2=(String)arrayList.get(1);String s3=(String)arrayList.get(2);String s4=(String)arrayList.get(3);System.out.println(s1);System.out.println(s2);System.out.println(s3);System.out.println(s4);}} 運行效果如下所示：

通過運行結果我們知道，說明第二個“java”已經添加進去了，我們發現，ArrayList是通過add進行添加的操作，通過get方法取出來；我們接著來看，size這個方法，返回列表中元素的個數；可是呢，取數據的時候一個一個取，非常的麻煩，所以，我們可以寫一個循環，如下所示：

package j2se.demo;import java.util.ArrayList;public class ArrayListTest {public static void main(String[] args) {ArrayList arrayList = new ArrayList();arrayList.add("hello");arrayList.add("world");arrayList.add("java");arrayList.add("java");String s1=(String) arrayList.get(0);String s2=(String)arrayList.get(1);String s3=(String)arrayList.get(2);String s4=(String)arrayList.get(3);System.out.println(s1);System.out.println(s2);System.out.println(s3);System.out.println(s4);System.out.println("----------");for(int i = 0 ;i<arrayList.size();i++){System.out.println(arrayList.get(i));}}} 運行效果如下所示：

size方法，用于獲取集合中元素的個數，接著我們來看Clear（）方法，編寫相關代碼，如下所示：

package j2se.demo;import java.util.ArrayList;public class ArrayListTest {public static void main(String[] args) {ArrayList arrayList = new ArrayList();arrayList.add("hello");arrayList.add("world");arrayList.add("java");arrayList.add("java");String s1=(String) arrayList.get(0);String s2=(String)arrayList.get(1);String s3=(String)arrayList.get(2);String s4=(String)arrayList.get(3);System.out.println(s1);System.out.println(s2);System.out.println(s3);System.out.println(s4);System.out.println("----------");for(int i = 0 ;i<arrayList.size();i++){System.out.println(arrayList.get(i));}arrayList.clear();System.out.println(arrayList.size());}} 運行效果如下所示：

接著，我們來看一下isEmpty這個方法，這個方法是用來判斷集合中是否有內容的一個方法，編寫相關代碼，如下所示：

package j2se.demo;import java.util.ArrayList;public class ArrayListTest {public static void main(String[] args) {ArrayList arrayList = new ArrayList();arrayList.add("hello");arrayList.add("world");arrayList.add("java");arrayList.add("java");String s1=(String) arrayList.get(0);String s2=(String)arrayList.get(1);String s3=(String)arrayList.get(2);String s4=(String)arrayList.get(3);System.out.println(s1);System.out.println(s2);System.out.println(s3);System.out.println(s4);System.out.println("----------");for(int i = 0 ;i<arrayList.size();i++){System.out.println(arrayList.get(i));}arrayList.clear();System.out.println(arrayList.isEmpty());}} 運行效果如下所示：

接著看，如何刪除一個元素呢，remove，刪除一個根據元素，我們可以根據索引刪除，還可以根據具體的對象進行刪除，編寫相關代碼，如下所示：

package j2se.demo;import java.util.ArrayList;public class ArrayListTest {public static void main(String[] args) {ArrayList arrayList = new ArrayList();arrayList.add("hello");arrayList.add("world");arrayList.add("java");arrayList.add("java");String s1=(String) arrayList.get(0);String s2=(String)arrayList.get(1);String s3=(String)arrayList.get(2);String s4=(String)arrayList.get(3);System.out.println(s1);System.out.println(s2);System.out.println(s3);System.out.println(s4);System.out.println("----------");for(int i = 0 ;i<arrayList.size();i++){System.out.println(arrayList.get(i));}// arrayList.clear(); // System.out.println(arrayList.isEmpty());arrayList.remove(0);System.out.println("----------");for(int i = 0 ;i<arrayList.size();i++){System.out.println(arrayList.get(i));}}} 運行，如下所示：

除此之外，我們還可以根據索引進行刪除，編寫相關代碼，如下所示：

package j2se.demo;import java.util.ArrayList;public class ArrayListTest {public static void main(String[] args) {ArrayList arrayList = new ArrayList();arrayList.add("hello");arrayList.add("world");arrayList.add("java");arrayList.add("java");String s1=(String) arrayList.get(0);String s2=(String)arrayList.get(1);String s3=(String)arrayList.get(2);String s4=(String)arrayList.get(3);System.out.println(s1);System.out.println(s2);System.out.println(s3);System.out.println(s4);System.out.println("----------");for(int i = 0 ;i<arrayList.size();i++){System.out.println(arrayList.get(i));}// arrayList.clear(); // System.out.println(arrayList.isEmpty());arrayList.remove(0);arrayList.remove("java");System.out.println("----------");for(int i = 0 ;i<arrayList.size();i++){System.out.println(arrayList.get(i));}}} 效果如下所示：

接著，我們添加兩個元素，打印，indexOf某個對象的索引在哪個位置上，代碼如下所示：

package j2se.demo;import java.util.ArrayList;public class ArrayListTest {public static void main(String[] args) {ArrayList arrayList = new ArrayList();arrayList.add("hello");arrayList.add("world");arrayList.add("java");arrayList.add("java");String s1=(String) arrayList.get(0);String s2=(String)arrayList.get(1);String s3=(String)arrayList.get(2);String s4=(String)arrayList.get(3);System.out.println(s1);System.out.println(s2);System.out.println(s3);System.out.println(s4);System.out.println("----------");for(int i = 0 ;i<arrayList.size();i++){System.out.println(arrayList.get(i));}// arrayList.clear(); // System.out.println(arrayList.isEmpty());arrayList.remove(0);arrayList.remove("java");System.out.println("----------");for(int i = 0 ;i<arrayList.size();i++){System.out.println(arrayList.get(i));}System.out.println("----------");arrayList.add("aaa");arrayList.add("bbb");System.out.println(arrayList.indexOf("aaa"));}} 運行，效果如下所示：

接著，我們新建一個類ArrayListTest1，編寫相關代碼：

package j2se.demo;import java.util.ArrayList;public class ArrayListTest1 {public static void main(String[] args) {ArrayList list = new ArrayList();list.add("hello");list.add(new Integer(2));String str=(String)list.get(0);Integer in = (Integer)list.get(1);System.out.println(str);System.out.println(in);}} 運行效果如下所示：

ArrayList本身接收的是對象，取出來的時候我們需要把他轉換成我們放進去的相應的類型。再來新建一個類ArrayListTest2，如何把集合轉成數組呢？編寫代碼，如下所示：

package j2se.demo;import java.util.ArrayList;public class ArrayListTest2 {public static void main(String[] args) {ArrayList list = new ArrayList();list.add(new Integer(1));list.add(new Integer(2));list.add(new Integer(3));list.add(new Integer(4));list.add(new Integer(5)); list.add(new Integer(6));/*** 不能將Object[]轉換成Integer[]*/Object[] in = list.toArray();for(int i = 0 ;i<in.length;i++){System.out.println(((Integer)in[i]).intValue());}}} 運行如下所示：

ArrayList底層部分源碼實現

前面介紹的都是ArrayList的基本方法，小伙伴們可以查詢API文檔，接著，我們來看ArrayList她自己本身是如何實現的，首先：

a、對于任何一個集合來說，集合中存放的是對象的引用，而不是對象本身。
b、ArrayList底層采用數組實現，當使用不帶參數的構成方法生成ArrayList對象的時候，實際上會在底層生成一個長度為10的Object類型數組。簡單來說ArrayList內部實現是數組。
c、如果增加的元素個數超過了10個，那么ArrayList底層會新生成一個數組，長度為原來數組的1.5倍，然后將原數組的內容復制到新數組中，并且后續增加的內容都會放到新數組當中，當新數組無法容納增加的元素時，重復該過程。集合中不能放入原生數據類型，只能放置對象的引用，我們需要使用原生數據類型的包裝類才能加入到集合當中。我們來看看ArrayList底層的部分源碼：

public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable {private static final long serialVersionUID = 8683452581122892189L;//設置arrayList默認容量private static final int DEFAULT_CAPACITY = 10;//空數組，當調用無參數構造函數的時候默認給個空數組private static final Object[] EMPTY_ELEMENTDATA = {};//這才是真正保存數據的數組private transient Object[] elementData;//arrayList的實際元素數量private int size;//構造方法傳入默認的capacity 設置默認數組大小public ArrayList(int initialCapacity) {super();if (initialCapacity < 0)throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);this.elementData = new Object[initialCapacity];}//無參數構造方法默認為空數組public ArrayList() {super();this.elementData = EMPTY_ELEMENTDATA;}//構造方法傳入一個Collection， 則將Collection里面的值copy到arrayListpublic ArrayList(Collection<? extends E> c) {elementData = c.toArray();size = elementData.length;// c.toArray might (incorrectly) not return Object[] (see 6260652)if (elementData.getClass() != Object[].class)elementData = Arrays.copyOf(elementData, size, Object[].class);}//下面主要看看ArrayList 是如何將數組進行動態擴充實現add 和 removepublic boolean add(E e) {ensureCapacityInternal(size + 1); // Increments modCount!!elementData[size++] = e;return true;}public void add(int index, E element) {rangeCheckForAdd(index);ensureCapacityInternal(size + 1); // Increments modCount!!System.arraycopy(elementData, index, elementData, index + 1,size - index);elementData[index] = element;size++;}private void ensureCapacityInternal(int minCapacity) {if (elementData == EMPTY_ELEMENTDATA) {minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);}ensureExplicitCapacity(minCapacity);}private void ensureExplicitCapacity(int minCapacity) {modCount++;//超出了數組可容納的長度，需要進行動態擴展if (minCapacity - elementData.length > 0)grow(minCapacity);}//這才是動態擴展的精髓，看到這個方法，ArrayList瞬間被打回原形private void grow(int minCapacity) {int oldCapacity = elementData.length;//設置新數組的容量擴展為原來數組的1.5倍int newCapacity = oldCapacity + (oldCapacity >> 1);//再判斷一下新數組的容量夠不夠，夠了就直接使用這個長度創建新數組， //不夠就將數組長度設置為需要的長度if (newCapacity - minCapacity < 0)newCapacity = minCapacity;//判斷有沒超過最大限制if (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);//將原來數組的值copy新數組中去， ArrayList的引用指向新數組//這兒會新創建數組，如果數據量很大，重復的創建的數組，那么還是會影響效率，//因此鼓勵在合適的時候通過構造方法指定默認的capaticy大小elementData = Arrays.copyOf(elementData, newCapacity);}private static int hugeCapacity(int minCapacity) {if (minCapacity < 0) // overflowthrow new OutOfMemoryError();return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE;}}

so，小伙伴們發現了沒有，ArrayList 她骨子里面的本質就是數組， ArrayList就是對數組進行動態的擴展，其add, get , remove 等等操作就是對數組的操作。 ArrayList的一些特性都來源于數組：有序、元素可重復、插入慢、 索引快 等等一系列神馬所謂的屬性， 有沒有一種被欺騙了的趕腳`(*∩_∩*)′。

ArrayList中的遍歷

我們來看一下ArrayList中的遍歷，ArrayList支持三種遍歷方式。

第一種：通過迭代器遍歷，即通過Iterator去遍歷
Integer value = null; Iterator iter = list.iterator(); while (iter.hasNext()) {value = (Integer)iter.next(); } 第二種：隨機訪問，通過索引值去遍歷，因為ArrayList實現了RandomAccess接口，so，她支持通過索引值去隨機訪問元素：
Integer value = null; int size = list.size(); for (int i=0; i<size; i++) {value = (Integer)list.get(i); }

第三種：for循環遍歷，如下所示：

Integer value = null; for (Integer integ:list) {value = integ; } 接著，我們通過一個demo比較一下這三種遍歷方式：

package j2se.demo; import java.util.*; import java.util.concurrent.*;/** @desc ArrayList遍歷方式和效率的測試程序。** @author 丁國華*/ public class ArrayListRandomAccessTest {public static void main(String[] args) {List list = new ArrayList();for (int i=0; i<100000; i++)list.add(i);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");} }

運行效果，如下所示：

由此可見，遍歷ArrayList時，使用隨機訪問(即，通過索引序號訪問)效率最高，而使用迭代器的效率最低！

ArrayList的優缺點

接著，我們來看一下ArrayList的優缺點：

從上面的幾個過程總結一下ArrayList的優缺點。ArrayList的優點如下：
a、ArrayList底層以數組實現，是一種隨機訪問模式，再加上它實現了RandomAccess接口，因此查找速度快；
b、ArrayList在順序添加一個元素的時候非常方便，只是往數組里面添加了一個元素而已；
ArrayList的缺點：
a、刪除元素的時候，涉及到一次元素復制，如果要復制的元素很多，那么就會比較耗費性能
b、插入元素的時候，涉及到一次元素復制，如果要復制的元素很多，那么就會比較耗費性能
因此，ArrayList比較適合順序添加、隨機訪問的場景。在后面的博文中，小編將介紹LinkedList，等介紹完LinkedList之后，我們把她們兩個放在一起進行對比。

? ? ?ArrayList線程問題

再說ArrayList線程問題之前，我們需要了解一下，什么是線程安全？什么是線程不安全？線程安全就是多線程訪問的時候，采用了加鎖機制，當一個線程訪問該類的某個數據的時候，進行保護，其他線程不能進行訪問直到該線程讀取完，其他線程才可以使用，不會出現數據不一致或者數據污染。

總結

以上是生活随笔為你收集整理的【Java集合系列】---ArrayList的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。