模仿JDK写一个简单的ArrayList——高淇JAVA300讲笔记之ArrayList

    最近在看高淇300讲的视频，已经看了100集出头了，是时候整理下笔记了。

    ArrayList是List的子类，有顺序，可以重复。底层实现是数组，线程不安全，效率高。查询快，修改、插入、删除慢。

    以下代码简单地实现了ArrayList的add()、set()、isEmpty()、remove()、get()、size()等方法。其中在挪动数组中的元素时用到了java.lang.System类的静态方法arraycopy，数组拷贝。

    下面就直接放代码吧。

package cn.bjsxt.collection;

import java.util.Date;

/**
 * 自己实现一个ArrayList
 * @author
 *
 */
public class SxtArrayList /*implements List*/ {
    
    private Object[] elementData;  //一个对象数组
    
    private int size;  //ArrayList的大小
    
    //返回ArrayList的大小
    public int size() {
        return size;
    }
    
    //ArrayList是否为空
    public boolean isEmpty() {
        return size == 0;
    }
    
    //无参构造器
    public SxtArrayList() {
        this(10);  //默认容器大小是10
    }
    
    //构造器重载
    public SxtArrayList(int initialCapacity) {
        if(initialCapacity<0) {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        elementData = new Object[initialCapacity];
    }
    
    //追加一个对象
    public void add(Object obj) {
        ensureCapacity();  //数组扩容
        elementData[size++] = obj;
    }
    
    //在指定位置插入一个对象
    public void add(int index, Object obj) {
        rangeCheck(index);
        
        ensureCapacity();  //数组扩容
        
        //将数组从指定位置开始往后挪一位
        System.arraycopy(elementData, index, elementData, index+1, size-index);
        elementData[index] = obj;
        size++;
    }
    
    //获得指定位置的元素
    public Object get(int index) {
        rangeCheck(index);  //检查数组越界
        return elementData[index];
    }
    
    //删除指定位置的对象
    public void remove(int index) {
        rangeCheck(index);  //检查数组越界
        int numMoved = size - index - 1;  //要挪动的元素的长度
        if(numMoved > 0) {
            //用数组拷贝的方式，将指定位置后面的元素往前挪一位
            System.arraycopy(elementData, index+1, elementData, index, numMoved);
        }
        elementData[--size] = null;  //使数组的最后一个元素为null
    }
    
    //remove的重载
    public void remove(Object obj) {
        for(int i=0;i<size;i++) {
            if(get(i).equals(obj)) {  //注意：底层调用的是equals方法而不是==
                remove(i);
                
            }
        }
    }
    
    //替换某个位置上的元素，并返回被替换掉的那个对象
    public Object set(int index, Object obj) {
        rangeCheck(index);
        
        Object oldValue = elementData[index];
        elementData[index] = obj;
        return oldValue;
    }
    
    private void ensureCapacity() {
        //数组扩容和数据的拷贝
        if(size == elementData.length) {
            Object[] newArray = new Object[size*2 + 1];  //新建一个数组，长度是原来的2倍加1
            
            System.arraycopy(elementData, 0, newArray, 0, elementData.length);  //把老数组里的元素拷贝给新数组
            elementData = newArray;
            
        }
    }
    
    //检查数组是否越界
    private void rangeCheck(int index) {
        if(index<0 || index>=size) {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] args) {
        SxtArrayList list = new SxtArrayList(3);
        list.add("aaa");
        list.add("aaa");
        list.add("444");
        list.add(new Date());
        System.out.println(list.isEmpty());
        System.out.println(list.size());
        System.out.println(list.get(3));
        System.out.println("被替换掉的元素是：" + list.set(3, "345"));
        System.out.println("被替换后的元素是：" + list.get(3));
        list.add(2,"abc");
        System.out.println(list.get(2));
        
        list.remove(2);
        System.out.println("####################################");
        for(int i=0;i<list.size();i++) {
            System.out.println(list.get(i));
        }
        list.remove("aaa");
        System.out.println("####################################");
        for(int i=0;i<list.size();i++) {
            System.out.println(list.get(i));
        }
        
    
    }
    
}