ArrayList笔记

ArrayList笔记

只实现了Collection部分方法，我们需要的是实现排序，所以只要实现toArray()方法和set()方法即可用Collections.sort()来实现排序算法。还有很多不足的地方，日后实现。

import java.util.AbstractList;
import java.util.Collections;
import java.util.List;
import java.util.Arrays;
import java.util.RandomAccess;

public class MyArray<T> extends AbstractList<T>
    implements List<T>, RandomAccess, Cloneable, java.io.Serializable{

    private static final long serialVersionUID = 1L;
    //元素列表
    private Object elementData[];
    //列表大小
    private int size;
    //列表容量
    private int capacity;

    /**
     * 默认构造长度为10的数组
     */
    public MyArray (){
        capacity = 10;
        elementData = new Object[capacity];
    }

    /**
     * 指定capacity大小的数组
     * @param capacity 容量
     */
    public MyArray (int capacity){
        this.capacity = capacity;
        elementData = new Object[this.capacity];
    }

    /**
     * 插入元素到指定index
     * @param index 指定位置
     * @param value 待插入元素
     */
    public void add(int index, T value){
        //此时size为真实存储数量+1
        //比如size=11,真实数量有10个,而插入在第11个位置也是可以的
        rangeCheck(index);
        ensureCapacity(size+1);

        //对一维数组按值传递,在元素内容巨大的情况下,它的执行效率远比for循环高的多
        System.arraycopy(elementData, index, elementData, index+1, size-index);

        elementData[index] = value;
        size++;

    }


    /**
     * 插入元素在列表某尾
     * @param value 待插入元素
     * @return 
     */
    public boolean add(T value) {
        ensureCapacity(size+1);
        elementData[size++] = value;
        return true;
    }

    /**
     * 从位置0开始查找元素
     * @param value 待查找元素
     * @return index 索引位置
     */
    public int indexOf(Object value){
        if(value==null){
            for(int i=0;i<size;i++){
                if(elementData[i]==null){
                    return i;
                }
            }
        }else{
            for(int i=0;i<size;i++){
                if(value.equals(elementData[i])){
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 从列表某尾开始查找元素
     * @param value 待查找元素
     * @return index 索引位置
     */
    public int lastIndexOf(Object value){
        if(value==null){
            for(int i=size-1;i>=0;i--){
                if(elementData[i]==null){
                    return i;
                }
            }
        }else{
            for(int i=size-1;i>=0;i--){
                if(value.equals(elementData[i])){
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 删除指定元素
     * @param value 待删除元素
     * @return 是否删除成功
     */
    public boolean remove(Object value){
        if(value==null){
            for(int i=0;i<size;i++){
                if(elementData[i]==null){
                    fastRemove(i);
                    return true;
                }
            }
        }else{
            for(int i=0;i<size;i++){
                if(value.equals(elementData[i])){
                    fastRemove(i);
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 删除指定位置元素
     * @param index 待删除位置元素
     * @return T 返回被删除元素
     */
    public T remove(int index){
        rangeCheck(index);
        T oldValue = (T) elementData[index];
        fastRemove(index);
        return oldValue;
    }

    /**
     * 获取指定位置的元素
     * @param index 指定位置
     * @return 返回指定位置元素
     */
    public T get(int index){
        rangeCheck(index);
        return (T) elementData[index];
    }


    /**
     * 删除指定位置的元素,效率高
     * @param index 待删除位置
     */
    private void fastRemove(int index){
        //待复制的元素数量
        int num = size-(index+1);
        //如果复制数量为0就不用去执行arraycopy
        if(num>0)
            System.arraycopy(elementData, index+1, elementData, index, num);
        elementData[--size] = null;
    }

    /**
     * 检查是否需要扩容
     */
    private void ensureCapacity(int newsize) {
        if(size>=capacity){
            int newCapacity = (capacity*3)/2 + 1;
            if(newsize>newCapacity){
                newCapacity = newsize;
            }
            //copyOf最后调用的是底层实现的System.arraycopy函数,效率比for高
            elementData = Arrays.copyOf(elementData, newCapacity);
            capacity = newCapacity;
        }
    }

    /**
     * 检查有无越界
     * @param index 待检查位置
     * @throws 越界则抛出异常
     */
    private void rangeCheck(int index) {
        if(index<0||index>size)
            throw new ArrayIndexOutOfBoundsException();
    }

    public T set(int index, T value){
        rangeCheck(index);
        T old = (T) elementData[index];
        elementData[index] = value;
        return old;
    }

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

    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public boolean contains(Object o) {
        return indexOf(o)>=0;
    }

    @Override
    public <T> T[] toArray(T[] a) {
        //a的长度小于this的长度,说明a的空间太小
        if(a.length<size)
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());

        //说明a的空间大于等于this的空间,所以直接复制就行了
        System.arraycopy(elementData, 0, a, 0, size);

        //说明a的空间比this空间大
        if(a.length>size)
            a[size] = null;
        return a;
    }

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

    @Override
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

    //测试单元
    public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<Integer>();
        myArray.add(100);
        myArray.add(100);
        myArray.add(200);
        myArray.add(300);
        myArray.add(2,400);
        myArray.add(100);
        for(Integer i : myArray){
            System.out.print(i+" ");
        }
        System.out.println();
        Collections.sort(myArray);
        for(Integer i : myArray){
            System.out.print(i+" ");
        }
    }

}