自己手动实现一个的ArrayList - Java

链接: 浅析list链表基本使用.

常用方法

add，remove，size,get,isEmpty等等，嗯，下面我根据源码简单的写了一个实现。

首先声明一个Object类型的数组，一个数组内元素个数

private Object[] elementData;
private int size;

写一个size方法，主要是返回还有多少个数

public int size() {
    
    
        return size;
    }

现在写构造方法ArrayListTest （就是仿写ArrayList）

public ArrayListTest(){
    
    
        this(10);
        //调用另一个构造方法(有参构造方法)，所以，必须有一个有参构造方法
    }

    public ArrayListTest(int initialCapacity) {
    
    
    //有参构造方法，实现数组容量的初始化
        if(initialCapacity<0) {
    
    
            try {
    
    
                throw new Exception();
            }catch(Exception e){
    
    
                e.printStackTrace();
            }
        }
        elementData=new Object[initialCapacity];
        //初始化，容量为10  与前面的数组声明对应
    }

现在写一个add()方法

对源码里面add是一个boolean方法，我知道，我就是简写一下；

public void add(Object obj) {
    
    
        //首先，判断数组是否装满，是则扩容
        elementData[size++]=obj;
        //扩容过程；
        if(size==elementData.length) {
    
    
            //创建一个新数组
            Object[] newArray=new Object[2*size+1];
            //将老数组拷贝到新数组内
            System.arraycopy(elementData, 0, newArray, 0, elementData.length);
            //再将新数组赋值给老数组
            elementData=newArray;
        }
    }

//知道你们懒的看，我给复制了一下这个是源码里面的。
	public boolean add(E e) {
    
    
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

写一个rangCheck()用来判断是不是越界了。

 private void rangCheck(int index) {
    
    
        if(index<0||index>size) {
    
    
            try {
    
    
                throw new Exception();
            }catch(Exception e) {
    
    
                e.printStackTrace();
            }
        }

    }

写一个get()方法

得到数组实质就是一个数组的索引操作

 public Object get(int index) {
    
    
        //检查下标是否越界
        rangCheck(index);
        return elementData[index];

    }

写remove（）方法，跟add差不多

public void remove(int index){
    
    
        rangCheck(index);
        //删除指定位置对象，删除某位置，相当于 将后往前挪:
        int numMoved = size-index-1;
        if(numMoved>0){
    
    
            System.arraycopy(elementData, index+1, elementData, index, numMoved);
        }
        elementData[--size] = null;
    }
    public void remove(Object obj){
    
    
        for(int i=0;i<size;i++){
    
    
            if(get(i).equals(obj)){
    
       
            //注意底层调用的equals方法而不是==。
                remove(i);
            }
        }

    }

写一个isEmpty（）方法

//这个可以跟源码一样，哈哈哈可以直接用！
public boolean isEmpty() {
    
    
        return size == 0;
    }

写一个main（）试一试

 public static void main(String[] args) {
    
    
        ArrayListTest list=new ArrayListTest();
        list.add("北京");
        list.add("海淀");
        list.add("wk");
        list.add("wkk");
        list.add("wukeke");

        System.out.println("list内拥有："+list.size()+"个元素");
        list.remove("wk");
        System.out.println("list内拥有："+list.size()+"个元素");
        System.out.println(list.isEmpty());
    }

总结

这个其实是我看了一个别的大佬的文章，然后我查出来了那个大佬remove方法有点问题，然后自己看源码，发现少了一行代码，所以我加上了，然后自己看了看源码，有什么简单方法，我就顺手写了一下，看源码，有好处，日常总结

完整的代码

package dknow;

/**
 * @name : wkk
 * @description:
 * @author: Andy
 * @time: 2021/1/20 17:47
 */
public class ArrayListTest {
    
    
    //声明一个Object类型的数组
    private Object[] elementData;
    //声明一个数组内元素个数
    private int size;

    public int size() {
    
    
        return size;
    }

    //定义一个无参构造函数,初始化数组内个数，这个可以不写，然后在main方法里面new的ArrayListTest的后面加个数也行。
    public ArrayListTest(){
    
    
        this(10);//调用另一个构造方法(有参构造方法)，所以，必须有一个有参构造方法
    }

    public ArrayListTest(int initialCapacity) {
    
    //有参构造方法，实现数组容量的初始化
        if(initialCapacity<0) {
    
    
            try {
    
    
                throw new Exception();
            }catch(Exception e){
    
    
                e.printStackTrace();
            }
        }
        elementData=new Object[initialCapacity];//初始化，容量为10    与前面的数组声明对应
    }
    //重点***********
    public void add(Object obj) {
    
    
        //首先，判断数组是否装满，是则扩容
        elementData[size++]=obj;
        if(size==elementData.length) {
    
    
            //创建一个新数组
            Object[] newArray=new Object[2*size+1];
            //将老数组拷贝到新数组内
            System.arraycopy(elementData, 0, newArray, 0, elementData.length);
            //再将新数组赋值给老数组
            elementData=newArray;
        }
    }

    //get方法，得到数组实质就是一个数组的索引操作
    public Object get(int index) {
    
    
        //检查下标是否越界
        rangCheck(index);
        return elementData[index];

    }

    public void remove(int index){
    
    
        rangCheck(index);
        //删除指定位置对象，删除某位置，相当于 将后往前挪:
        int numMoved = size-index-1;
        if(numMoved>0){
    
    
            System.arraycopy(elementData, index+1, elementData, index, numMoved);
        }
        elementData[--size] = null;
    }
    public void remove(Object obj){
    
    
        for(int i=0;i<size;i++){
    
    
            if(get(i).equals(obj)){
    
       //注意底层调用的equals方法而不是==。
                remove(i);
            }
        }

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

    private void rangCheck(int index) {
    
    
        if(index<0||index>size) {
    
    
            try {
    
    
                throw new Exception();
            }catch(Exception e) {
    
    
                e.printStackTrace();
            }
        }

    }

    public static void main(String[] args) {
    
    
        ArrayListTest list=new ArrayListTest();
        list.add("北京");
        list.add("海淀");
        list.add("wk");
        list.add("wkk");
        list.add("wukeke");

        System.out.println("list内拥有："+list.size()+"个元素");
        list.remove("wk");
        System.out.println("list内拥有："+list.size()+"个元素");
        System.out.println(list.isEmpty());
    }
}