ArrayList源碼分析

ArrayList源碼分析

類的實現接口及繼承父類

public class ArrayList<E> extends AbstractList<E>. implements List<E>, RandomAccess, Cloneable, java.io.Serializable

AbstractList 和 List

ArrayList 和AbstractList 都實現了List接口。
而且AbstractList是ArrayList的父類。

RandomAccess

RandomAccess接口裏沒有方法須要實現。這是一個很特別的空接口。這個接口的做用是：

List實現它可以支持快速隨機訪問。主要能提升隨機訪問的性能。
 for (int i=0, n=list.size(); i < n; i++)
    list.get(i);
比下面這種快。
for (Iterator i=list.iterator();i.hasNext(); )
    i.next();

Cloneable

此接口也是一個空接口，實現次接口，須要重寫object對象的clone()方法，而且方法是訪問權限是public的。

clone()是值拷貝，即爲淺拷貝。

測試是否爲淺拷貝：

拷貝對象：

package xuelongjiang.ArrayListCloneTest;

/**
 * @author xuelongjiang
 */
public class User {

private String name ;

private Integer sex;

public User() {
}

public User(String name, Integer sex) {
    this.name = name;
    this.sex = sex;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public Integer getSex() {
    return sex;
}

public void setSex(Integer sex) {
    this.sex = sex;
}


@Override
public String toString() {
    return "User{" +
            "name='" + name + '\'' +
            ", sex=" + sex +
                    "//\n" +
            getClass().getName() + "@" + Integer.toHexString(hashCode())+
            '}';
}

}

測試類：

package xuelongjiang.ArrayListCloneTest;


import java.util.ArrayList;
import java.util.List;

/**
 *
 * 結論： clone 是淺拷貝 值相同，對象的引用相同
 * @author xuelongjiang
 */
public class CloneObject {


public static void main(String[] args) {


    ArrayList<User> userList = new ArrayList<>();
    userList.add(new User("xue",1));
    userList.add(new User("lisi",2));

    System.out.println("------------原始值-------------");
    for(User user : userList){
        System.out.println(user);
    }


    List<User> cloneList  = (List<User>) userList.clone();
    System.out.println("------------拷貝值-------------");
    for(User user : cloneList){
        System.out.println(user);
    }


}

}

輸出：

------------原始值-------------
User{name='xue', sex=1//
xuelongjiang.ArrayListCloneTest.User@2d98a335}
User{name='lisi', sex=2//
xuelongjiang.ArrayListCloneTest.User@16b98e56}
------------拷貝值-------------
User{name='xue', sex=1//
xuelongjiang.ArrayListCloneTest.User@2d98a335}
User{name='lisi', sex=2//
xuelongjiang.ArrayListCloneTest.User@16b98e56}

實現ArrayList的容器

ArrayList的底層實現爲數組。

transient Object[] elementData;

從上面咱們能夠看出數組爲obejct。在取出值的時候利用範型轉爲聲明的類型。

構造方法

ArrayList 有三個構造方法

第一種構造方法：

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

若是使用無參的構造方法，則初始化的數組爲空（注意不爲null）。

第二種構造方法

public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
    this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
    this.elementData = EMPTY_ELEMENTDATA;
} else {
    throw new IllegalArgumentException("Illegal Capacity: "+
                                       initialCapacity);
}
}

若是初始化的容器值大於0，則初始化爲這個值。若是等於0 則初始化爲空

private static final Object[] EMPTY_ELEMENTDATA = {};

若是小於0則拋出異常。

第三種構造方法：

public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
    // replace with empty array.
    this.elementData = EMPTY_ELEMENTDATA;
}
}

因爲ArrayList的底層實現是Object[] 須要把Collection轉爲Object[]。而且設置size爲傳入的Collection大小。

經常使用方法解析

size() list的元素數

size方法很簡單直接返回size值的大小。

private int size;

public int size() {
    return size;
}

add()

在add方法中會對elemenrData進行擴容，若是不須要擴容或者擴容完成了，就把須要添加的元素放入elementData中，而且size自增。

public boolean add(E e) {
      ensureCapacityInternal(size + 1);  // Increments modCount!!
elementData[size++] = e;
return true;
}

在ensureCapacityInternal中若是容器爲空，比較須要擴容的大小和DEFAULT_CAPACITY(= 10)
若是大於DEFAULT_CAPACITY，則使用本次傳入的不然設置容量爲DEFAULT_CAPACITY。

private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
    minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}

ensureExplicitCapacity(minCapacity);
}

ensureExplicitCapacity方法:

private void ensureExplicitCapacity(int minCapacity) {
modCount++;

// overflow-conscious code
if (minCapacity - elementData.length > 0)
    grow(minCapacity);
}

若是本次須要的擴容大於elementData的長度，則調用grow方法擴容。

private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;//1
int newCapacity = oldCapacity + (oldCapacity >> 1);//2
if (newCapacity - minCapacity < 0)
    newCapacity = minCapacity;//3
if (newCapacity - MAX_ARRAY_SIZE > 0)
    newCapacity = hugeCapacity(minCapacity);//4
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);//5
}

1. 獲取當前容器的大小
2. 計算新的擴容大小：擴容1.5倍

3. 若是默認擴容小於本次須要擴容的大小，則設置爲本次須要的擴容大小，不然設爲默認擴容

   private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

public static final int   MAX_VALUE = 0x7fffffff;//2的31次方，大於20多億

1. 若是本次須要的擴容大於MAX_ARRAY_SIZE，則容器設置爲Integer.MAX_VALUE，若是等於MAX_ARRAY_SIZE則設爲MAX_ARRAY_SIZE。
2. 拷貝生成擴容後的容器

remove()

public E remove(int index) {
    rangeCheck(index);//1
       modCount++;
       E oldValue = elementData(index);//2

            int numMoved = size - index - 1;//3
        if (numMoved > 0)
    System.arraycopy(elementData, index+1, elementData, index,
                     numMoved);//4
    elementData[--size] = null; // clear to let GC do its work
    return oldValue;
    }

移除元素後，須要把它以後的雖有元素向前移動1位。

1. 檢查索引是否超出範圍
2. 返回被移除的元素
3. 須要向前移動的元素數
4. 移動元素：拷貝

contains() 是否包含某元素

public boolean contains(Object o) {
return indexOf(o) >= 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;
}

循環容器判斷每個元素是否和目標值相等。
**注意：若是是對象的話這裏比較的對象的引用，在開發中不少時候咱們要比較的實體，實體映射的是數據庫裏的一條記錄，比較的實際上是主鍵是否相等，因此若是
是這種狀況須要重寫equal方法及hashCode方法**

clear()

public void clear() {
modCount++;

// clear to let GC do its work
for (int i = 0; i < size; i++)
    elementData[i] = null;

size = 0;
}

把容器中的每一個元素的值設爲null，以後垃圾回收機制會收回被使用的內存。

迭代器

java5以後，集合框架可使用迭代器，而且提供了foreach語法糖。

public Iterator<E> iterator() {
return new Itr();
}

public E next()
public boolean hasNext()

迭代器模式：https://blog.csdn.net/u013565...

開發中的易犯錯誤

https://blog.csdn.net/u013565...

關注個人公衆號第一時間閱讀有趣的技術故事
掃碼關注：
也能夠在微信搜索公衆號便可關注我：codexiulian 渴望與你一塊兒成長進步！