动态数组

如果数组是不变的，当数据大小超过了数组的容量则会导致内存不足，如果数据过少，开辟的数组容量过大会造成空间的浪费。此时可以设计一个随着存储的数组元素动态调整数组容量大小，就较为方便。如何设置数组空间大小就较为关键了。

数组装满需要另外开辟一个新的数组空间

新的数组容量翻倍

将原来的数组的值对应赋值到新的数组空间中去

原来的引用data也同时指向新的空间

java的垃圾回收机制将原来的四个元素空间的数组清除

代码实现：

public class Array<E>{
    pritvate E[] data;
    private int size;
//私有成员变量 数组类型，名字，存储数
// 构造函数，传入数组的容量capacity构造Array
public Array(int capacity){
      data = (E[])new Object[capacity];
      size = 0;
}

//无参数的构造函数，默认数组的容量capacity=10
public Array(){
     this(capacity: 10);
}
//获取数组中元素的个数
public int getSize(){
   return size;
}
//获取数组的容量
public int getCapacity(){
   return data.length;
}
//返回数组是否为空
public boolean isEmpty(){
   return size==0;
}
//向所有元素后添加一个新元素
public void addlast(E e){
//if(size == data.length)
  //  throw new IllegalArgumentException("AddLast failed. Array is full.")
//data[size] = e;
//size++;
       add(size, e);
}
//在所有元素前面添加一个元素
public void addFirst(E e){
    add(index:0, e);
}
 //在第index位置插入一个新元素（指定位置插入）e
public void add(int index , E e){
  if(index < 0 ||index >size）
          throw new IllegalArgumentException("Add failed. Require index >= 0 and  index<= size.")
  if（size == data.length)
        resize(2*data.length);  //扩容为原来的几倍在一个数量级，最优是两倍

  for(int i = size - 1 ; i >=index ; i --)
       data[i+1] = data[i];
   data[index] = e;
   size ++;
 }
// 获取index索引位置的元素
public E get(int index){
     if(index < 0 || index >=size)
        throw new IllegalArgumentException("Get failed. Index is illegal.");
     return data[index];
}
//修改index索引位置的元素为e
public void set（int index ， E e）{
   if（index < 0 || index >= size)
       throw new IllegalArgumentException（” get failed, index is Illegal");
   data[index] = e;
}
//查找数组中是否有元素e （是否包含e）
public boolean contains(E e){
     for(int i = 0; i < size ; i ++){
         if(data[i].equals(e))
             return true;
}
      return false;
}
//查找数组中元素e所在的索引，如果不存在元素e，则返回 -1(搜素元素e）
public int find(E e){
     for(int i = 0; i < size ; i ++){
        if(data[i].equals(e))
            return i;
}
     return -1;
}
//从数组中删除index位置的元素，返回删除元素
public E remove(int index){
   if(index < 0 || index >= size)
      throw new IllegalArgumentException("Remove failed. Index is Illegal.")
 
   E ret = data[index]
   for(int i = index +1 ; i < size ; i ++)
       data[i-1] = data[i];
   size --; 
   data[size] = null; //loitering objects !=memory leak
   if(size == data.length /4)  //动态数组缩小时采用lazy的方法当数组元素达到1/4时缩减一半，还预留了一定的空间，不至于频繁调节增大时间复杂度。
      resize(newCapacity:data.length / 2);
   return ret;
}
//从数组中删除第一个元素
public E removeFirst(){
          return remove(index: 0);
}
//从数组中删除最后一个元素，返回删除的元素
public E removeLast(){
    return remove(index:size -1);
}
//从数组中删除元素e
public void removeElement(E e){
  int index = find(e)
  if(index != -1)
    remove(index);
}

@Override
public String toString(){
       StringBuilder res = new StringBuilder();
       res.append(String.format("Array: size = %d ,capacity = %d, size, data.length))
       res.append('[');
       for(int i = 0 ; i < size ; i++){
            res.append(data[i]); 
            if(i!=size-1) 
                res.append(", ");
       }
       res.append(']');
       return res.toString();
  }
private void resize(int newCapacity){
  E{} newData = (E[])new Object[newCapacity];
  for(int i = 0; i<size ; i ++)
     newData[i] = data[i];
  data = NewData;
}
                res.append(", ");