00_动态数组

数组：new 向堆空间申请一个存储空间

对象数组：数组中放的不是对象本身，放的是对象的地址值

删除所有元素

1. 能循环利用的留下，不能循环利用的滚蛋
2. 所以不可以断开堆与栈的线，而是断开数组与对象的线
3. 数组开辟的空间不需要再次创建 只让地址为null 即让数组里指向的对象挂掉

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

==与equals()方法

1. ==比较内存地址
2. equals()默认比较也是内存地址，但可以重写其方法指定怎样的比较
3. Interger类中重写了.equals()方法，所以不用重写就可以进行比较

@Override
public boolean euals(Object obj){
	Person person = (Person)obj;
	return this.age == person.age;
}

代码

import java.util.Arrays;
import java.util.Objects;

public class ArrayList<E> {

    private int size;
    private E[] elements;//所有的元素
    private static final int DEFAULT_CAPACITY = 10;//静态表示内存中只有一份 常量
    private static final int ELEMENT_NOTFOUND = -1;

    public ArrayList(){//缺省构造
        //elements = new int[DEFAULT_CAPACITY];
        this(DEFAULT_CAPACITY);
    }
    public ArrayList(int capaticy){
        capaticy = (capaticy < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capaticy;
        elements = (E[]) new Object[capaticy];
    }
    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size == 0;
    }

    //获取index位置的元素
    public E get(int index){
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("Index" + index + ",size:" + size);
        }
        return elements[index];
    }

    //设置index位置的元素
    public E set(int index, E element){
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("Index:" + index + ",size:" + size);
        }
        E old = elements[index];
        elements[index] = element;
        return old;
    }

    //返回元素的索引 
    public int indexOf(E element){
        for (int i = 0; i < size; i++){
            if(elements[i] == element)
                return i;
        }
        return ELEMENT_NOTFOUND;
    }

    //是否包含某元素
    public boolean contains(E element){
        return indexOf(element) != ELEMENT_NOTFOUND;
    }

    //清除所有元素
    /*
     *能循环利用的留下 不能循环利用的滚蛋 也就是数组开辟的空间不需要再次创建 只让地址为null 只让数组里指向的对象挂掉
     */
    public void clear(){
        for (int i = 0; i < size; i++){
            elements[i] = null;
        }
        size = 0;
    }

    //添加
    public void add(E element){
        //elements[size++] = element;
        add(size, element);
    }

    //保证容量
    private void ensureCapacity(int capacity){
        int oldCapacity = elements.length;
        if(oldCapacity < capacity){
            int newCapacity = oldCapacity + (oldCapacity >> 1); //右移一位相当于除以2
            E[] newElements = (E[]) new Object[newCapacity];
            for (int i = 0; i < size; i++){
                newElements[i] = elements[i];
            }
            elements = newElements;
        }

    }
    //在某位置添加元素
    public  void add(int index, E element){
        if(index < 0 || index > size){
            throw new IndexOutOfBoundsException("Index:" + index + ",size:" + size);
        }

        //扩容
        ensureCapacity(size + 1);
        for (int i = size - 1; i >= index; i--){
            elements[i + 1] = elements[i];
        }
        elements[index] = element;
        size++;
    }

    //删除
    public E remove(int index){
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("Index:" + index + ",size:" + size);
        }
        E old = elements[index];
        for(int i = index + 1; i < size - 1; i++){
            elements[i - 1] = elements[i];
        }
        //size--;

        elements[--size] = null;
        return old;
    }

    @Override
    public String toString() {
        StringBuilder string = new StringBuilder();
        string.append("size=").append(size).append(",[");
        for (int i = 0; i < size; i++){
            string.append(elements[i]);
            if(i != size-1){
                string.append(", ");
            }
        }
        string.append("]");
        return string.toString();
    }
}