【数据结构】动态数组的实现

已于 2023-05-04 16:16:08 修改
阅读量529 收藏 3
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构
于 2023-03-18 16:57:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48479056/article/details/129639181
版权

目录

🌟前言

🌟定义一个线性表接口SeqList

🌟SeqList接口的实现类：MyArray

🌈 初始化

🌈 元素尾插

🌈 自定义实现grow扩容方法     

🌈 在索引位置添加元素（重点）

🌈 删除索引位置元素

🌈 删除第一个值为element的元素

🌈 删除所有值为element的元素（重点）

🌈改：修改index位置下的元素，并返回被修改的原值

🌈查：查询索引index位置下的元素

🌈 判断数组是否包含element元素值，返回判断结果。

🌈 返回元素element在数组中对应的索引

🌈 重写ToString方法

🌟完整代码实现

🌟测试类

🌟总结 

🌟前言

        需要知道： 我们平时说的数组，最大的特点就是定长，它的长度是固定的。而我们今天说的冬天数组与其最大的区别就在于：动态数组的长度并不是固定的。它本质上就是在基本数组的基础上封装到了类中，至于数组的长度则由类的内部来进行扩容操作。对于用户来说，使用动态数组不需要关心数组的长度。知道这一点即可。接下来我们就来自己实现一下动态数组~（元素的添加和删除是重点）

🌟定义一个线性表接口SeqList

public interface SeqList<E> {
    /**
     * 增：直接增加元素
     */
    void add(E element);
    /**
     * 增：在索引为Index的位置增加元素
     */
    void add(int index,E element);
    /**
     * 删：通过索引删除元素，并返回删除的值
     */
    E removeByIndex(int index);
    /**
     * 删：通过值删除元素：删除第一个值为element的元素
     */
    void removeByValue(E element);
    /**
     * 删：删除所有值为element的元素
     */
    void removeAllValue(E element);
    /**
     * 改：在索引为index的位置设置值，并返回该值
     */
    E set(int index,E elemnet);
    /**
     * 查：查询索引为index的值，并返回查询到的值
     */
    E get(int index);
    /**
     * 判断当前线性表中是否包含该元素值
     */
    boolean contains(E element);
    /**
     * 查询值为element的索引并返回该值
     */
    int indexOf(E element);
}

🌟SeqList接口的实现类：MyArray

    三步原则：判断索引合法性——>数据处理：增删改查操作——>判断是否需要扩容

🌈 初始化

        初始化主要包括数组，有效元素的个数size，以及有参和无参构造用来初始化数组长度的。

注意：size不仅表示数组中有效元素的个数，而且表示数组中下一个元素的索引。

    /**
     * 定义一个泛型数组elementData，使用Object类型
     * size不仅表示现有数组实际存储的大小,还表示下一个元素的位置
     */
    private Object[] elementData;//定义一个泛型数组
    private int size;//定义一个默认的数组大小
    /**
     * 有参和无参构造方法
     */
    //无参构造: 默认数组的长度是10
    public MyArray() {
        this(10);
    }
    //有参构造: 传入参数确定动态数组的长度为size
    public MyArray(int size) {
        this.elementData = new Object[size];
    }

🌈 元素尾插

         主要思想：直接给数组添加元素，然后判断是否需要扩容。

    @Override
    public void add(E element) {
        this.elementData[size] = element;
        size++;
        if(size==elementData.length){
            grow();
        }
    }

 🌈 自定义实现grow扩容方法     

       主要思想：获取数组原来的旧长度，定义数组扩容后的新长度，定义新数组，长度为扩容后的长度，并将旧数组的元素值拷贝过来，此时的新数组就是我们的数组。

    private void grow() {
        int oldLength = elementData.length;//获取原数组的长度
        int newLength = oldLength<<1;//获取新数组的长度：默认将容量扩为原先的一倍
        Object[] newArray = Arrays.copyOf(elementData, newLength);//将原数组拷贝到新数组中
        elementData = newArray;//获取扩容后的数组
    }

🌈 在索引位置添加元素（重点）


     主要思想：判断索引的合法性——>判断根据索引插入元素的位置判断是否需要扩容：
     (1)如果index=size,插入位置在size,不需要扩容:直接调用尾插方法
     (2)如果0<index<size插入位置在中间：遍历数组，找到索引位置，将索引后的数组元素每个都向后移动一位，就可以将索引位置空出来。 然后再将元素添加到索引位置。——>添加完成后判断是否需要扩容。    

    @Override
    public void add(int index, E element) {
        //(1)判断索引的合理性
        if(index<0||index>size){
            throw new IllegalArgumentException("add index illegal");
        }
        //(2)如果插入位置为尾插：则直接调用尾插方法并提前结束该方法
        if(index==size){
            add(element);
            return;
        }
        //(3)如果插入位置在元素中间，则将数据插入并判断数组长度是否需要扩容
        for (int i = size-1; i >=index; i--) {//遍历数组走到Index位置
            elementData[i+1] = elementData[i];//将Index后的元素向后移
        }
        elementData[index]=element;//此时Index空出，插入待添加的元素
        //(4)判断数组是否需要扩容
        size++;
        if(size==elementData.length){
            grow();
        }
    }

🌈 删除索引位置元素

        主要思路：遍历数组走到index位置，获取要删除的元素值进行记录，并将索引后的元素向左移动一位进行元素的覆盖。

 @Override
    public E removeByIndex(int index) {
        //(1)判断索引的合法性
        if(!indexCheck(index)){
           throw  new IllegalArgumentException("remove index illegal");
        }
        //(2)获取要删除索引位置的元素
        E oldVal = (E)elementData[index];
        //(2)遍历数组从Index位置走到size
        for (int i = index; i < size-1; i++) {//注意：这里因为要保证索引不能越界：i+1实际上是取不到size的,也就是i<size-1
            elementData[i] = elementData[i+1];//将索引后的元素向左移动一位进行元素的覆盖
        }
        //(3)size--
        size--;
        return oldVal;
    }
    /**
     * 索引的合法性校正
     */
    private boolean indexCheck(int index){
        if(index<0 || index>=size){
            return false;
        }
        return true;
    }

🌈 删除第一个值为element的元素

        主要思路：遍历数组从0索引开始一直判断元素值是否等于element。如果找到了element，则该元素是我们要删除的元素。获取element位置下的Index，通过调用removeByIndex方法删除。更新元素个数。

 @Override
    public void removeByValue(E element) {
        for (int i = 0; i < size; i++) {
            if(elementData[i].equals(element)){
                removeByIndex(i);
                return;
            }
        }
        throw new IllegalArgumentException("没有找到该元素~");
    }

🌈 删除所有值为element的元素（重点）

        注意： 错误写法：去掉removeByValue方法中的return即可。
        原因：当数组中要删除的元素是连续出现时(比如连续出现了3次222)，调用removeByIndex方法删除元素要考虑当前指向的元素是不是要删除的元素：
       如果是要删除的元素，则i不能变化
       如果不是要删除的元素,i才可以++；

    @Override
    public void removeAllValue(E element) {
//         自己一开始写成了这种形式，当出现连续要删除的元素值时会发生漏删的现象
      /*  for (int i = 0; i < size; i++) {
            if(elementData[i].equals(element)){
                removeByIndex(i);
            }
        }*/
        for (int i = 0; i < size; ) {
            if(elementData[i].equals(element)){
                removeByIndex(i);
            }else{
                i++;
            }
        }
    }

  🌈改：修改index位置下的元素，并返回被修改的原值

    @Override
    public E set(int index, E element) {
        if(!indexCheck(index)){
            throw new IllegalArgumentException("set index illegal");
        }
        //找到index下的旧值返回,并将新的数值赋值给数组的index位置
        E oldVal = (E)elementData[index];
        elementData[index] = element;
        return oldVal;

    }

 🌈查：查询索引index位置下的元素

     @Override
    public E get(int index) {
        //(1)判断索引的合法性
        if(!indexCheck(index)){
            throw new IllegalArgumentException("get index illegal");
        }
        //(2)返回数值
        return (E) elementData[index];
    }

🌈 判断数组是否包含element元素值，返回判断结果。

      主要思想：遍历数组0-size,将数组的每一个值与element进行比对。

  @Override
    public boolean contains(E element) {
        for (int i = 0; i < size; i++) {
            if(elementData[i].equals(element)){
                return true;
            }
        }
        return false;
    }

🌈 返回元素element在数组中对应的索引

 @Override
    public int indexOf(E element) {
        for (int i = 0; i < size; i++) {
            if(elementData[i].equals(element)){
                return i;
            }
        }
        throw new IllegalArgumentException("indexOf error"+"Don't has this element");
    }

 🌈 重写ToString方法

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        // 遍历elementData数组
        for (int i = 0; i < size; i++) {
            sb.append(elementData[i]);
            if (i < size - 1) {
                sb.append(", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }

🌟完整代码实现

public class MyArray<E> implements SeqList<E> {
    /**
     * 定义一个泛型数组elementData，使用Object类型
     * size不仅表示现有数组实际存储的大小,还表示下一个元素的位置
     */
    private Object[] elementData;//定义一个泛型数组
    private int size;//定义一个默认的数组大小
    /**
     * 有参和无参构造方法
     */
    //无参构造: 默认数组的长度是10
    public MyArray() {
        this(10);
    }
    //有参构造: 传入参数确定动态数组的长度为size
    public MyArray(int size) {
        this.elementData = new Object[size];
    }
    /**
     * 尾插：直接给数组添加元素
     */
    @Override
    public void add(E element) {
        this.elementData[size] = element;
        size++;
        if(size==elementData.length){
            grow();
        }
    }
    /**
     * 自定义实现grow扩容方法
     * 思想：
*          获取数组原来的旧长度，定义数组扩容后的新长度，定义新数组，长度为扩容后的长度，并将旧数组的
     * 元素值拷贝过来，此时的新数组就是我们的数组。
     */
    private void grow() {
        int oldLength = elementData.length;//获取原数组的长度
        int newLength = oldLength<<1;//获取新数组的长度：默认将容量扩为原先的一倍
        Object[] newArray = Arrays.copyOf(elementData, newLength);//将原数组拷贝到新数组中
        elementData = newArray;//获取扩容后的数组
    }
    /**
     * 三步原则：判断索引合法性——>数据处理：增删改查操作——>判断是否需要扩容
     * 增：根据索引添加元素
     * 思想：判断索引的合法性——>判断根据索引插入元素的位置判断是否需要扩容：
     *     (1)如果index=size,插入位置在size,不需要扩容:直接调用尾插方法
     *     (2)如果0<index<size插入位置在中间：遍历数组，找到索引位置，将索引后的数组元素每个都向后移动一位，就可以将索引位置空出来
     * 然后再将元素添加到索引位置。——>添加完成后判断是否需要扩容
     */
    @Override
    public void add(int index, E element) {
        //(1)判断索引的合理性
        if(index<0||index>size){
            throw new IllegalArgumentException("add index illegal");
        }
        //(2)如果插入位置为尾插：则直接调用尾插方法并提前结束该方法
        if(index==size){
            add(element);
            return;
        }
        //(3)如果插入位置在元素中间，则将数据插入并判断数组长度是否需要扩容
        for (int i = size-1; i >=index; i--) {//遍历数组走到Index位置
            elementData[i+1] = elementData[i];//将Index后的元素向后移
        }
        elementData[index]=element;//此时Index空出，插入待添加的元素
        //(4)判断数组是否需要扩容
        size++;
        if(size==elementData.length){
            grow();
        }
    }

    /**
     * 删：通过索引删除元素
     * 思路：遍历数组走到index位置，获取要删除的元素值进行记录，并将索引后的元素向左移动一位进行元素的覆盖
     */
    @Override
    public E removeByIndex(int index) {
        //(1)判断索引的合法性
        if(!indexCheck(index)){
           throw  new IllegalArgumentException("remove index illegal");
        }
        //(2)获取要删除索引位置的元素
        E oldVal = (E)elementData[index];
        //(2)遍历数组从Index位置走到size
        for (int i = index; i < size-1; i++) {//注意：这里因为要保证索引不能越界：i+1实际上是取不到size的,也就是i<size-1
            elementData[i] = elementData[i+1];//将索引后的元素向左移动一位进行元素的覆盖
        }
        //(3)size--
        size--;
        return oldVal;
    }
    /**
     * 索引的合法性校正
     */
    private boolean indexCheck(int index){
        if(index<0 || index>=size){
            return false;
        }
        return true;
    }
    /**
     * 删：直接删除数组中的出现的第一个element
     * 思路：遍历数组从0索引开始一直判断元素值是否等于element。如果找到了element，则该元素是我们要删除的元素
     * 获取element位置下的Index，通过调用removeByIndex方法删除。size--。
     */
    @Override
    public void removeByValue(E element) {
        for (int i = 0; i < size; i++) {
            if(elementData[i].equals(element)){
                removeByIndex(i);
                return;
            }
        }
        throw new IllegalArgumentException("没有找到该元素~");
    }
    /**
     * 删：删除数组中所有值为element的元素：
     * 错误写法：去掉removeByValue方法中的return即可
     * 原因：当数组中要删除的元素是连续出现时(比如连续出现了3次222)，调用removeByIndex方法删除元素要考虑当前指向的元素是不是要删除的元素：
     * 如果是要删除的元素，则i不能变化
     * 如果不是要删除的元素,i才可以++；
     */
    @Override
    public void removeAllValue(E element) {
//         自己一开始写成了这种形式，当出现连续要删除的元素值时会发生漏删的现象
      /*  for (int i = 0; i < size; i++) {
            if(elementData[i].equals(element)){
                removeByIndex(i);
            }
        }*/
        for (int i = 0; i < size; ) {
            if(elementData[i].equals(element)){
                removeByIndex(i);
            }else{
                i++;
            }
        }
    }
    /**
     * 改：修改index位置下的元素为element，并返回被修改的原值
     */
    @Override
    public E set(int index, E element) {
        if(!indexCheck(index)){
            throw new IllegalArgumentException("set index illegal");
        }
        //找到index下的旧值返回,并将新的数值赋值给数组的index位置
        E oldVal = (E)elementData[index];
        elementData[index] = element;
        return oldVal;

    }
    /**
     * 查：查询索引Index位置下的元素
     */
    @Override
    public E get(int index) {
        //(1)判断索引的合法性
        if(!indexCheck(index)){
            throw new IllegalArgumentException("get index illegal");
        }
        //(2)返回数值
        return (E) elementData[index];
    }

    /**
     * 判断数组是否包含element元素值，返回判断结果
     * 思想：遍历数组0-size,将数组的每一个值与element进行比对
     */
    @Override
    public boolean contains(E element) {
        for (int i = 0; i < size; i++) {
            if(elementData[i].equals(element)){
                return true;
            }
        }
        return false;
    }
    /**
     * 返回元素element在数组中对应的索引
     */
    @Override
    public int indexOf(E element) {
        for (int i = 0; i < size; i++) {
            if(elementData[i].equals(element)){
                return i;
            }
        }
        throw new IllegalArgumentException("indexOf error"+"Don't has this element");
    }
    /**
     * 重写ToString方法
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        // 遍历elementData数组
        for (int i = 0; i < size; i++) {
            sb.append(elementData[i]);
            if (i < size - 1) {
                sb.append(", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

🌟测试类

public class MyArrayTest {
    public static void main(String[] args) {
        //注意这里的写法：SeqList是一个接口，我们不能直接创建它的对象，必须通过它的实现类来创建对象
        SeqList<Integer> list = new MyArray<>() ;
        //往集合中添加元素
        list.add(0);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(3);
        list.add(3);
        System.out.println(list);
        //在索引位置添加元素
        list.add(3,9);
        System.out.println(list);
        //通过索引删除数据
        list.removeByIndex(3);
        System.out.println(list);
        //删除出现的第一个element值
        list.removeByValue(3);
        System.out.println(list);
        //删除所有值为element的元素
        list.removeAllValue(3);
        System.out.println(list);
        //将数组index 为0的位置改为9
        System.out.println(list.set(0,9));
        System.out.println(list);
        //查询Index下的元素
        System.out.println(list.get(3));
        //判断元素值7在数组中是否包含
        System.out.println(list.contains(7));
        //返回元素在数组中对应的索引值
        System.out.println(list.indexOf(9));
    }
}

代码运行结果：

🌟总结 

  • 动态数组在中间位置进行插入和删除，操作比较耗时，因为此时需要来回搬移元素；但是不能片面的认为数组的插入就一定慢：在进行尾插时，速度也是很快的，因为不需要元素的搬移。
  • 动态数组的底层依然使用的是数组，因此按索引查询是比较快的。
  • 动态数组一般需要连续的空间，因此当数据量较大时，会存在很大一部分空间的浪费。比如此时数组的长度为100，数组存满了，要再保存一个元素，就要进行扩容处理。扩容之后的数组长度变为了200.但是此时为了存储一个元素，浪费了99个空间。

        玩了两天，今天终于将动态数组的增删改查和扩容机制写了一遍，这两天就是说疯狂的补课补课补作业中~

IUIUStar
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现动态数组 超详细 小白也能懂
Fu_chen__的博客
02-02 3133
C语言实现动态数组
在数组指定索引插入一条数据的几个方法
IU
07-17 7027
1. splice splice(position, numberOfItemsToRemove, item) position:加入元素的索引位置，原始索引向后移一位 numberOfItemsToRemove：要删除元素的数量 item:插入的元素 如果只需要添加，不需要删除的话，我们可以封装一个类似的函数（利用原型链） 原理：在原型链中增加一个函数对象,删除的参数默认为0，如图 ...
使用c++类模板实现动态数组-可实现自定义数据类型存储
hou19975418的博客
01-13 805
今天在重新学习了数据结构中的顺序存储结构-顺序表之后，尝试跟随视频完成了基于c语言的动态数组实现，发现由于c语言中没有模板这一概念，所以它的实现主要针对单一的内置数据类型如int等来展开。感觉整体敲的时候思路还是比较清晰的，但是也出现了语句顺序，delete[]和new[]不匹配的问题，以及在实现自定义数据类型操作时需要运算符重载上有点迷糊（把问题想复杂了，只需要重载元素数据类型的运算符即可。这套代码直接在模板类中提供了多个接口，用到了类和类模板的分文件编写。
数组中动态添加或删除数据
weixin_48930475的博客
05-26 1230
1、arr[index] = val,通过数组名[下标]赋值的形式直接添加数据，注意如果下标在数组中之前存在，此时执行的是对数组中的元素进行修改。如果想要添加，此方式只能在数组的末尾添加元素。 2、arr.push(val) ---调节数组的方法push，向数组的最后一个位置添加元素。 3、arr.shift() ---删除数组最前面一个元素 4、arr.unshift(val) ---在数组最前面的位置插入一个元素 5、arr.pop() ---删除数组最后第一个元素 6、arr.splice(
动态数组的增删改查
CkzWp171231的博客
04-19 1250
Java实现动态数组的增删改查。
数据结构动态数组实现链表
05-12
总的来说，通过动态数组实现链表是一种有趣的实践，它结合了两种数据结构的优点，但也需要权衡插入/删除效率和内存使用。理解这种实现方式可以帮助我们更好地理解和设计数据结构，为未来的编程挑战打下坚实的基础。
数据结构之数组翻转的实现方法
01-01
数据结构之数组翻转的实现方法 以下为实现数组翻转的方法： 1.用c语言实现的版本 #include #define M 20 void fun(int *x,int n) { int *i, *j, *p, m=n/2; i = x; j = x+n-1; p = x+m; for( ; i<p; ++i,-...
数据结构固定大小数组实现链表
05-12
这种实现方式结合了数组和链表的优点：利用数组的连续存储特性加速随机访问，同时通过指针实现动态扩展和收缩。 1. **节点结构**： 通常，数组中的每个元素会扩展为一个结构体，包括数据域和指针域。例如： ```c ...
C++ 数据结构线性表-数组实现
12-26
C++ 数据结构线性表-数组实现 线性表的数组实现，实现几个核心的功能，语言是C++，如果有更好的想法和意见，欢迎留言~~~ /* Author : Moyiii * 线性表的数组实现，仅作学习之用，当然如果 * 你想拿去用，随你好啦...
动态数组的实现（C++）
柚子树's Blog
05-05 7252
这是用 C++ 封装的一个简单的动态数组类模板，它由任意多个位置连续的、类型相同的元素组成，其元素个数可在程序运行性改变，与 vector 的工作原理相同。并且使用这个动态数组实现求 2~n 区间之间不确定个数的质数。有需要可以参考，代码如下： // Array.h #pragma once #include <iostream> #include <cassert> ...
实现动态数组
最新发布
2302_79401873的博客
10-09 102
定义格式： 数组存储的数据类型[][] 数组名 = new 数据类型[存储的一维数组个数][每个 一维数组中存储的元素个数];定义格式： 数组存储的数据类型[] 数组名= new 数据类型[存储的元素个数];下标： 从0开始(将数组中的第一个位置的内存地址转为标号0)，依次向后递增1。属性： 底层存储数据的数组 已存入的元素个数 数组的实时长度。1： 数组定义好之后长度固定 ，不具备扩容的条件。2： 我们可以自己定义一个动态数组类实现自动扩容。构造方法： 进行初始化。长度： 整个数组中可以存储的元素个数。
数据结构学习——动态数组C#实现
xiaojuese255的博客
08-28 4438
数据结构，动态数组C#实现
Java动态数组的实现
weixin_52953038的博客
07-05 3973
众所周知，在Java中，数组的特点是 因此，数组也有缺点，比如说，数组一旦创建，长度不可改变。这样的话，就不怎么利于我们的使用。我们学习的数组都是静态数组，其实在很多的时候，静态数组根本不能满足我们编程的实际需要，比方说我们需要在程序运行过程中动态的向数组中添加数据，这时我们的静态数组大小是固定的，显然就不能添加数据，要动态添加数据必须要用到动态数组，动态数组中的各个元素类型也是一致的。 在我们的学习使用中，经常要对数组进行 增加、删除、改变元素、查找元素等等...一系列操作。.
【数据结构】动态数组
m0_50987960的博客
11-15 2816
动态数组主要方法的创建以及JVM中ArrayList的使用
JAVA学习--4.动态数组实现
weixin_43929250的博客
04-21 193
动态数组实现 1.类的构造 ​ 所有类的构造都需要从两方面考虑：属性和方法。 属性 ​ 想要构造一个动态数组，首先就是需要一个大小不确定的数组，在调用其构造函数时再去确定数组的大小。 ​ 其次有关这个数组的一些参数：首先需要又length来用于确定他的大小，然后我们可以用size来表示这个数组实际被使用到的空间。这两个数据也会帮助在我们之后对对象进行增加，删除操作时做出判断，是否需要扩容等。 //存放数据的容器 int[] arr; //容器的大小 int length = 0; //被使用的
动态数组实现
Princess_Y
11-28 229
动态数组 动态数组的特点 逻辑结构：线性的 物理结构：顺序结构 申请内存：一次申请一大段连续的空间，一旦申请到了，内存就固定了。 存储特点：所有数据存储在这个连续的空间中，数组中的每一个元素都是一个具体的数据（或对象），所有数据都紧密排布，不能有间隔。 动态数组的基本操作 与数据结构相关的数据操作： 插入 删除 修改 查找 遍历 public interface Container<E> extends Iterable<E>{ void add(E e); void ins
动态建立数组
热门推荐
qq_41727218的博客
03-29 1万+
          在很多情况下，我们不知道所要建立数组的大小，而是想根据需求动态的建立数组。但是通常使用 int arr[n] 这样的写法编译器会报错，因为n是变量。例如以下代码 int n = 10; int a[n];   对于这种情况我们可以用以下的方法解决。 一、建立动态数组     用到的头文件：# include &lt;stdlib.h&gt; 用到的函数：m...
动态数组的简单写法
weixin_45791222的博客
06-14 363
动态数组 数组是一段连续的空间，所以一旦确定就不能随意更改，但是有时候需要的长度不确定，弄得太大浪费，小了容易不够，所以需要动态数组。动态数组在java里是提供的 ArrayList。下面是一个手写的类似的方法。 下面的源码没有测试过，大致差不多，当然估计会有一些问题，但能大概帮助理解 重要的地方有俩 一个是泛型，一个是扩容 泛型：把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型(就是数据类型等着用的时候改) 扩容：因为数组一串连续的空间，想要扩大就不能直接再后面贴一段空间。所有解决办法

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值