自定义一个顺序表

 1.List

特性：（1）元素有逻辑上的前后关系

           （2）每个元素都有相应的下标（每个元素的索引位置）

2.自定义一个顺序表

1.顺序表大小（capacity）

  容量与元素个数：容量指的是整个顺序表能够存放的元素的大小，而元素个数指的是实际上存放在顺序表当中元素的个数，二者有明显的区分。

方法：

 2.MyList接口

package Java_DS.Arraylist;

public interface MyList {
    int size();
    boolean add(Long e);

    /**
     * 将 e 插入到线性表的 index 位置，从 [index, size()) 向后移
     * index 的合法下标 [0, size()]
     * 如果下标不合法：抛出一个 ArrayIndexOutOfBoundsException
     * @param index
     * @param e
     */
    void add(int index, Long e);

    /**
     * 删除 index 位置的元素
     * index 的合法下标：[0, size())
     * 如果下标不合法：抛出一个 ArrayIndexOutOfBoundsException
     * @param index
     * @return 从线性表中删除掉的元素
     */
    Long remove(int index);

    /**
     * 从前到后，删除第一个遇到的 e（ equals() == true）
     * @param e
     * @return 删除成功：true，没有该元素：false
     */
    boolean remove(Long e);

    /**
     * 直接返回 index 位置的元素
     * index: [0, size())
     * @param index
     * @return
     */
    Long get(int index);

    /**
     * 使用 e 替换 index 位置的元素
     * @param index [0, size())
     * @param e
     * @return 原来 index 位置的元素
     */
    Long set(int index, Long e);

    /**
     * 返回第一次遇到 e 的下标（equals() == true）
     * @param e
     * @return 如果没有找到，返回 -1
     */
    int indexOf(Long e);

    /**
     * 从后往前，返回第一次遇到 e 的下标（equals() == true）
     * @param e
     * @return 如果没有找到，返回 -1
     */
    int lastIndexOf(Long e);

    /**
     * 线性表中是否包含 e（equals）
     * @param e
     * @return
     */
    boolean contains(Long e);

    /**
     * 清空线性表
     */
    void clear();

    /**
     * 判断线性表是否是空的（empty） 等价于一个元素都没有
     * @return
     */
    boolean isEmpty();
}

3.MyArrayList

package Java_DS.Arraylist;

import java.util.Arrays;

public class MyArrayList implements MyList {
    private Long [] Array;//Array是指向一个数组的
    int size;
    public MyArrayList(){
        this.size=0;
        this.Array=new Long[20];//this.Array指向了一个存放元素为Long类型的数组
    }

    @Override
    public String toString() {
        return "MyArrayList{" +
                "Array=" + Arrays.toString(Array) +
                ", size=" + size +
                '}';
    }

    public MyArrayList(int initialCapacity){
        this.size=0;
        this.Array=new Long[initialCapacity];
    }
    @Override
    public int size() {
        return size;
    }
    public void Bigger(){
        if(this.size<this.Array.length){
            return;
        }
        int NewLength=this.Array.length*2;
        Long[] newArray=new Long[NewLength];
        for (int i = 0; i < this.Array.length; i++) {
            newArray[i]=this.Array[i];
        }
        this.Array=newArray;
    }
    @Override
    public boolean add(Long e) {
        Bigger();
        Array[size]=e;
        size++;
        return true;
    }

    @Override
    public void add(int index, Long e) {
        Bigger();
        if(index<0|index>size){
            throw new ArrayIndexOutOfBoundsException("插入下标有误！");
        }
        for (int i = size-1; i >=index ; i--) {
            Array[i+1]=Array[i];
        }
        Array[index]=e;
        size++;
    }

    @Override
    public Long remove(int index) {
        if(index<0||index>=size){
            throw new ArrayIndexOutOfBoundsException("删除下标有误！");
        }
        else if(Array[index]==null) {
            return null;
        }
        Long e=Array[index];
        for (int i = index+1; i <size ; i++) {
            Array[i-1]=Array[i];
        }
        Array[size-1]=null;
        size--;
        return  e;//返回删除的元素
    }

    @Override
    public boolean remove(Long e) {
        for (int i = 0; i <size ; i++) {
            if(Array[i]==e){
                for (int j = i+1; j <size ; j++) {
                    Array[j-1]=Array[j];
                }
                Array[size-1]=null;
                size--;
                return true;
            }
        }
        return false;
    }

    @Override
    public Long get(int index) {
        if(index<0||index>=size){
            throw new ArrayIndexOutOfBoundsException("删除下标有误！");
        }
        return Array[index];
    }

    @Override
    public Long set(int index, Long e) {
        if(index<0||index>=size){
            throw new ArrayIndexOutOfBoundsException("删除下标有误！");
        }
        Long old=Array[index];
        Array[index]=e;
        return old;
    }

    @Override
    public int indexOf(Long e) {
        for (int i = 0; i < size; i++) {
            if(Array[i]==e){
                return i;
            }
        }
        return -1;
    }

    @Override
    public int lastIndexOf(Long e) {
        for (int i = size-1; i >=0 ; i--) {
            if(Array[i].equals(e)){
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean contains(Long e) {
        for (int i = 0; i < size; i++) {
            if (Array[i].equals(e)){
                return true;
            }
        }
        return false;
    }

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

    @Override
    public boolean isEmpty() {
        if(size==0){
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        MyArrayList myArrayList=new MyArrayList();
        myArrayList.add(10L);
        myArrayList.add(10L);
        myArrayList.add(10L);
        myArrayList.add(10L);
        myArrayList.add(10L);
        System.out.println(myArrayList.toString());
    }
}

3.总结

1.注意对引用的理解

2.准确判断边界

3.重载：add    remove

4.扩容机制：1.5倍扩容（具体可以查看源码）