线性结构（顺序表）

       1. 概述：

        顺序表是在计算机内存中以数组的形式保存的一种数据结构,它是用一组地址连续的存储
单元依次存储线性表中的各个元素

 

        2.性能：

                1.get获取数据方法，由于可以直接通过下表获取数组中对应的元素，所以时间复杂度O(1),性能是非常优秀的。
                2.add插入元素，需要把当前位置的元素都向后移动一个位置，时间复杂度是O(n)。同时如果数组已经放满的话，还有扩容的操作。
                3.remove删除元素，需要把删除位置后面的元素全部向前移动一个位置，时间复杂度是O(n)。

       3.自己做一个线性表：

                        基本设计：

public class MyArrayList<T> {
//成员变量
                private Object[] items; //存储的元素
                private int size; //存储元素的数量
//构造方法
                public MyArrayList(int capacity);
//常用方法
                public int size();//获取当前存储元素的数量
                public T get(int i);//获取指定位置的元素
                public void add(T t);/在尾部添加元素
                public void add(int i,T t); //在指定位置添加元素
                public T remove(int i); //删除指定位置的元素
}

         4.扩容问题：

        由于数组的长度是固定的,当所有的数组都存放了元素之后,再次插入元素的时候就会出现没有存储空间的问题,并且会抛出数组越界的异常。

                由于数组在创建的时候分配的内存是固定的,之后是不可以在添加的.所以可以创建
个新的数组,容器的大小之后是之间的两倍然后将原有的数组赋值到新的数组中。

 

        5.自己实现的代码：

package sequenceList;
/**
 * 顺序表
 * */
public class MyArrayList<T> {
//    成员变量
    private Object[] items;//存储的元素。
    private int size;      //存储元素的数量。

//    构造方法
    public MyArrayList(int capacity){
        //创建一个数组
        this.items=new Object[capacity];
        //初始化元素的数量
        this.size=0;
    }

    /**
     * 数组扩容：
     *      1.由于数组在创建的时候分配的内存是固定的，之后是不可以再添加的，所以可以创建
     *一个新的数组，容器的大小之后比之前扩大到两倍。
     *      2.然后将原有的数组赋值到新的数组中。
     * */

    //实现扩容方法
    public void resize(int size){
        //创建一个新的数组。
        Object[] newItems=new Object[size];
        //将原来数组的元素复制到新的数组中
        for (int i = 0; i < this.size; i++) {
            newItems[i]=this.items[i];
        }
        //将新的数组赋值给老的数组
        this.items=newItems;
    }

//    常用方法
    //获取当前存储元素的数量
    public int size(){
        return this.size;
    }

    //获取指定位置的元素O(1)，注意扩容
    public T get(int i){
        return (T)this.items[i];
    }

    //在尾部加入元素O(1)
    public void add(T t){
        //判断数组元素是否已经填满
        if (this.size==this.items.length){
            //需要扩容
            this.resize(this.items.length*2);
        }
        this.items[this.size]=t;
        //累计添加元素数量
        this.size++;
    }

    //在指定的位置加入元素O(n),注意扩容
    public void add(int i,T t){
        //判断数组元素是否已经填满
        if (this.size==this.items.length){
            //需要扩容
            this.resize(this.items.length*2);
        }
        //通过遍历将i之后的元素依次向后移动一格
        for (int j = this.size-1; j >=i ; j--) {
            this.items[j+1]=this.items[j];
        }
        //将需要插入的元素放入到i的位置
        this.items[i]=t;
        //累计添加元素的数量
        this.size++;
    }

    //删除指定位置的元素O(n),注意缩容。
    public T remove(int i){
        T t=(T) this.items[i];
        //从插入的位置的后面一个元素开始，将后面的元素向前移动一格
        for (int j = i+1; j < this.size; j++) {
            this.items[j-1]=this.items[j];
        }
         //数量减少
        this.size--;
        //返回删除的元素
        return t;
    }
}

         6.测试的代码

package sequenceList;


public class TestMyArraylist {
    public static void main(String[] args) {
        //创建顺序表。
        MyArrayList<String> list=new MyArrayList<>(10);

        //刚创建时数组长度
        System.out.println("刚创建时的长度为："+list.size());

        //添加元素。
        for (int i = 0; i<20; i++) {
            list.add("我是第"+i+"个数据");
        }
        System.out.println("加入元素后的长度为："+list.size());

        //删除指定位置的元素
        list.remove(2);

        //在指定的位置添加一个元素
        list.add(1,"11");
        System.out.println("现在元素的长度为："+list.size());
        //遍历顺序表
        for (int i = 0; i < list.size(); i++) {
            String str= list.get(i);
            System.out.println(str);
        }

//        System.out.println(ArrayList);

    }
}