ArrayList封裝

package com.cn.test.jihe;

import java.util.Arrays;

/**
* 
* insert
* delete
* update 
* get
*
*/
public class ArrayList {

/**
* Default initial capacity.
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* Shared empty array instance used for empty instances.
*/
private static final Object[] EMPTY_ELEMENTDATA = {};

Object[] elementData;

private int size;

protected int modCount = 0;

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

public ArrayList(int initialCapacity) throws Exception {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new Exception("illegal Capital" + initialCapacity);
}
}

public ArrayList() {
this.elementData = EMPTY_ELEMENTDATA;
}

public boolean add(Object obj) {
// 首先比較數組的長度
ensureCapitalInteral(size + 1);
elementData[size ++] = obj;
return false;
}

public void add(int index, Object obj) throws Exception {
/**
* 首先判斷要index的位置
*/
rangCheckForAdd(index);
ensureCapitalInteral(size + 1);
System.arraycopy(elementData, index, elementData, index + 1, size - index);
elementData[index] = obj;
size++;
}

private void rangCheckForAdd(int index) throws Exception {
if (size < index || index < 0) {
throw new Exception("數組下標越界" + index);
}
}
boolean contains(Object o ) {
return indexOf(o) >= 0;
}

/**
* 返回位置上的下標
* @param index
* @return
* @throws Exception 
*/
Object get(int index) throws Exception {
rangeCheck(index);
return elementData[index];
}
/**
* 列表沒有元素返回true
* @return
*/
boolean isEmpty() {
return size == 0;
}

/**
* 返回此列表中最後一次出現的指定元素的索引，或如果此列表不包含索引，則返回 -1。
* @param o
* @return
*/
int lastIndexOf(Object o) {
if (null == o) {
// 逆序迴圈數組
for (int i = size - 1; i >= 0; i--) {
if (null == elementData[i]) {
return i;
}
}
} else {
for (int i = size - 1; i >= 0; i--) {
if (o.equals(elementData[i])) {
return i;
}
}
}

return -1;
}

/**
* 移除此列表中指定位置上的元素。向左移動所有後續元素（將其索引減 1）。
* @throws Exception 
*/
Object remove(int index) throws Exception {
// 下標的檢查
rangeCheck(index);
Object oldValue = elementData[index];
int numMove = size - index - 1;
if (numMove > 0) { // 表示刪除的不是最後一個元素
System.arraycopy(elementData, index + 1, elementData, index, numMove);
}
elementData[size--] = null;
return oldValue;
}

/**
* 移除此列表中首次出現的指定元素（如果存在）。如果列表不包含此元素，則列表不做改動。
*/
boolean remove(Object object) throws Exception {
// object 是否在該數組中
int index = indexOf(object);
if(index >= 0) {
// 刪除下標
int moveNum = size - index - 1;
if (moveNum > 0) {
System.arraycopy(elementData, index + 1, elementData, index, moveNum);
}
elementData[size--] = null;
return true;
}

return false;

}
/**
* 用指定的元素替代此列表中指定位置上的元素,
* 並且將舊元素返回
* @throws Exception 
*/
Object set(int index, Object element) throws Exception {
// 1. 判斷index的下標越界問題
rangeCheck(index);
Object oldValue = elementData[index];
elementData[index] = element;
return oldValue;

}

/**
* 按適當順序（從第一個到最後一個元素）返回包含此列表中所有元素的數組。
由於此列表不維護對返回數組的任何引用，，因而它將是“安全的”。（換句話說，此方法必須分配一個新的數組）。因此，調用者可以自由地修改返回的數組。
* @return
*/
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}

private void rangeCheck(int index) throws Exception {

if (size <= index) {
throw new Exception("下標越界" + index);
}

}

private int indexOf(Object o) {
if(null == o) {
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;
}

public int size() {
return size;
}
private void ensureCapitalInteral(int minCapacity) {
ensureExplicitCapacity (calculateCapacity(elementData, minCapacity));
}


private void ensureExplicitCapacity(int calculateCapacity) {
modCount++;
if (calculateCapacity - elementData.length > 0) {
grow(calculateCapacity);
}

}

private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0) // int的數組超限
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0) {
newCapacity = hugeCapacity(minCapacity);
}
elementData = Arrays.copyOf(elementData, newCapacity);

}

private int hugeCapacity(int minCapacity) {
if (minCapacity < 0) {
throw new OutOfMemoryError();
}
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

private int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY,minCapacity);
}
return minCapacity;
}
}