动态数组

当我们不加static修饰的时候

我们需要创建一个对象才可以去访问

这里ArrayList是一个类名 

当是用static修饰的方法的时候  我们用类名.方法名进行访问即可 

清空的时候我们直接：

因为这条代码就已经告诉外界 我们动态数组的元素数量已经是0了 不可以再继续使用

这样我们可以在内部继续使用 也是一种节省空间的操作

 

 删除元素：

 把后面的元素往前挪就行了

 

 注意一点：把77的值赋值给前面一个的时候  

那么77怎么处理？

不处理即可  因为size--已经是告诉外界了  告诉了能访问的元素范围

 

当在某一个位置插入一个元素的时候

我们把这个位置及其以后的所有元素都往后挪动

 

 

 申请一块更大的内存空间

Java有垃圾回收机制  会自动回收原来的空间内存 

注意：

 因为所有的类都是继承于Object这个类的 

之后再强制转换为E[ ]类型

 对象数组：

 放地址节省空间

 这个objects[0]等等 存放的是引用地址

注意：

 

 当仅仅是销毁下标6处的引用指向这根线断掉

那么仅仅是下标为6处的元素被杀

倘若objects指向堆空间的主线断掉的时候

我们可知整个对象数组都没了

 当我们new引用类型时

那么对clear这个方法就要进行更新

这里不可以单单的对size=0进行操作了

若只是只样操作 但是对象的引用地址指向依然是保存着的  

 也就是说对象依旧存在着 外部依旧可以调用

 我们可以这样把每一个对象的引用地址给清空

但是我们的这块内存空间并没有消失

因此我们还可以在下一次new的时候创建新的对象  和引用指向

因此可循环利用。。

 

 总代码：

package 链表动态数组.动态数组;

public class ArrayList<E> {
    //元素的数量
    private int size;
    //所有的元素
    private E[] element;
    private static final int DEFAULT_CAPACITY=10;
private static final int ELEMENT_NOT_FOUND=-1;

    public ArrayList(int capaticy) {
       capaticy=(capaticy<DEFAULT_CAPACITY)?DEFAULT_CAPACITY:capaticy;
       element= (E[]) new Object[capaticy];
    }
public ArrayList(){
        //当main函数中new一个对象的时候 会调用这个无参构造器
    //把这个值传给有参构造器的参数
        this(DEFAULT_CAPACITY);
}
    /**
     * 清除所有元素
     */
    public void clear(){
        for (int i = 0; i < size; i++) {
            element[i]=null;
        }
        size=0;
    }
    /**
     * 元素的数量
     */
    public int size() {
     return size;
    }
    /**
     * 判断是否为空
     */
    public boolean isEmpty(){
      return size==0;
    }
    /**
     * 判断是否包含某个元素
     */
    public boolean contains(E elements){
       return indexOf(elements)!=ELEMENT_NOT_FOUND;
    }
    /**
     * 添加元素到尾部
     */
    public void add(E elements) {
element[size++]=elements;
    }
    /**
     * 获取index位置的元素
     */
    public E get(int index) {
       if(index<0||index>=size){
           throw new IndexOutOfBoundsException("index");
       }
       return element[index];
    }
    /**
     * 设置index位置的元素为elements
     */
    public E set(int index,E elements){
        if(index<0||index>=size){
            throw new IndexOutOfBoundsException("index");
        }
        E old=element[index];//把原来的元素取出来
        element[index]=elements;
        return old;
    }
    /**
     * 在index插入一个元素
     */
    public void add(int index,E elememts) {
        if(index<0||index>=size){
            throw new IndexOutOfBoundsException("index");
        }
        for (int i =size-1; i <=index; i++) {
            element[i+1]=element[i];
        }
        element[index]=elememts;
        size++;
    }
    /**
     * 删除index位置的元素
     */
    public E remove(int index){
        if(index<0||index>=size){
            throw new IndexOutOfBoundsException("index");
        }
        E old=element[index];//把原来的元素取出来
        for (int i =index+1; i <size-1; i++) {
            element[i-1]=element[i];
        }
        size--;
        return old;
    }
    /**
     * 查看元素的索引
     */
    public int indexOf(E elements){
        for (int i = 0; i <size; i++) {
            if(elements.equals(element[i])){
                return i;
            }
        }
        return ELEMENT_NOT_FOUND;//无此元素
    }
    /**
     * 保证capacity的容量够用
     */
    private void ensureCapacity(int capacity){
        int oldCapacity=element.length;
       if(oldCapacity>=capacity){
           return;
       }
       //我们通常扩容 新容量为旧容量的1.5倍
       int newCapacity=oldCapacity+(oldCapacity>>1);
       E[] newElement= (E[]) new Object[newCapacity];
        for (int i = 0; i <size; i++) {
            newElement[i]=element[i];
        }
       element=newElement;
    }
    /**
     *重写toString打印方法
     * 目标 打印出来 size=3,[1,2,3]
     */
    @Override
    public String toString() {
        StringBuilder string=new StringBuilder();
        string.append("size=").append(size).append(",[");
        for (int i = 0; i <size; i++) {
            string.append(element[i]);
            if(i!=size-1){
                string.append(",");
            }
        }
        string.append("]");
        return string.toString();
    }

    @Override
    public boolean equals(Object obj) {
        //这里面可以自定义比较的规则
    }

    public static void main(String[] args) {
        ArrayList.main(args);
    }
}