# ArrayList/Vector çåºå±åæ
## ArrayList
`ArrayList` å®ç°äº `List`ã`RandomAccess` æ¥å£ãå¯ä»¥æå
¥ç©ºæ°æ®ï¼ä¹æ¯æéæºè®¿é®ã
`ArrayList `ç¸å½äºå¨ææ°æ®ï¼å
¶ä¸æéè¦çä¸¤ä¸ªå±æ§å嫿¯:
`elementData` æ°ç»ï¼ä»¥å `size` 大å°ã
å¨è°ç¨ `add()` æ¹æ³çæ¶åï¼
```java
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
```
- é¦å
è¿è¡æ©å®¹æ ¡éªã
- å°æå
¥ç弿¾å°å°¾é¨ï¼å¹¶å° size + 1 ã
妿æ¯è°ç¨ `add(index,e)` 卿å®ä½ç½®æ·»å çè¯ï¼
```java
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++;
}
```
- 乿¯é¦å
æ©å®¹æ ¡éªã
- æ¥çå¯¹æ°æ®è¿è¡å¤å¶ï¼ç®çæ¯æ index ä½ç½®ç©ºåºæ¥æ¾æ¬æ¬¡æå
¥çæ°æ®ï¼å¹¶å°åé¢çæ°æ®ååç§»å¨ä¸ä¸ªä½ç½®ã
å
¶å®æ©å®¹æç»è°ç¨ç代ç :
```java
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
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);
}
```
乿¯ä¸ä¸ªæ°ç»å¤å¶çè¿ç¨ã
ç±æ¤å¯è§ `ArrayList` çä¸»è¦æ¶èæ¯æ°ç»æ©å®¹ä»¥å卿å®ä½ç½®æ·»å æ°æ®ï¼å¨æ¥å¸¸ä½¿ç¨æ¶æå¥½æ¯æå®å¤§å°ï¼å°½éåå°æ©å®¹ãæ´è¦åå°å¨æå®ä½ç½®æå
¥æ°æ®çæä½ã
### åºåå
ç±äº ArrayList æ¯åºäºå¨ææ°ç»å®ç°çï¼æä»¥å¹¶ä¸æ¯ææç空é´é½è¢«ä½¿ç¨ãå æ¤ä½¿ç¨äº `transient` 修饰ï¼å¯ä»¥é²æ¢è¢«èªå¨åºååã
```java
transient Object[] elementData;
```
å æ¤ ArrayList èªå®ä¹äºåºååä¸ååºååï¼
```java
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// Write out all elements in the proper order.
//åªåºååäºè¢«ä½¿ç¨çæ°æ®
for (int i=0; i