public class MyArrayList implements List {
@Override
public int size() {
return 0;
}
@Override
public boolean isEmpty() {
return false;
}
@Override
public boolean contains(Object o) {
return false;
}
@Override
public Iterator iterator() {
return null;
}
@Override
public Object[] toArray() {
return new Object[0];
}
@Override
public boolean add(Object o) {
return false;
}
@Override
public boolean remove(Object o) {
return false;
}
@Override
public boolean addAll(Collection c) {
return false;
}
@Override
public boolean addAll(int index, Collection c) {
return false;
}
@Override
public void clear() {
}
@Override
public Object get(int index) {
return null;
}
@Override
public Object set(int index, Object element) {
return null;
}
@Override
public void add(int index, Object element) {
}
@Override
public Object remove(int index) {
return null;
}
@Override
public int indexOf(Object o) {
return 0;
}
@Override
public int lastIndexOf(Object o) {
return 0;
}
@Override
public ListIterator listIterator() {
return null;
}
@Override
public ListIterator listIterator(int index) {
return null;
}
@Override
public List subList(int fromIndex, int toIndex) {
return null;
}
@Override
public boolean retainAll(Collection c) {
return false;
}
@Override
public boolean removeAll(Collection c) {
return false;
}
@Override
public boolean containsAll(Collection c) {
return false;
}
@Override
public Object[] toArray(Object[] a) {
return new Object[0];
}
}
一：由于ArrayList底层是数组结构，所以我们先定义一个数组，再由于我们不知道将来会在里面
存储什么类型的元素，所以我么它为一个object类型的数组。
二：写一个有参构造方法，来定义数组的初始容量，并实例化对象，让我们先前定义的那个数组
等于实例化的对象。
三：再写一个无参构造。在它里面调用我们的有参构造，有参构造方法会帮我们实例化出一个数
组，再声明一个默认容量，大小为十，将这个默认容量放到无参构造中，这时初始默认容量为十
public class MyArrayList implements List {
private Object[] elementData;
private static int DefaultCapacity=10;
public MyArrayList() {
this(DefaultCapacity);
}
public MyArrayList(int initialCapacity) {
this.elementData = new Object[initialCapacity];
}
}
2.这时我们来重写它里面的add添加数据的方法：
一：首先，得确保储存空间能够储存新的数据
二：这时需要声明一个size属性，然后让size方法返回我们的数组数量。
三：然后我们要按数组下标进行存储元素
四：为了验证添加是否成功，让原来的数组数量和添加完当前数组的数量进行比较
五：但是当存储的数量大于数组的默认初始容量十的时候，就需要扩容啦，
这需要我们创建一个ensureCapacity方法，并声明参数为最小数量，之后才能在添加方 法中使用这个方法。用当前数组的长度和最小容量10比较，如果相等则说明满了，需要
扩容了，如果不相等，则不需要扩容。
扩容需要先把我们原来的数组拷贝，并让原来的数组等于这个新数组,然后声明新的容量
新容量为：原来容量的1.5倍。
六：元素的读取，需要重写get方法。
七：重写toString方法。
public class MyArrayList implements List {
private Object[] elementData;
private int size;
private static int DefaultCapacity=10;
public MyArrayList() {
this(DefaultCapacity);
}
public MyArrayList(int initialCapacity) {
this.elementData = new Object[initialCapacity];
}
@Override
public int size() {
return this.size;
}
}
@Override
public boolean add(Object o) {
//确保储存空间能够储存新的数据
elementData[size++]=o;
int oldSize=this.size;
if(this.size>oldSize){
return true;
}
return false;
}
private void ensureCapacity(int minCapacity) {
if(elementData.length==minCapacity){
//空间不够给数组扩容
int oldCapacity = elementData.length;
int newCapacity=oldCapacity+(oldCapacity >>1);
newCapacity=Math.max(minCapacity,newCapacity);
elementData= Arrays.copyOf(elementData, newCapacity);
}
}
@Override
public Object get(int index) {
return elementData[index];
}
@Override
public String toString() {
String result="[";
for (int i = 0; i
3.在指定位置上，移除元素 。
一：需要重写add(int index)这个方法。
@Override
public Object remove(int index) {
system.arraycopy(elementData,index+1,elementData,index,size-index-1);
elementData[--size]=null;
return elementData[index];
}
注意：在重写ArrayList时，添加或移除元素时，会造成数据的移动，因为你的数组拷贝了
所以这是它的一个缺点，也就是添加删除慢，但它读取快。
