数组

数组：把数据码成一排进行存放。

索引从0开始：

数组优点：快速查询。
数组最好应用于“索引有语意"的情况。

数组类：

public class Array<E> {
    private  E[] data;
    /**
     * size 元素个数+1(注意元素个数不是数组长度)
     */
    private int size;
    /**
     * capacity 数组容量
     * @param capacity
     */
    public Array(int capacity){
        data=(E[]) new Object[capacity];
        size=0;
    }
    /**
     * 默认的构造函数 数组容量为10
     */
    public Array(){
        this(10);
    }
    /**
     * 获取数组中的元素个数
     * @return
     */
    public int getSize(){
        return size;
    }
    /**
     * 获取数组容量
     */
    public int getCapacity(){
        return  data.length;
    }
    /**
     * 数组是否为空
     * @return
     */
    public boolean isEmpty(){
        return size==0;
    }
    /**
     * 向所有元素后添加一个元素
     * @param e
     */
    public void addLast(E e){
        add(size,e );
    }
    /**
     * 向所有元素前添加一个元素
     */
    public void addFirst(E e){
        add(0, e);
    }
    /**
     * 向指定位置添加元素
     */
    public void add(int index,E e){
        //设置index>size 是希望元素是紧密排列的，而不是散的
        if (index<0 || index>size)
            throw new IllegalArgumentException("AddLast 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索引位置的元素
     * @param index
     * @return
     */
    public E get(int index) {
        if (index<0 || index>= size)
            throw  new IllegalArgumentException("Get failed. Index is illegal");
        return data[index];
    }
    /**
     * 获取数组的最后一个元素
     * @return
     */
    public E getLast(){
        return get(size-1);
    }
    /**
     * 获取数组第一个元素
     * @return
     */
    public E getFirst(){
        return get(0);
    }
    /**
     * 更新数组元素
     * @return
     */
    void set(int index,E e){
        if (index<0 || index>= size)
            throw  new IllegalArgumentException("Get failed. Index is illegal");
        data[index]=e;
    }
    /**
     * 查找数组中是否有元素e
     * @param e
     * @return
     */
    public  boolean contains(E e)
        {
        for (int i=0;i<size;i++){
            if (data[i].equals(e))
                return true;
        }
        return false;
    }
    /**
     * 查找数组中元素e所在的索引，如果不存在元素e，则返回-1（只查找第一个）
     * @param e
     * @return
     */
    public int find(E e){
        for (int i=0;i<size;i++){
            if (data[i].equals(e))
                return i;
        }
        return -1;
    }
    /**
     * 查找所有元素e的索引  如果不存在元素，返回null,
     */
    public List<Integer> findAll(E e){
        List<Integer> list=new ArrayList();
        for (int i=0;i<size;i++){
            if (data[i]==e) {
                list.add(i);
            }
        }
        if (list.size()==0)
            return null;
        return list;
    }
    /**
     * 删除指定位置的元素,返回删除的元素
     * 删除指定位置的时候，后面的元素往前移动，但
     * size位置还会有一个多余的元素，因为是从后往前复制的
     * @return
     */
    public E remove(int index){
        if (index<0 || index>= size)
            throw  new IllegalArgumentException("remove failed. Index is illegal");
        E datum = data[index];
        for (int i=index+1;i<size;i++)
            data[i-1]=data[i];
        size--;
        // data[size]里存着一个类对象的引用，不会被回收，但
        //实际上这个元素没啥卵用了。让gc回收了这个多余的数据，设置为null，
        //那么这个对象就不再和程序中其他对象相关联了，可以被回收了。
        data[size]=null;
        //当数组的元素个数等于数组的长度的一半时
        //缩容 当缩容到length等于1时，就不能在缩了
        if(size==data.length/4 && data.length/2 !=0)
            resize(data.length/2);
        return datum;
    }
    /**
     * 删除第一个元素,返回删除的元素
     * @return
     */
    public E removeFirst(){
        return remove(0);
    }
    /**
     * 删除最后一个元素，返回删除的元素
     * @return
     */
    public E removeLast(){
        return remove(size-1);
    }
    /**
     * 如果数组中存在元素e，就删除元素e(如果有多个e，只删除第一个)
     * @return
     */
    public  String removeElement(E e){
        int index=find(e);
        if(index!=-1)
            remove(index);
        else
            return e+" is not find";
        return "deleted";
    }
    /**
     * 删除数组中的所有e
     * @return
     */
    public void removeAllElement(E e){
     List<E> all = (List<E>) findAll(e);
     all.forEach(a->{
         int i1 = find(e);
         remove(i1);
     });
    }
    @Override
    public  String toString(){
        StringBuilder res=new StringBuilder();
        res.append(String.format("Array: size= %d , capacity= %d\n",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();
    }
    /**
     * 数组大小改变
     * @param newCapacity
     */
    private void resize(int newCapacity)
    {
        E[] newData=(E[])new Object[newCapacity];
        for (int i=0;i<size;i++)
            newData[i]=data[i];
        data=newData;
    }
}

分析动态数组的时间复杂度：

• 添加操作 总的来说O(n)
  addLast(e) O(1)
  addFirst(e) O(n)
  add(index,e) O(n/2)=O(n) 严格计算需要概率论知识
  通常考虑的是最坏的情况
  resize O(n)
• 删除操作 总的来说O(n)
  removeLast(e) O(1)
  removeFirst(e) O(n)
  remove(index,e) O(n/2)=O(n)
  resize O(n)
• 修改操作
  set(index ,e) O(1)
• 查询操作
  get(index) O(1)
  contains(e) O(n)
  find(e) O(n)

增 O(n)
删 O(n)
改 已知索引O(1) 未知索引 O(n)
查 已知索引O(1) 未知索引 O(n)
对于增删如果只对最后一个元素操作依然是O(n),因为resize；

resize复杂度分析
容量8的数组

平均每次addLast操作，进行两次基本操作，均摊下来，意味着时间复杂度是O(1)。在这个例子里，这样均摊计算，比计算最坏情况有意义。这样计算复杂度称为均摊复杂度。一个相对比较耗时的操作，如果我们能保证它不会每次都触发的话，那么相对比较耗时的操作相应的时间是可以分摊到其他的操作来的。
同理，removeLast操作，均摊时间复杂度也是O(1)。

复杂度震荡
同时看addLast和removeLast操作。
一个数组已经满元素，容量n。

先添加一个元素扩容时间复杂度O(n),然后又删除一个元素，触发缩容O(n) …
制造的情景，每一次addLast,removeLast都会耗费O(n)的复杂度，这就是复杂度的震荡。明明均摊的时候是O(1),但在某些特殊情况下，猛的窜到了O(n)，产生了震荡。

出现的原因： removeLast时resize过于着急（Eager）。
解决方案：Lazy的方式，懒一些，懒机制

代码修改：
前：

后：