第16天 数组、链表的元素增删改查的实现

数组的增删改查

package cn.javasm.demo;

import java.util.Arrays;
import java.util.Objects;

/**
 * @className: ArrayListDemo
 * @description  模拟ArrayList
 * @author: gfs
 * @date: 2024/4/26 9:52
 * @version: 0.1
 * @since : jdk11
 */
public class ArrayListDemo {

    // 存储数据的数组
    private String[] data;

    // 实际元素的个数
    private int size;

    // 定义无参构造
    public ArrayListDemo(){
        data = new String[10];
    }

    // 定义有参构造，指定初始化容量
    public ArrayListDemo(int initialCapacity){
        if (initialCapacity < 0)
            throw new IllegalArgumentException();
        data = new String[initialCapacity];
    }

    // 添加元素方法
    public void add(String str){
        // 判断是否需要扩容
        if (size >= data.length){
            grow();
        }
        data[size++] = str;
    }

    // 数组扩容方法
    private void grow() {
        if (data.length <= 1){
            data = Arrays.copyOf(data,data.length  + 1);
        }else {
            data = Arrays.copyOf(data,data.length + (data.length >> 1));
        }
    }

    // 插入元素方法
    public void add(int index,String str){
        // 判断是否越界
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException();

        // 是否需要扩容
        if (size >= data.length)
            grow();

        // 插入元素就是将数据向后挪动一位，然后腾出来的那一位赋值要插入的数据
//        for (int i = size - 1;i >= index;i--){
//            data[i + 1] = data[i];
//        }
        System.arraycopy(data,index,data,index + 1,size - index);
        data[index] = str;
        size++;
    }

    // 删除指定索引处的元素
    public void remove(int index){
        // 判断是否越界
       out(index);

        // 删除元素实际上是数据统一向前挪动一位
//        for (int i = index;i < size - 1;i++){
//            data[i] = data[i + 1];
//        }

        System.arraycopy(data,index + 1,data,index, size - index - 1);

        size--;
    }

    // 查找某一个元素第一次出现的索引，如果找不到，返回-1
    public int indexOf(String str){
        for (int i = 0;i < size;i++){
            if (Objects.equals(str, data[i])){
                // 第一次找到时，立即返回索引
                return i;
            }
        }
        // 没有找到，返回-1
        return -1;
    }

    // 删除指定的元素
    public void remove(String str){
        // 寻找str第一次出现的索引
        int i = indexOf(str);
        // 判断是否找到索引
        if (i != - 1)
            remove(i);
    }

    // 清空集合
    public void clear(){
        data = new String[10];
        size = 0;
    }

    // 判断是否包含指定的元素
    public boolean contains(String str){
        return indexOf(str) != -1;
    }

    // 获取指定索引处元素
    public String get(int index){
        // 判断是否越界
        out(index);
        return data[index];
    }

    // 判断集合是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    // 替换元素
    public void set(int index,String str){
        // 判断越界
        out(index);
        data[index] = str;
    }

    // 获取元素个数
    public int size(){
        return size;
    }

    private void out(int index){
        if (index <0 || index >= size){
            throw new IndexOutOfBoundsException();
        }
    }

    // 截取子列表
    public ArrayListDemo subList(int fromIndex,int toIndex){
        // 判断参数是否合法
        if (fromIndex > toIndex){
            throw new IllegalArgumentException();
        }
        // 判断越界
        out(fromIndex);
        out(toIndex);
        // 创建新的ArrayList
        ArrayListDemo sublist = new ArrayListDemo(toIndex - fromIndex);
        System.arraycopy(this.data,fromIndex,sublist.data,0,toIndex - fromIndex);
        // 设置实际长度
        sublist.size = toIndex - fromIndex;
        return sublist;
    }

    // [10, 20, 30]
    public String toString(){
        // 拼接字符串
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("[");
        for (int i = 0; i < size; i++) {
            if (i != size - 1){
                stringBuilder.append(data[i]).append(", ");
            }else {
                stringBuilder.append(data[i]);
            }
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }


}