自己实现一下ArrayList

java数据结构中数组列表，ArrayList的相关实现。

package pac01;
/**
* 列表接口，定义一些列的操作
**/
public interface List<T>{

//向列表的尾部添加指定的元素
public boolean add(T t);

//在列表的指定位置插入新的元素
public void add(int index,T t);

//将列表中的所有元素添加到此列表的末尾
public boolean addAll(List<T> list);

//从列表中移除所有的元素
public void clear();

//列表中是否包含指定元素
public boolean contains(Object b);

//比较指定的对象与此列表是否相等
public boolean equals(Object c);

//获取指定位置的元素
public T get(int index);

//返回此列表的hashCode
public int hashCode();

//返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回-1
public int indexOf(Object o);

//返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
public int lastIndexOf(Object o);

//移除列表中指定位置的元素
public void remove(int index);

// 从此列表中移除第一次出现的指定元素（如果存在）
public void remove(Object o);

//用指定元素替换列表中指定位置的元素
public void set(int index,T t);

//返回列表中的元素数
public int size();

//如果是整数，那么对数据进行排序
}

package pac01;
/**
* java中的向量类似与数组的顺序存储的数据结构，但是具有比数据更强大的功能，它是
* 允许不同类型元素共存的变长数组，也就是说，java中的向量的容量是可变的，而且他
* 还提供了许多的方法来操作处理这些数据。jdk中的向量的实现包括Vector和ArrayList
* Vector是线程安全的，但是操作效率较低。相反，正是ArrayList实现的优点。实际中
* ArrayList使用较多
**/

public class ArrayList implements List{

//定义它的默认长度为10
private int DEFAULT_SIZE = 10;

//定义每次数组扩容的大小为5
private int EXPAND_SIZE = 5;

//向量中的元素个数
public static int size = 0 , length = 10;

private Object [] array;

//定义它的构造方法
public ArrayList(){
array = new Object[10];
}

//定义对数据的操作的方法

/**
* 将指定的元素添加到列表尾
* @return
**/
@Override
public boolean add(Object c){
//需要判断添加后数组能否存放的下
boolean flag = this.needExpand(size+1);
if(!flag) {//不需要扩展
array[size] = c;
size ++;
} else {
Object[] temp = array;//存放
array = new Object[DEFAULT_SIZE + EXPAND_SIZE];
this.length = array.length;
this.copy(array,temp);
array[size] = c;
size++;
}

return true;
}

/**
* 进行数组的复制
* @param array2 新的数组
* @param temp 旧的数组
*/
private void copy(Object[] array2, Object[] temp) {
int i = 0;
for(Object o : temp) {
array2[i] = o;
}
}

@Override
public void add(int index, Object t) {
boolean flag = this.needExpand(size+1);
if(!flag) {
for(int i=size ; i>index ; i--) {
array[size+1] = array[i];
}
array[index] = t;
size++;
}else {
Object[] temp = array;//存放
array = new Object[DEFAULT_SIZE + EXPAND_SIZE];
this.length = array.length;
this.copy(array,temp);

for(int i=size ; i>index ; i--) {
array[size+1] = arra
4000
y[i];
}
array[index] = t;
size++;
}

}

@Override
public boolean addAll(List list) {
boolean b = this.needExpand(size+list.size());

if(b == false){//不需要扩容
for(int i=0,j=this.size-1;i<list.size();i++){
array[j] = list.get(i);
size++;
}
}else {
Object [] temp = array;
array = new Object[this.size+list.size()];
this.length = size+list.size();
this.copy(array, temp);
for(int i=0,j=this.size-1;i<list.size();i++){
array[j] = list.get(i);
this.size++;
}
}
return true;
}

@Override
public void clear() {
for(int i=0;i<size;i++) {
array[i] = null;
}

}

@Override
public boolean contains(Object b) {
int i = 0;
while(b != array[i]){
i++;
if(i==this.size) {
return false;
}
}
return true;
}

@Override
public Object get(int index) {
// TODO Auto-generated method stub
return array[index];
}

@Override
public int indexOf(Object o) {
int index = -1;
for(int i=0;i<this.size;i++){
if(o.equals(array[i])){
index = i+1;
}
break;
}
return index;
}

@Override
public int lastIndexOf(Object o) {
int index = -1;
for(int i=this.size;i<0;i--){
if(o.equals(array[i])){
index = i+1;
}
break;
}
return index;
}

@Override
public void remove(int index) {
for(int i=index-1;i<this.size;i++) {
array[i] = array[i+1];
}
}

@Override
public void remove(Object o) {
int c = this.indexOf(o);
if(c > 0) {
this.remove(c);
}

}

@Override
public void set(int index, Object t) {
array[index] = t;

}

@Override
public int size() {
return size;
}

/**
* 添加后的尺寸与原来的尺寸进行比较
**/
public boolean needExpand(int afterSize){
if(afterSize < length) {
return false;
}
return true;
}

@Override
public String toString() {
return (String) this.get(size);
}

}

这就是自己实现的ArrayList，测试了几个方法是正常的。