Java集合系列--第三篇--ArrayList詳細介紹(源碼解析
概要
上一章，咱們學習了Collection的架構。這一章開始，咱們對Collection的具體實現類進行講解；首先，講解List，而List中ArrayList又最爲經常使用。所以，本章咱們講解ArrayList。先對ArrayList有個總體認識，再學習它的源碼，最後再經過例子來學習如何使用它。內容包括：java
ArrayList介紹
ArrayList 繼承了AbstractList，實現了List。它是一個數組隊列，提供了相關的添加、刪除、修改、遍歷等功能。數組
ArrayList 實現了RandmoAccess接口，即提供了隨機訪問功能。RandmoAccess是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數據結構
java.lang.Object
↳ java.util.AbstractCollection<E>
↳ java.util.AbstractList<E>
↳ java.util.ArrayList<E>
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}
ArrayList包含了兩個重要的對象：elementData 和 size。app
elementData 是"Object[]類型的數組"，它保存了添加到ArrayList中的元素。實際上，elementData是個動態數組，咱們能經過構造函數 ArrayList(int initialCapacity)來執行它的初始容量爲initialCapacity；若是經過不含參數的構造函數ArrayList()來建立ArrayList，則elementData的容量默認是10。elementData數組的大小會根據ArrayList容量的增加而動態的增加，具體的增加方式，請參考源碼分析中的ensureCapacity()函數。dom
size 則是動態數組的實際大小。函數
System.arrayCopy()與Arrays.copyOf()的區別
System.arraycopy()源碼分析
public class Demo {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
int[] copied=new int[10];
System.arraycopy(arr,0,copied,1,4);
System.out.println(Arrays.toString(copied));
}
}
輸出結果
[0, 1, 2, 3, 4, 0, 0, 0, 0, 0]
System.arraycopy(arr,0,copied,1,5);//這裏的arr是原數組，0是原數組拷貝的起始地址。而copied是目標數組，1是目標數組開始存放的位置，5則是數組存放的長度。
Arrays.copyOf
public class Demo {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
int[] copied= Arrays.copyOf(arr,10);
System.out.println(Arrays.toString(copied));
}
}
輸出結果
[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
ArrayList源碼解析
Array.copyOf() 用於複製指定的數組內容以達到擴容的目的，該方法對不一樣的基本數據類型都有對應的重載方法
* @since 1.6
*/
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
src：源對象 srcPos：源數組中的起始位置 dest：目標數組對象 destPos：目標數據中的起始位置 length：要拷貝的數組元素的數量
ArrayList源碼
package java.util;
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
// 序列版本號
private static final long serialVersionUID = 8683452581122892189L;
// 保存ArrayList中數據的數組
private transient Object[] elementData;
// ArrayList中實際數據的數量
private int size;
// ArrayList帶容量大小的構造函數。
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
// 新建一個數組
this.elementData = new Object[initialCapacity];
}
// ArrayList構造函數。默認容量是10。
public ArrayList() {
this(10);
}
// 建立一個包含collection的ArrayList
public 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);
}
// 將當前容量值設爲 =實際元素個數
public void trimToSize() {
modCount++;
int oldCapacity = elementData.length;
if (size < oldCapacity) {
elementData = Arrays.copyOf(elementData, size);
}
}
// 肯定ArrarList的容量。
// 若ArrayList的容量不足以容納當前的所有元素，設置 新的容量=「(原始容量x3)/2 + 1」
public void ensureCapacity(int minCapacity) {
// 將「修改統計數」+1
modCount++;
int oldCapacity = elementData.length;
// 若當前容量不足以容納當前的元素個數，設置 新的容量=「(原始容量x3)/2 + 1」
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
int newCapacity = (oldCapacity * 3)/2 + 1;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
// 添加元素e
public boolean add(E e) {
// 肯定ArrayList的容量大小
ensureCapacity(size + 1); // Increments modCount!!
// 添加e到ArrayList中
elementData[size++] = e;
return true;
}
// 返回ArrayList的實際大小
public int size() {
return size;
}
// 返回ArrayList是否包含Object(o)
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
// 返回ArrayList是否爲空
public boolean isEmpty() {
return size == 0;
}
// 正向查找，返回元素的索引值
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;
}
// 反向查找(從數組末尾向開始查找)，返回元素(o)的索引值
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;
}
// 返回ArrayList的Object數組
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
// 返回ArrayList的模板數組。所謂模板數組，便可以將T設爲任意的數據類型
public <T> T[] toArray(T[] a) {
// 若數組a的大小 < ArrayList的元素個數；
// 則新建一個T[]數組，數組大小是「ArrayList的元素個數」，並將「ArrayList」所有拷貝到新數組中
if (a.length < size)
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
// 若數組a的大小 >= ArrayList的元素個數；
// 則將ArrayList的所有元素都拷貝到數組a中。
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
// 獲取index位置的元素值
public E get(int index) {
RangeCheck(index);
return (E) elementData[index];
}
// 設置index位置的值爲element
public E set(int index, E element) {
RangeCheck(index);
E oldValue = (E) elementData[index];
elementData[index] = element;
return oldValue;
}
// 將e添加到ArrayList中
public boolean add(E e) {
ensureCapacity(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
// 將e添加到ArrayList的指定位置
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
ensureCapacity(size+1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
// 刪除ArrayList指定位置的元素
public E remove(int index) {
RangeCheck(index);
modCount++;
E oldValue = (E) elementData[index];
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // Let gc do its work
return oldValue;
}
// 刪除ArrayList的指定元素
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
// 快速刪除第index個元素
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
// 從"index+1"開始，用後面的元素替換前面的元素。
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 將最後一個元素設爲null
elementData[--size] = null; // Let gc do its work
}
// 刪除元素
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
// 便利ArrayList，找到「元素o」，則刪除，並返回true。
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
// 清空ArrayList，將所有的元素設爲null
public void clear() {
modCount++;
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
// 將集合c追加到ArrayList中
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
// 從index位置開始，將集合c添加到ArrayList
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
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
// 刪除fromIndex到toIndex之間的所有元素。
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// Let gc do its work
int newSize = size - (toIndex-fromIndex);
while (size != newSize)
elementData[--size] = null;
}
private void RangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
}
// 克隆函數
public Object clone() {
try {
ArrayList<E> v = (ArrayList<E>) super.clone();
// 將當前ArrayList的所有元素拷貝到v中
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
// java.io.Serializable的寫入函數
// 將ArrayList的「容量，全部的元素值」都寫入到輸出流中
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// 寫入「數組的容量」
s.writeInt(elementData.length);
// 寫入「數組的每個元素」
for (int i=0; i<size; i++)
s.writeObject(elementData[i]);
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
// java.io.Serializable的讀取函數：根據寫入方式讀出
// 先將ArrayList的「容量」讀出，而後將「全部的元素值」讀出
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in size, and any hidden stuff
s.defaultReadObject();
// 從輸入流中讀取ArrayList的「容量」
int arrayLength = s.readInt();
Object[] a = elementData = new Object[arrayLength];
// 從輸入流中將「全部的元素值」讀出
for (int i=0; i<size; i++)
a[i] = s.readObject();
}
}
ArrayList 其實是經過一個數組去保存數據的。當咱們構造ArrayList時；若使用默認構造函數，則ArrayList的默認容量大小是10。
當ArrayList容量不足以容納所有元素時，ArrayList會從新設置容量：新的容量=「(原始容量x3)/2 + 1」。
ArrayList的克隆函數，便是將所有元素克隆到一個數組中。
ArrayList實現java.io.Serializable的方式。當寫入到輸出流時，先寫入「容量」，再依次寫入「每個元素」；當讀出輸入流時，先讀取「容量」，再依次讀取「每個元素」。
ArrayList遍歷方式
ArrayList支持3種遍歷方式
第一種，經過迭代器遍歷。即經過Iterator去遍歷。
Integer value = null;
Iterator iter = list.iterator();
while (iter.hasNext()) {
value = (Integer)iter.next();
}
第二種，隨機訪問，經過索引值去遍歷。 因爲ArrayList實現了RandomAccess接口，它支持經過索引值去隨機訪問元素。
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;
}
下面經過一個實例，比較這3種方式的效率，實例代碼(ArrayListRandomAccessTest.java)以下：
/**
* @program: demo
* @description: demo
* @author: lee
* @create: 2018-08-28
**/
class Test {
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);
iteratorThroughFor(list);
}
private static void isRandomAccessSupported(List list) {
if (list instanceof RandomAccess) {
System.out.println("true");
} else {
System.out.println("no");
}
}
private static void iteratorThroughFor(List list) {
long beginTime = System.currentTimeMillis();
for (Object i : list) {
}
long endTime = System.currentTimeMillis();
long consume = endTime - beginTime;
System.out.println(consume);
}
private static void iteratorThroughIterator(List list) {
long beginTime = System.currentTimeMillis();
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object a = iterator.next();
}
long endTime = System.currentTimeMillis();
long consume = endTime - beginTime;
System.out.println(consume);
}
private static void iteratorThroughRandomAccess(List list) {
long beginTime = System.currentTimeMillis();
for (int i = 0; i < list.size(); i++) {
Object a = list.get(i);
}
long endTime = System.currentTimeMillis();
long consume = endTime - beginTime;
System.out.println(consume);
}
}
輸出結果
true 5 9 5
因而可知，遍歷ArrayList時，使用隨機訪問(即，經過索引序號訪問)效率最高，而使用迭代器的效率最低！
相關文章
- 1. Java 集合系列-第六篇-Vector詳細介紹
- 2. java集合系列 02ArrayList詳細介紹
- 3. Java集合系列——ArrayList源碼解讀
- 4. Java【集合系列】-12- TreeMap詳細介紹(源碼解析)和使用示例
- 5. Java 集合系列03之 ArrayList詳細介紹(源碼解析)和使用示例
- 6. Java集合源碼分析系列-（一）ArrayList源碼剖析
- 7. java集合源碼分析（三）：ArrayList
- 8. 集合系列（1）----------ArrayList 源碼分析
- 9. Java集合之List集合（ArrayList、Vector 和 LinkedList）詳細介紹
- 10. Java集合（三） ArrayList詳解
- 更多相關文章...
- • Spring體系結構詳解 - Spring教程
- • Spring整合Redis詳細步驟 - Redis教程
- • Java Agent入門實戰（一）-Instrumentation介紹與使用
- • 爲了進字節跳動，我精選了29道Java經典算法題，帶詳細講解
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 融合阿里雲，牛客助您找到心儀好工作
- 2. 解決jdbc(jdbctemplate)在測試類時不報錯在TomCatb部署後報錯
- 3. 解決PyCharm GoLand IntelliJ 等 JetBrains 系列 IDE無法輸入中文
- 4. vue+ant design中關於圖片請求不顯示的問題。
- 5. insufficient memory && Native memory allocation (malloc) failed
- 6. 解決IDEA用Maven創建的Web工程不能創建Java Class文件的問題
- 7. [已解決] Error: Cannot download ‘https://start.spring.io/starter.zip?
- 8. 在idea讓java文件夾正常使用
- 9. Eclipse啓動提示「subversive connector discovery」
- 10. 帥某-技巧-快速轉帖博主文章（article_content）
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Java 集合系列-第六篇-Vector詳細介紹
- 2. java集合系列 02ArrayList詳細介紹
- 3. Java集合系列——ArrayList源碼解讀
- 4. Java【集合系列】-12- TreeMap詳細介紹(源碼解析)和使用示例
- 5. Java 集合系列03之 ArrayList詳細介紹(源碼解析)和使用示例
- 6. Java集合源碼分析系列-（一）ArrayList源碼剖析
- 7. java集合源碼分析（三）：ArrayList
- 8. 集合系列（1）----------ArrayList 源碼分析
- 9. Java集合之List集合（ArrayList、Vector 和 LinkedList）詳細介紹
- 10. Java集合（三） ArrayList詳解