ArrayList ：
1）ArrayList內部是通過一個Object數組實現的，當數組填滿之後會根據需要進行擴容
2）最好預估ArrayList的大小，並設置其初始容量，以避免不必要的擴容所造成的性能問題。
3）ArrayList的初始容量是10，ArrayList每次擴容都將容量變爲原來的1.5倍，若還小於所需的最小值，那麼直接分配容量爲所需值。
4）ArrayList線程不安全，允許空（null）的元素。
5）ArrayList內部有兩個內部類，分別實現Iterator和ListIterator，定義了迭代的規則。
查找O（1）。添加移除慢。
ArrayList的容量是指用來存儲列表元素的數組的大小。它總是至少等於列表的大小。隨着向 ArrayList 中不斷添加元素，其容量也自動增長。自動增長會帶來數據向新數組的重新拷貝。如果可預知數據量的多少，可在構造 ArrayList 時指定其容量。在添加大量元素前，應用程序也可使用ensureCapacity操作來增加ArrayList實例的容量，這可減少遞增式再分配的數量。
注意，此實現不是同步的。如果多個線程同時訪問一個 ArrayList 實例，而其中至少一個線程從結構上修改了列表，那麼它必須保持外部同步。
相對比的，Vector是線程安全的，其中涉及線程安全的方法皆被同步操作了。
從上面介紹的向 ArrayList 中存儲元素的代碼中，每當向數組中添加元素時，都要去檢查添加後元素的個數是否會超出當前數組的長度，如果超出，數組將會進行擴容，以滿足添加數據的需求。數組擴容通過一個公開的方法 ensureCapacity(int minCapacity)來實現。在實際添加大量元素前，我也可使用 ensureCapacity來手動增加 ArrayList 實例的容量，以減少遞增式再分配的數量。
ArrayList源碼分析：（JDK8）
ArrayList是對象引用的一個變長數組，是線程不安全的
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
屬性：
transient Object[] elementData;
private int size;
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
構造方法：
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);
}
}
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
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;
}
}
set方法：
public E set(int index, E element) { // set時依舊會判斷是否越界，然後保存新值返回舊值
rangeCheck(index);
E oldValue = elementData(index); // 先獲取舊值
elementData[index] = element; // 直接對內部維護的數組進行賦值
return oldValue;
}
add方法：
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
// 將指定的元素插入此列表中的指定位置。
// 如果當前位置有元素，則向右移動當前位於該位置的元素以及所有後續元素（將其索引加1）
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++;
}
get方法：
public E get(int index) { // get元素前會先判斷傳入的index是否越界，如果沒有則返回元素值
rangeCheck(index); // 判斷是否越界
return elementData(index);
}
indexOf方法：
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;
}
remove方法：
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
public boolean remove(Object o) {
// 由於ArrayList中允許存放null，因此下面通過兩種情況來分別處理。
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;
}
clear方法：
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
public int size() {
return size;
}
@Override
public void forEach(Consumer<? super E> action) {
Objects.requireNonNull(action);
final int expectedModCount = modCount;
@SuppressWarnings("unchecked")
final E[] elementData = (E[]) this.elementData;
final int size = this.size;
for (int i=0; modCount == expectedModCount && i < size; i++) {
action.accept(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
elementData[--size] = null; // clear to let GC do its work
}
擴容:
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // 如果只是剛初始化，最小容量大小默認是8
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);//根據容量進行分配
}
private void ensureExplicitCapacity(int minCapacity) { // 擴容
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0) // 大於的時候進行擴容，否則直接結束
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1); // JDK8擴充策略是原來的1.5倍
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
從上述代碼中可看出，數組進行擴容時，會將老數組中的元素重新拷貝一份到新的數組中，每次數組容量的增長大約是其原容量的 1.5倍。這種操作的代價是很高的，因此在實際使用時，我們應該儘量避免數組容量的擴張。當我們可預知要保存的元素的多少時，要在構造 ArrayList 實例時，就指定其容量，以避免數組擴容的發生。或者根據實際需求，通過調用 ensureCapacity方法來手動增加 ArrayList實例的容量。
ArrayList 還給我們提供了將底層數組的容量調整爲當前列表保存的實際元素的大小的功能。它可通過 trimToSize方法來實現。
實例：
ArrayList array = new ArrayList();// 創建集合對象 // 添加多個字符串元素(包含內容相同的) array.add("hello"); array.add("world"); array.add("java"); array.add("world"); array.add("java"); array.add("world"); array.add("world"); array.add("world"); array.add("world"); array.add("java"); array.add("world"); ArrayList newArray = new ArrayList(); Iterator it = array.iterator(); while (it.hasNext()) { String s = (String) it.next(); // 新集合是否有這個字符串，沒有就添加新的字符串 if (!newArray.contains(s)) { newArray.add(s); } } // 遍歷新集合 for (int x = 0; x < newArray.size(); x++) { String s = (String) newArray.get(x); System.out.println(s); } /* 需求：ArrayList去除集合中字符串的重複值(字符串的內容相同) * 要求：不能創建新的集合，就在以前的集合上做。 */ //去除相同的（選擇排序思想）不建立新的數組 //不斷對比，如果是重複的話，就去掉當前對比的這個，然後讓數組的值減一 for (int x = 0; x < array.size() - 1; x++) { for (int y = x + 1; y < array.size(); y++) { if (array.get(x).equals(array.get(y))) { array.remove(y); y--; } } } Iterator it1 = array.iterator(); while (it1.hasNext()) { String s = (String) it1.next(); System.out.println(s); } |