小码哥《恋上数据结构与算法》笔记（一）：动态数组

怼烎@ 2023-05-28 06:47 26阅读 0赞

> 具体代码在 [ArrayList][] , 欢迎 `star`

## 目录 ##

*  一、数组(Array)
 *  二、动态数组（Dynamic Array）接口设计
 *  三、动态数组的实现
    
     *  1、构造方法
     *  2、添加元素
        
         *  2.1、数组越界
         *  2.2、数组扩容
     *  3、删除元素
        
         *  3.1、数组越界
         *  3.2、数组缩容
     *  4、清空数组
     *  5、修改元素
     *  6、查询元素
     *  7、查看元素位置
     *  8、是否包含某元素
     *  9、元素的数量
     *  10、数组是否为空
     *  11、动态数组打印
 *  四、动态数组的复杂度
 *  五、ArrayList能否进一步优化？
 *  六、重点总结
    
     *  1、动态扩容思路
     *  2、如何确保容量是否越界
     *  3、使用泛型
     *  4、clear方法的过渡细节
     *  5、remove、indexOf的细节

附录、ArrayList完整代码

--------------------

# 一、数组 (Array) #

跳转到目录

*  数组是一种`顺序存储`的线性表，所有元素的内存地址都是连续的。
    
        int[] array = new int[]{ 20, 30, 40}

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70]

*  在很多编程语言中，数组有个致命的缺点， **无法动态修改容量**。
 *  实际开发中我们希望数组的容量是动态变化的。

# 二、动态数组 (Dynamic Array) 接口设计 #

跳转到目录

*  创建`ArrayList`类，创建`size`属性来管理数组中元素的个数， 创建`elements`属性来管理存取的数据。
 *  可以对动态数组进行`增删改查`操作。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 1]

public class ArrayList<E> { 
        private int size;
        private E[] elements;
    
    	// 元素的数量
    	int size(); 
    	// 是否为空
    	boolean isEmpty();
    	// 是否包含某个元素
    	boolean contains(E element); 
    	// 添加元素到最后面
    	void add(E element); 
    	// 返回index位置对应的元素
    	E get(int index); 
    	// 设置index位置的元素
    	E set(int index, E element); 
    	// 往index位置添加元素
    	void add(int index, E element); 
    	// 删除index位置对应的元素 
    	E remove(int index); 
    	// 查看元素的位置
    	int indexOf(E element); 
    	// 清除所有元素
    	void clear(); 
    }

# 三、动态数组的实现 #

跳转到目录

#### 1、构造方法 ####

跳转到目录

*  如果构建的数组空间小于默认空间，则会以默认空间构建数组。

public class ArrayList<E> { 
        /** * 元素的数量 */
        private int size;
    
        /** * 所有元素 */
        private E[] elements;
    
        /** * 数组的默认容量 */
        private static final int DEFAULT_CAPACITY = 10;
    
    	/** * 找不到元素返回-1 */
        private static final int ELEMENT_NOT_FOUNT = -1;
    
        public ArrayList() { 
            // 默认容量
            //elements = new int[DEFAULT_CAPACITY];
            this(DEFAULT_CAPACITY); // 调用下面的构造器
        }
    
        public ArrayList(int capacity) { 
            // 设置默认容量为 10
            capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
    
            // 因为泛型(所以传一个Object数组,然后通过强转)
            elements = (E[]) new Object[capacity];
        }
    }

#### 2、添加元素 ####

跳转到目录

*  数组添加元素分为`在最后一个元素的后面添加新元素`和`将元素插入到某个位置（非最后面）`两种情况。
 *  第一种情况，这个`新元素需要添加到的索引`等于`当前数组元素的个数`，在ArrayList中`size`属性就是`当前数组元素的个数`，所以就是将新元素添加到数组的`size`位置上，然后`size加1`。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 2]

public void add(int index, E element) { 
        elements[index] = element;
        size++;
    }

*  如果是第二种情况，只需要将插入位置后面的元素向后移动即可。
 *  注意：需要从后向前移动元素，如果从前向后移动元素，那么会进行元素覆盖, 最后出错。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 3]

##### 2.1、数组越界 #####

跳转到目录

*  添加元素，还要注意传入的索引不能越界，即`不能小于0, 也不能大于size`。

/** * 根据index插入元素时,判断index是否有效 * * @param index */
    private void rangeCheckForAdd(int index) { 
        if (index < 0 || index > size) { 
            indexOutOfBounds(index);
        }
    }

/** * 封装数组越界异常 * * @param index */
    private void indexOutOfBounds(int index) { 
        throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
    }

##### 2.2、数组扩容 #####

跳转到目录

*  **动态扩容思路:**
 *  通过默认容量创建的数组,是在堆空间中`随机`生成的地址;如此一来再申请空间拼接到该数组后,这种方式`不可能`实现;
 *  我们只能再创建一个`大容量`的数组,然后将之前数组中的元素`移动`到这个数组中;然后将`引用`指向新数组即可!
 *  由于数组`elements`最大的容量只有`10`，所以当数组存满元素时，就需要对数组进行扩容。
 *  因为数组是无法动态扩容的，所以需要`创建一个新的数组`，这个数组的容量要比之前数组的容量大。
 *  然后在将原数组中的元素存放到新数组中，这样就实现了数组的扩容。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 4]
 *  该方法确保默认容量为多少,为了验证`是否超过给定的默认容量`,然后进行判断是否要扩容;这里`size+1`为数组当前数量+1, 因为每次`add`都会增加一个容量。

/** * 确保至少要有capacity个容量 * * @param capacity */
    private void ensureCapacity(int capacity) { 
    
        // 获取数组当前容量
        int oldCapacity = elements.length;
        // 判断是否要扩容
        if (oldCapacity >= capacity)
            return; // 此时不扩容
    
        // 这种方式是扩容1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
    
        E[] newElements = (E[]) new Object[newCapacity];
        // 将原来数组中的元素移动到新数组中
        for (int i = 0; i < size; i++) { 
            newElements[i] = elements[i];
        }
        // 将数组引用指向新数组
        elements = newElements;
    }

*  实现`add`函数，需要在添加新元素之前，判断`数组越界`和`扩容`。

/** * 在index位置插入一个元素 * * @param index * @param element */
    public void add(int index, E element) { 
        // 在添加元素的时候,判断index是否有效
        rangeCheckForAdd(index);
    
        ensureCapacity(size + 1);
    
        // 注意: 插入元素后,元素是从后开始往后挪
        for (int i = size - 1; i >= index; i--) { 
            elements[i + 1] = elements[i];
        }
        elements[index] = element;
        size++;
    }

*  最终`在最后一个元素的后面添加新元素`，即`添加元素到尾部`的实现方式如下

/** * 添加元素到尾部 * * @param element */
    public void add(E element) { 
        // elements[size++] = element;
        // 传入数组数量(相当于在最后插入元素)
        add(size, element);
    }

#### 3、删除元素 ####

跳转到目录

*  删除元素，实际上就是`移除指定位置的元素`，并将`后面的元素向前移动`。
 *  如下图，当删除索引为`3`的元素时，只需要将后面的元素向前移动，然后在去掉最后一个元素，`size减1`即可。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 5]

##### 3.1、数组越界 #####

跳转到目录

*  删除元素时传入的索引不能越界, 即`不能小于0, 也不能大于等于size`所以我们在删除元素之前需要先进行索引检查。

private void indexOutOfBounds(int index) { 
        throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
    }
    	
    private void rangeCheck(int index) { 
        if (index < 0 || index >= size) { 
            outOfBounds(index);
        }
    }

##### 3.2、数组缩容 #####

跳转到目录

*  当数组中的元素删除后，数组剩余的空间可能会很大，这样就会造成内`存的浪费`。
 *  所以当数组中元素删除后，我们需要对数组进行`缩容`。
 *  实现方法类似于扩容，当`数组中容量小于某个值`时，创建新的数组，然后将原有数组中的元素`存入新数组`即可。

/** * 数组缩容 */
    public void trim() { 
        // 获取当前数组的容量
        int capacity = elements.length;
        // 当size大于等于容量的一半, 或则容量已经小于默认容量(10)时, 直接返回
        if (size >= capacity >> 1 || capacity < CAPACITY_DEFAULT) return;
        // 计算新的容量 = 原有容量的一半
        int newCapacity = capacity >> 1;
        // 创建新数组
        E[] newElements = (E[]) new Object[newCapacity];
        // 将原数组元素存入新数组
        for (int i = 0; i < size; i++) { 
        	newElements[i] = elements[i];
        }
        // 引用新数组
        elements = newElements;
    }

*  最终, `remove`方法实现如下

/** * 删除index位置的元素 * * @param index * @return 被删除的元素 */
    public E remove(int index) { 
        rangeCheck(index);
        E delEle = elements[index];
    
        // 当删除一个元素时,需要挪动后面元素的范围
        for (int i = index + 1; i <= size - 1; i++) { 
            elements[i - 1] = elements[i];
        }
        size--;
        // 同clear的细节,当从后往前以后时,最后一个的地址需要释放
        elements[size] = null;
        // 判断数组是否需要缩容
        trim();
        return delEle;
    }
    
    /** * 删除传入的元素 * @param element */
    public void remove(E element){ 
        remove(indexOf(element));
    }

#### 4、清空数组 ####

跳转到目录

*  清空数组时，需要将所有的元素置为`null`，只有这样才能真正的释放对象，然后`size置为0`。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 6]

/** * 清除所有元素 */
    public void clear() { 
        for (int i = 0; i < size; i++) { 
            elements[i] = null;
        }
        size = 0;
    }

#### 5、修改元素 ####

跳转到目录

*  修改元素时，只需要将原有位置的元素`替换`掉即可，同样需要注意一下索引是否`越界`。

/** * 设置index位置的元素 * * @param index * @param element * @return 原来的元素 */
    public E set(int index, E element) { 
        rangeCheck(index);
    
        E oldEle = elements[index];
        elements[index] = element;
        return oldEle;
    }

#### 6、查询元素 ####

跳转到目录

*  查询元素，只需要将指定索引的元素返回，注意`索引`是否`越界`即可。

/** * 获取index位置的元素 * * @param index * @return */
    public E get(int index) { 
        // 约束Index
        rangeCheck(index);
        return elements[index];
    }

#### 7、查看元素位置 ####

跳转到目录

*  可以通过循环, 查找元素在数组中的位置。
 *  注意：假如数组中可以存储`null`，而null是不能调用`equals`方法的，所以需要对传入的元素进行判断，如果查找的元素是`null`，需要单独处理。
 *  当元素存在时返回索引，否则返回变量`ELEMENT_ON_FOUND`的值。

/** * 查看元素的索引 * * @param element * @return */
    public int indexOf(E element) { 
        if (element == null) { 
            // 循环判断如果element为null,直接返回null的索引
            for (int i = 0; i < size; i++) { 
                if (elements[i] == null)
                    return i;
            }
        } else { 
            for (int i = 0; i < size; i++) { 
                // 因为element肯定不为null了,所以放在前面;避免空指针异常
                if (element.equals(elements[i]))
                    return i;
            }
        }
        return ELEMENT_NOT_FOUNT;
    }

#### 8、是否包含某元素 ####

跳转到目录

*  只需通过判断索引是否等于`ELEMENT_ON_FOUND`即可。

/** * 是否包含某个元素 * * @param element * @return */
    public boolean contains(E element) { 
        // 如果element元素可以找到
        return indexOf(element) != ELEMENT_NOT_FOUNT;
    }

#### 9、元素的数量 ####

跳转到目录

*  size的值，即为元素的数量。

/** * 元素的数量 * * @return */
    public int size() { 
        return size;
    }

#### 10、数组是否为空 ####

跳转到目录

*  通过判断`size`的值是否为`0`即可

/** * 是否为空 * * @return */
    public boolean inEmpty() { 
        return size == 0;
    }

#### 11、动态数组打印 ####

跳转到目录

*  可以重写`toString`方法, 来打印`ArrayList`中的元素。

@Override
    public String toString() { 
        // 打印格式: size=3, [10, 20, 30]
        // 使用StringBuilder 效率高一些
        StringBuilder string = new StringBuilder();
        string.append("size=").append(size).append(", [");
        for (int i = 0; i < size; i++) { 
            string.append(elements[i]);
            if (i != size - 1) { 
                string.append(", ");
            }
        }
        string.append("]");
        return string.toString();
    }

**这样就实现了动态数组的基本操作。**

# 四、动态数组的复杂度 #

跳转到目录  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 7]

# 五、ArrayList能否进一步优化？ #

跳转到目录

*  在ArrayList中，如果要删除索引`0`位置的元素，则需要将索引`0`之后的元素`全部往前移一位`。
 *  如果要在索引`0`位置添加元素，也需要将索引`0`及之后的元素全`部往后移一位`。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 8]
 *  在ArrayList中`增加一个记录首元素位置的属性`。
 *  删除索引`0`位置的元素，我们只需要将`first`属性改为`1`。

--------------------

*  在索引`0`位置添加元素，则只需要将`first`属性改为`0`。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 9]

--------------------

*  如果继续往前插入元素，则将插入的元素存放在索引`8`这个位置，并将`first`改为`8`。
 *  当要获取索引`8`下一个元素时，对索引取`模`，则拿到索引`0`位置的元素。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 10]

--------------------

*  如果插入元素，则可选择挪动`前半段`数据或`后半段`数据。
 *  在索引`2`处插入元素`99`，可以选择将元素`22`，`33`左移，然后插入`99`即可。
 *  `扩容`和`缩容`同样可以优化。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 11]

# 六、重点总结 #

跳转到目录

#### 1、动态扩容思路 ####

跳转到目录

*  通过默认容量创建的数组,是在堆空间中随机生成的地址;如此一来  
    再申请空间拼接到该数组后,这种方式不可能实现;
 *  我们只能再创建一个大容量的数组,然后将之前数组中的元素移动到  
    这个数组中;然后将`引用指向新数组`即可!

#### 2、如何确保容量是否越界 ####

跳转到目录

*  该方法确保默认容量为多少, 为了验证是否超过给定的默认容量,然后进行判断是否要扩容; 这里size+1为数组当前数量+1, 因为每次add都会增加一个容量, 在每次添加元素之前判断一下。
    
        ensureCapacity(size + 1);

#### 3、增加泛型 ####

跳转到目录

*  使用泛型, 使动态数组可以添加`任何`类型的数据。
    
        elements = (E[]) new Object[capacity];

#### 4、clear方法的过渡细节 ####

跳转到目录

*  因为之前存储的都是`int数据`, 直接设置`size=0`时, 开辟的存储int类型的空间就不能被访问, 当add后, 就可以访问后面的空间, 所以此时的空间可以`重复利用`;
 *  当使用`泛型`后, 动态数组中存储的都是`对象`类型, 实际存储的都是对象的`地址`, 每一个对象的地址又有一块空间`引用`着; 此时如果仍设置 size=0, 当clear后,开辟的存储空间中的`地址`没有被`销毁`, 地址仍被`对象空间`引用着; 这样以来存储对象的空间就不会被释放; 但是`存储地址`的数组可以重复利用; 所以要将地址数组都置为`null,` 然后size=`0`, 这样以来,引用该地址的对象空间也就`释放`了!

#### 5、remove、indexOf的细节 ####

跳转到目录

*  remove最后一个地址也要情况, 同clear细节
 *  在indexOf方法中,不用`==`比较, 因为比较的是`地址值`,一般重写`equals`方法自己定义比较内容即可;
 *  null值处理: 当往数组传`null`的时候,indexOf的比较处理: 如果那null.equals来比较会出现`空指针`异常;

### 附录: ArrayList完整代码 ###

/** * Description: 设计动态数组 * * @author guizy * @date 2020/3/15 19:39 */
    public class ArrayList<E> { 
        /** * 元素的数量 */
        private int size;
    
        /** * 所有元素 */
        private E[] elements;
    
        /** * 数组的默认容量 */
        private static final int DEFAULT_CAPACITY = 10;
    
        /** * 找不到元素返回-1 */
        private static final int ELEMENT_NOT_FOUNT = -1;
    
        public ArrayList() { 
            // 默认容量
            //elements = new int[DEFAULT_CAPACITY];
            this(DEFAULT_CAPACITY); // 调用下面的构造器
        }
    
        public ArrayList(int capacity) { 
            // 设置默认容量为 10
            capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
    
            // 因为泛型(所以传一个Object数组,然后通过强转)
            elements = (E[]) new Object[capacity];
        }
    
        /** * 清除所有元素 */
        public void clear() { 
            for (int i = 0; i < size; i++) { 
                elements[i] = null;
            }
            size = 0;
        }
    
        /** * 元素的数量 * * @return */
        public int size() { 
            return size;
        }
    
        /** * 是否为空 * * @return */
        public boolean inEmpty() { 
            return size == 0;
        }
    
        /** * 是否包含某个元素 * * @param element * @return */
        public boolean contains(E element) { 
            // 如果element元素可以找到
            return indexOf(element) != ELEMENT_NOT_FOUNT;
        }
    
        /** * 添加元素到尾部 * * @param element */
        public void add(E element) { 
            // elements[size++] = element;
            // 传入数组数量(相当于在最后插入元素)
            add(size, element);
        }
    
        /** * 获取index位置的元素 * * @param index * @return */
        public E get(int index) { 
            // 约束Index
            rangeCheck(index);
            return elements[index];
        }
    
        /** * 设置index位置的元素 * * @param index * @param element * @return 原来的元素 */
        public E set(int index, E element) { 
            rangeCheck(index);
    
            E oldEle = elements[index];
            elements[index] = element;
            return oldEle;
        }
    
        /** * 在index位置插入一个元素 * * @param index * @param element */
        public void add(int index, E element) { 
            // 在添加元素的时候,判断index是否有效
            rangeCheckForAdd(index);
    
            /* 该方法确保默认容量为多少,为了验证是否超过给定的默认容量,然后进行判断是否要扩容; 这里size+1为数组当前数量+1, 因为每次add都会增加一个容量 */
            ensureCapacity(size + 1);
    
            // 注意: 插入元素后,元素是从后开始往后挪
            for (int i = size - 1; i >= index; i--) { 
                elements[i + 1] = elements[i];
            }
            elements[index] = element;
            size++;
        }
    
    
        /** * 删除index位置的元素 * * @param index * @return 被删除的元素 */
        public E remove(int index) { 
            rangeCheck(index);
            E delEle = elements[index];
    
            // 当删除一个元素时,需要挪动后面元素的范围
            for (int i = index + 1; i <= size - 1; i++) { 
                elements[i - 1] = elements[i];
            }
            size--;
            // 同clear的细节,当从后往前以后时,最后一个的地址需要释放
            elements[size] = null;
            // 缩容
            trim();
            return delEle;
        }
    
        /** * 删除传入的元素 * * @param element */
        public void remove(E element) { 
            remove(indexOf(element));
        }
    
        /** * 查看元素的索引 * * @param element * @return */
        public int indexOf(E element) { 
            if (element == null) { 
                // 循环判断如果element为null,直接返回null的索引
                for (int i = 0; i < size; i++) { 
                    if (elements[i] == null)
                        return i;
                }
            } else { 
                for (int i = 0; i < size; i++) { 
                    // 因为element肯定不为null了,所以放在前面;避免空指针异常
                    if (element.equals(elements[i]))
                        return i;
                }
            }
            return ELEMENT_NOT_FOUNT;
        }
    
        /** * 确保至少要有capacity个容量 * * @param capacity */
        private void ensureCapacity(int capacity) { 
    
            // 判断是否要扩容
            int oldCapacity = elements.length;
            if (oldCapacity >= capacity)
                return; // 此时不扩容
    
            // 这种方式是扩容1.5倍
            int newCapacity = oldCapacity + (oldCapacity >> 1);
    
            E[] newElements = (E[]) new Object[newCapacity];
            // 将原来数组中的元素移动到新数组中
            for (int i = 0; i < size; i++) { 
                newElements[i] = elements[i];
            }
            // 将数组引用指向新数组
            elements = newElements;
    
            System.out.println(oldCapacity + "扩容为:" + newCapacity);
        }
    
        /** * 数组缩容 */
        private void trim() { 
            // 获取当前数组的容量
            int capacity = elements.length;
            // 当size大于等于容量一半时,或者容量已经小于默认容量(10)时, 直接返回
            if (size >= capacity >> 1 || capacity < DEFAULT_CAPACITY) return;
            // 计算新的容量 = 原来容量的一半
            int newCapacity = capacity >> 1;
            // 创建新数组
            E[] newElements = (E[]) new Object[newCapacity];
            // 将原来数组元素存入到新数组
            for (int i = 0; i < size; i++) { 
                newElements[i] = elements[i];
            }
            // 引用新数组
            elements = newElements;
        }
    
        /** * 封装数组越界异常 * * @param index */
        private void indexOutOfBounds(int index) { 
            throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
        }
    
        /** * 检查get,remove传入的index是否有效 * * @param index */
        private void rangeCheck(int index) { 
            if (index < 0 || index >= size) { 
                indexOutOfBounds(index);
            }
        }
    
        /** * 根据index插入元素时,判断index是否有效 * * @param index */
        private void rangeCheckForAdd(int index) { 
            if (index < 0 || index > size) { 
                indexOutOfBounds(index);
            }
        }
    
        @Override
        public String toString() { 
            // 打印格式: size=3, [10, 20, 30]
            // 使用StringBuilder 效率高一些
            StringBuilder string = new StringBuilder();
            string.append("size=").append(size).append(", [");
            for (int i = 0; i < size; i++) { 
                string.append(elements[i]);
                if (i != size - 1) { 
                    string.append(", ");
                }
            }
            string.append("]");
            return string.toString();
        }
    }

[ArrayList]: https://github.com/coderZYGui/dynamic-array
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70]: /images/20230528/ebf07282ca2e479182295ed8f40770ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 1]: /images/20230528/cb69237a75e3425296839be7b345c502.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 2]: /images/20230528/7329362eeb1f4d8e97f4d9bfd1b20524.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 3]: /images/20230528/a23d6399e5a549a699fa07fae94acb30.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 4]: /images/20230528/794f0a891fae4021ad223c239e378a91.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 5]: /images/20230528/ccd4f2e9baba4c0188c0305cea4bdd56.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 6]: /images/20230528/dadd970e3b6e482aa086023a523c1b98.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 7]: /images/20230528/53ab9c0573814757bd67b299ca675a8c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 8]: /images/20230528/a2e3639ca5ae42edb64508f6737101d3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 9]: /images/20230528/bab2817ebd77424ab57efd099405737c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 10]: /images/20230528/3818a6c342434a27aaca1b7d7ae201a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 11]: /images/20230528/c151c9441bda4b73be947204623b17f7.png