DESKTOP-2IHO1NT_20200907秦文亮

问题

import java.util.Arrays;

public class Test1 {
    
    private static final int XIAOHEI = 10;
    // 声名加载因子
    private static final float DEFAULT_LOAD_FACTOR = 0.75F;
    // 声明一个Object类型的数组变量(引用变量)，用来引用存放数据的数组对象
    private Object[] arr;
    // 声明一个Object类型的常量用来填充数组中的"空闲"位置
    private static final Object PRESENT = new Object();

    private int counter;

    private float loadFactor;
    // 缓存区
    private StringBuilder builder = new StringBuilder();

    // 构造
    public Test1() {
        this( XIAOHEI , DEFAULT_LOAD_FACTOR );
    }

    public Test1(int n) {
        this(n, XIAOHEI);
    }

    public Test1(int n, float loadFactor) {
        super();
        if (n <= 0) {
            throw new IllegalArgumentException("容器初始容量必须是正整数");
        }
        if (loadFactor <= 0 || loadFactor >= 1) {
            throw new IllegalArgumentException("加载因子必须是0到1之间的小数");
        }
        arr = new Object[n];
        // 使用 PRESENT 初始化数组
        Arrays.fill(arr, PRESENT);
        // 指定加载因子
        this.loadFactor = loadFactor;
    }

    private void grow() {
        int oldCapacity = arr.length;
        // 当容器中元素个数容量的一定比例时就要扩容了
        if (counter >= oldCapacity * loadFactor) {
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            Object[] array = new Object[newCapacity];// 创建新数组
            Arrays.fill(array, PRESENT); // 填充新数组
            // 将O数组中的[0,counter)之间的元素复制到array的[0,counter)位置
            System.arraycopy(arr, 0, array, 0, counter);
            // 让实例变量elements指向新创建的数组
            arr = array;
        }
                                                
    }

    // 方法 扩容
    public void add(Object a) {
        grow();
        arr[counter] = a;
        counter++;
    }
    //指定位置 x 插入一个新元素 a
    public void add(int x,Object a) {
        if(x<0||x>counter) {//判断插入新元素的索引是否在【0，conter）范围内；否则抛出异常
            throw new IndexOutOfBoundsException( "新插入的元素索引只能是 [ 0 , " + counter + "]"  );
        }
        grow();//扩容
        System.arraycopy(arr, x, arr, x+1,counter-x );//复制数组，从指定位置插入新元素的位置x开始，
        //复制到原数组，从x+开始复制，复制原数组的长度-x的索引个长度；
        arr[x]=a;//把要插入的元素复制到新数组的x索引的位置；
        counter++;//让长度有变换；
    }
    //用新元素替换指定位置 x 的元素并返回原来的元素 o
    public Object set(int x,Object a) {
        if(x<0||x>counter) {
            throw new IndexOutOfBoundsException( "替换元素索引只能是 [ 0 , " + counter + "]"  );
        }
        Object o=arr[x];//返回原来的元素用Object接收
        arr[x]=a;//把替换的元素赋值给指定位置元素的数组；
        return o;//返回原来的元素；
    }       
    //获取指定索引处x的元素
    public Object get(int x) {//定义指定索引x
        if(x<0||x>counter) {
            throw new IndexOutOfBoundsException( "获取元素索引只能是 [ 0 , " + counter + "]"  );
        }
        return arr[x];//返回指定指定索引x的元素
    }
    //删除指定索引处的元素并返回该元素
    public Object remove(int x) {//定义删除的索引x
        if(x<0||x>counter) {
            throw new IndexOutOfBoundsException( "删除元素索引只能是 [ 0 , " + counter + "]"  );
        }
        Object old =arr[x];//删除的元素用Object类的old 接收
        System.arraycopy(arr, x+1, arr, x, counter-x);//复制数组
        //原数组arr，从x+1处开始，复制到新arr数组，从x索引处开始，到原数组的长度减去x的索引个元素；
        counter--;//删除了元素长度就会发生变化；
        return old;//返回删除的元素；
    }

    @Override // 重写toString
    public String toString() {
        builder.setLength(0);
        for (int i = 0; i < counter; i++) {
            builder.append(arr[i]);// 把数组放在缓存区里
            if (i < counter - 1) {// 除了最后一个外，前面的用逗号隔开；
                builder.append(",");
            }
        }
        return "[" + builder.toString() + "]";
    }

    // 返回当前"容器"的容量
    public int capacity() {
        return arr.length;
    }
    
    // 返回当前"容器"的元素个数
    public int size() {
        return counter;
    }

    // 当当前"容器"为空时返回true
    public boolean isEmpty() {
        return counter == 0;
    }
}

测试类

public class Test1Test {

    public static void main(String[] args) {
        
        Test1 d=new Test1();
        d.add("asd");
        d.add("qwe");
        d.add(123);
        d.add("zxc");
        System.out.println(d);
        System.out.println(d.capacity()+"    "+d.size());
        //测试在指定位置插入一个新的元素
        d.add(2, "jiade");
        System.out.println(d);
        d.add(5, 0);
        System.out.println(d);
        //测试用新元素替换指定位置的元素并返回原来的元素 
        d.set(1, "w");
        System.out.println(d);
        //测试获取指定索引处的元素
        System.out.println(d.get(2));
        //测试删除指定索引处的元素
        d.remove(0);
        System.out.println(d);
    }

}

吐槽

好像学会了这几个方法，好难理解；还是好多没有理解的。加油！！！