java中的ArrayList的学习笔记

ArrayList是一个集合类，其中对数组进行了封装，可以实现可变数组，和数组采用相同的存储方式，在内存中分配连续的空间，经常称ArrayList为动态数组。
ArratList是实现了List接口，用起来很方便，一些常用的发方法如下


下面参考源码实现其中的一些方法（具体的实现参考源码）
【首先实现添加元素】

• 首先判断数组中是否满了
• 如果装满了，扩容
• 否则给数组中添加

public class MYarrayList {

    private int size;
    private Object [] data = new Object[3];
    public void add(Object o){
        if(size == data.length){
            grow();
        }
        data[size] = o;
        size ++;
    }
    private void grow(){
        System.out.println("扩容");
        Object []newarr = new Object[data.length * 2];
        newarr = Arrays.copyOf(data,newarr.length);
        data = newarr;
    }
}

【对扩容进行分析】
上面扩容的思路就是新创建一个大小为其原来数组二倍的数组，将原来数组中的值全部复制过来，然后替换原来数组的引用。
【其他的一些方法如下所示】

package day0308.myarraylist;
import java.util.*;

public class MyArrayList {
    private int size;
    private Object[] objects;

    public MyArrayList() {
        objects = new Object[5];
    }

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

    @Override
    public boolean isEmpty() {
        if (size == 0) {
            return true;
        }
        return false;
    }
    @Override
    public boolean add(Object o) {
        if (size == objects.length) {
            grows();
        }
        objects[size++] = o;
        return true;
    }

    private void grows() {
        System.out.println("扩容");
        objects = Arrays.copyOf(objects, objects.length * 2);
    }

    @Override
    public boolean remove(Object o) {
        int index = indexOf(o);
        if (index >= 0) {
            System.arraycopy(objects, index + 1, objects, index, size - index - 1);
            objects[size] = null;
            size--;
            return true;
        }
        return false;
    }

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

    @Override
    public Object get(int index) {
        if (index < 1 || index > size) {
            throw new IllegalArgumentException("参数错误");
        }
        return objects[index - 1];
    }

    @Override
    public Object set(int index, Object element) {
        if (index < 0 || index > size - 1) {
            throw new IllegalArgumentException("参数错误");
        }
        Object overvalue = objects[index];
        objects[index] = element;
        return overvalue;
    }

    @Override
    public void add(int index, Object element) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("参数错误");
        }
        if (index == size) {
            grows();
        }
        System.arraycopy(objects, index, objects, index + 1, size - index);
        objects[index] = element;
        size++;
    }

    @Override
    public Object remove(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("参数错误");
        }
        Object o = objects[index];
        System.arraycopy(objects,index+1,objects,index,size- 1-index);
        size--;
        return o;
    }

    @Override
    public boolean contains(Object o){
        return indexOf(o) >= 0;
    }
    @Override
    public int indexOf(Object o) {
        return indexofRange(o,0,size);
    }
    public int indexofRange(Object o,int start,int end){
        Object []es = objects;
        if(o == null){
            for (int i = start; i < end; i++) {
                if(es[i] == null){
                    return i;
                }
            }
        }
        else{
            for (int i = start; i < end; i++) {
                if(o.equals(es[i])){
                    return i;
                }
            }
        }
        return -1;
    }

    @Override
    public int lastIndexOf(Object o) {
        for (int i = size-1; i >0; i--) {
            if(objects[i].equals(o)){
                return i;
            }
        }
        return -1;
    }
    @Override
    public String toString() {
        StringBuffer str = new StringBuffer();
        for (int i = 0; i < size; i++) {
            str.append(objects[i] + ", ");
        }
        return str.substring(0, str.length() - 2);
    }
}

以上只是一些方法，并没有完全实现List，所以在类的地方并没有implements