模拟实现ArrayList顺序表

---

代码实现

public class MyArraylist {
    private String[] data=null;//存放元素
    private int size=0;
    public MyArraylist(){
        data=new String[10];//初始10个容量
    }
    public MyArraylist(int capacity){
        if(capacity<=10){
            data=new String[10];
        }else{
            data=new String[capacity];
        }
    }

    //实现扩容操作
    private void resize(){
        //1.创建更长的数组,常务为原来的1.5倍
        int newsize=(int)(size*1.5);
        String[] newdata=new String[newsize];
        //2.把旧数组的元素放到新数组中
        for(int i=0;i<size;i++){
            newdata[i]=data[i];
        }
        //3.用新的数组代替旧的数组
        data=newdata;//把新数组的地址赋给旧数组
        //注:data(数组名)是引用类型,它存放的是一段连续口评鉴的地址,而不是数组本身
    }

    //实现尾插
    public void add(String element){
        if(size>=data.length){
            //扩容
            resize();
        }
        data[size]=element;
        size++;
    }

    //往中间位置插入
    public void add(int index,String element){
        //判定index是否合法
        if(index<0||index>size){
            throw new IndexOutOfBoundsException("Index:"+index+", Size:"+size);
        }
        if(size>=data.length){resize();}
        //把元素放到index上(前一个元素放到后一个元素上)
        for(int i=size;i>=index;i--){
            data[i]=data[i-1];
        }
        data[index]=element;//放入元素
        size++;
    }

    //按照下标删除,返回被删除的值
    public String remove(int index){
        if(index<0 || index>=size){
            throw new IndexOutOfBoundsException("Index:"+index+",Size:"+size);
        }
        String element=data[index];
        for(int i=index;i<size-1;i++){ //让后面的元素覆盖前面的元素
            data[i]=data[i+1];
        }
        size--;
        return element;
    }

    //按照元素值来删除,删除成功返回true,失败返回false
    public boolean remove(String elem){
        for(int i=0;i<size;i++){
            if(data[i].equals(elem)){
                remove(i); //调用按照下标移除元素
                return true;
            }
        }
        return false;
    }

    //获取下标index的元素
    public String get(int index){
        if(index<0||index>=size){ //注:一定要判断下标是否越界
            throw new IndexOutOfBoundsException("Index:"+index+"Size:"+size);
        }
        return data[index];
    }

    //将下标index元素设置为element
    public void set(int index,String element){
        if(index<0||index>=size){
            throw new IndexOutOfBoundsException("Index:"+index+"Size:"+size);
        }
        data[index]=element;
    }

    //清空所有元素
    public void clear(){
        size=0;
    }

    //判断元素是否在线性表中
    public boolean contains(String element){
        for(int i=0;i<size;i++){
            if(data[i].equals(element))
                return true;
        }
        return false;
    }

    //返回第一个出现元素的下标indexOf
    public int indexOf(String element){
        for(int i=0;i<size;i++){
            if(data[i].equals(element)){
                return i;
            }
        }
        return -1;
    }

    public int lastIndexOf(String element){
        for(int i=size-1;i>=0;i--){
            if(data[i].equals(element))
                return i;
        }
        return -1;
    }

    //取部分list
    public MyArraylist sublist(int fromIndex,int toIndex){
        //创建一个新的Arraylist对象,把区间元素加到新对象中
        if(fromIndex<0||toIndex>size||fromIndex>toIndex){
            throw new IndexOutOfBoundsException("fromIndex:"+fromIndex+",toIndex:"+toIndex+",size:"+size);
        }
        MyArraylist sublist=new MyArraylist(toIndex-fromIndex);
        for(int i=fromIndex;i<toIndex;i++){
            String elem=this.get(i);
            sublist.add(elem);//尾插
        }
        return sublist;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder=new StringBuilder();
        stringBuilder.append("[");
        for(int i=0;i<size;i++){
            stringBuilder.append(data[i]);
            if(i<size-1)
                stringBuilder.append(",");
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }

    public static void main(String[] args) {
        MyArraylist list=new MyArraylist();
        list.add("12");
        list.add("13");
        list.add(1,"4");
        System.out.println(list);
    }
}

功能

1. 成员变量：

• private String[] data=null; ：用于存储元素的数组。
• private int size=0; ：记录当前数组中实际存储的元素个数。

2. 构造函数：

• public MyArraylist() ：默认构造函数，初始化一个容量为10的数组。
• public MyArraylist(int capacity) ：带参数的构造函数，根据传入的容量 capacity 初始化数组。如果 capacity 小于等于10，则初始化为容量10；否则初始化为 capacity 。

3. 扩容方法：

• private void resize() ：当数组已满时，将数组容量扩大到原来的1.5倍。具体步骤为：创建一个新的更大的数组，将原数组元素复制到新数组，然后用新数组替换原数组。

4. 添加元素方法：

• public void add(String element) ：在数组末尾添加元素。如果数组已满，先进行扩容，然后将元素添加到数组末尾，并增加 size 。
• public void add(int index, String element) ：在指定下标 index 处插入元素。首先检查 index 是否合法，若数组已满则扩容。然后将 index 及之后的元素向后移动一位，再将新元素插入 index 位置，并增加 size 。

5. 删除元素方法：

• public String remove(int index) ：删除指定下标 index 处的元素，并返回被删除的元素。首先检查 index 是否合法，然后将 index 之后的元素向前移动一位，覆盖要删除的元素，并减少 size 。
• public boolean remove(String elem) ：删除指定元素值 elem 。遍历数组找到该元素，调用 remove(int index) 方法删除，并返回删除是否成功。

6. 获取和设置元素方法：

• public String get(int index) ：获取指定下标 index 处的元素。首先检查 index 是否合法，然后返回对应位置的元素。
• public void set(int index, String element) ：将指定下标 index 处的元素设置为 element 。首先检查 index 是否合法，然后替换对应位置的元素。

7. 其他方法：

• public void clear() ：清空数组，将 size 置为0。
• public boolean contains(String element) ：判断数组中是否包含指定元素。遍历数组，若找到则返回 true ，否则返回 false 。
• public int indexOf(String element) ：返回指定元素第一次出现的下标。遍历数组，若找到则返回下标，否则返回-1。
• public int lastIndexOf(String element) ：返回指定元素最后一次出现的下标。从数组末尾开始遍历，若找到则返回下标，否则返回-1。
• public MyArraylist sublist(int fromIndex, int toIndex) ：返回一个新的 MyArraylist ，包含原数组中从 fromIndex （包括）到 toIndex （不包括）的元素。首先检查 fromIndex 和 toIndex 是否合法，然后创建新对象并将指定区间的元素添加到新对象中。
• @Override public String toString() ：将数组转换为字符串形式，格式为 [element1,element2,…] 。

顺序表擅长的功能:

1. 尾插
2. 根据下标获取/修改元素

两者的时间复杂度都为O(1) , 其他操作为O(N)

顺序表是基于数组实现
创建顺序表的时候, 会先申请一块空间

顺序表的局限性:

1. 空间利用率较低
2. 中间位置的插入删除 , 都需要进行搬运
   而这些链表能很好实现