JAVA整理04---手写简单的arraylist来学习arraylist

ArrayList类

通过自定义的arraylist类与jdk源码里的ArrayList的实现的对比学习：

1.所需的变量：

private Object[] elementData;
private int size;
private static final int DEFAULT_LENGTH=10;


private static final int DEFAULT_CAPACITY = 10;
transient Object[] elementData;
private int size;


（1）默认长度设置成static final 因为这个是不随具体对象改变的，是属于类的通用不变属性。

（2）为什么要把核心数组定义成 transient 数据类型，大概是因为序列化和反序列化的过程类要自己做，不要用默认的，至于原因深入后再谈。

2.构造函数

1.无参构造

public MyList(){

elementData = new Object[DEALULT_LENGTH];

}


public ArrayList() {

this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

}
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};


无参构造可以定义成static final ，没必要每次都new一个新的空对象。

2.传入length的构造

public MyList(int length){

elementData = new Object[length];

}


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);
}

}


对length进行判断，大于0的情况处理一样的，等于0的话还是调用了静态的那个空对象，小于0抛出非法长度的异常。

3.增加元素

public void add(E obj){

Object[] newArray;
if(size == elementData.length) {
    newArray = new Object[elementData.length + (elementData.length >> 1)];
    System.arraycopy(elementData, 0, newArray, 0, elementData.length);
    elementData=newArray;
}
    elementData[size++]=obj;

}


public boolean add(E e) {

ensureCapacityInternal(size + 1);  // Increments modCount!!
elementData[size++] = e;
return true;

}


add的差别比较大，MyList的简单逻辑：判断目前存的size与elementData的长度的大小，如果size等于开的长度的话，再存进去会溢出，所以需要数组扩容，扩容的基本步骤：开一个新的数组，长度是原来的1.5倍（>>1就是加上了一半，这样运算快点），将原来数组的东西拷贝到新数组的前面，将新数组指向elementData数组，把obj存进新数组里。

源码的逻辑多了几层判断，最终的扩容操作逻辑也是大同小异的：

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);

}


4.删除元素

public void remove(int index){

for(int i=index+1;i<elementData.length;i++){
   elementData[i-1] = elementData[i];
}
size--;

}


将index后的元素前移一位，size--；

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;

}


源码里remove后返回了删除的值，并且多了一个rangecheck的函数进行index判断，因为这个功能很多地方都可以用到，相似的。

private void rangeCheck(int index) {

if (index >= size)
    throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

}


移动使用的是for循环，源码使用了copy方法，做一个时间的测试：

5.修改元素

public void set(int index,E obj){

elementData[index]=obj;

}


public E set(int index, E element) {

rangeCheck(index);

E oldValue = elementData(index);
elementData[index] = element;
return oldValue;

}


也是多了一个rangecheck的判断，然后返回了旧的的value。

<h4>6.查找元素</h4>

public E get(int index){

return (E)elementData[index];

}


public E get(int index) {

rangeCheck(index);
checkForComodification();
return ArrayList.this.elementData(offset + index);

}


差别不大，就是返回elementdata的index元素。