AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

【数据结构与算法】1、学习动态数组数据结构（基本模拟实现 Java 的 ArrayList 实现增删改查）

2024-03-01 428
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【数据结构与算法】1、学习动态数组数据结构（基本模拟实现 Java 的 ArrayList 实现增删改查）


一、什么是数据结构

(1) 概念

🍃 数据结构是计算机存储、组织数据的方式

(2) 分类

🎉 线性结构

  • 线性表（数组、链表、栈、队列、哈希表）

🎉 树形结构

  • 二叉树
  • AVL 树
  • 红黑树
  • B 树
  • 堆
  • Trie
  • 哈夫曼树
  • 并查集

🎉 图形结构

  • 邻接矩阵
  • 邻接表

二、线性表

🎁 线性表是具有 n 个相同类型元素的有限序列（n >= 0）

  • a1 是首节点（首元素）， an 是尾结点（尾元素）
  • a1 是 a2 的前驱
  • a2 是 a1 的后继

常见的线性表有：

🎗️ 数组

🎗️ 链表

🎗️ 栈

🎗️ 队列

🎗️ 哈希表（散列表）

三、数组（Array）

(1) 数组的底层结构

🎁 数组是一种顺序存储的线性表，全部元素的内存地址是连续的

// 【new】向堆空间申请一段存储空间
int[] array = new int[]{11, 22, 33};

(2) 数组缺点

  • 👓数组有个致命的缺点：无法动态修改容量
  • 👓数组创建完毕后，能够存储的数据就固定了
  • 👓数组操纵元素的方式不够面向对象

🎐 自己实现动态数组，弥补数组的缺点

四、动态数组（Dynamic Array）接口设计

public interface List<E> {
    /**
     * 元素的数量
     */
    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) 成员变量

Java 中的成员变量会自动初始化，比如：

🎑 int 类型自动初始化为 0

🎑 对象类型自动初始化为 null

🎑 size 记录动态数组中元素的个数

🎑 elements 用于实际存储数据

🎑 动态数组的底层是数组

(2) 代码

/**
 * 只支持存储 int 类型数据的动态数组
 */
public class ArrayListInt {
    private int size;
    private int[] elements;
    public static final int DEFAULT_CAPACITY = 10;
    public static final int ELEMENT_NOT_FOUND = -1;
    public ArrayListInt() {
        this(DEFAULT_CAPACITY);
    }
    public ArrayListInt(int capacity) {
        capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
        elements = new int[capacity];
    }
    public int size() {
        return size;
    }
    public boolean isEmpty() {
        return size == 0;
    }
    /**
     * 获取 index 索引处的元素
     */
    public int get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("size: " + size + ", " + "index: " + index);
        }
        return elements[index];
    }
    /**
     * 设置 index 位置的元素
     *
     * @param index   下标
     * @param element 要设置的元素
     * @return 原来的元素ֵ
     */
    public int set(int index, int element) {
        // 获取 index 位置的元素
        int old = get(index);
        elements[index] = element;
        return old;
    }
    /**
     * 返回元素的索引
     */
    public int indexOf(int element) {
        // 如果数组为空, 直接找不到
        if (isEmpty()) return ELEMENT_NOT_FOUND;
        for (int i = 0; i < size; i++) {
            if (element == elements[i]) return i;
        }
        return ELEMENT_NOT_FOUND;
    }
    /**
     * 检查数组中是否包含 element 元素
     */
    public boolean contains(int element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }
    /**
     * 清除全部元素
     * 只要【size = 0】就无法获取到数组中的任何元素了
     */
    public void clear() {
        size = 0;
    }
}

① get ()

🎈 该方法的作用：获取 index 索引处的元素

🎈 数组可通过索引获取到元素

🎈 要做参数（index）校验

② indexOf ()

🎈 返回某个元素的索引

🎈 遍历每个下标的元素，拿数组中的每个元素和参数元素进行比较

③ clear ()

🎈 清除全部元素（清空数组）

🎈 在当前的代码中，只要【size = 0】就无法获取到数组中的任何元素了（就可以理解为清空了数组）

六、add 方法和扩容

🎈 add(int element)：往数组的尾部添加元素 element

🎈 add(int index, int element)：往数组的 index 索引位置添加元素 element

(1) add (int element)

🕰️ 每次往尾部添加元素的时候，是往数组的索引为 size 位置添加元素

public class ArrayListInt {
    /**
     * 往数组尾部添加元素
     */
    public void add(int element) {
        // TODO 扩容检测
        elements[size++] = element;
    }
}

(2) 打印动态数组中的元素

☆写法1：

public class ArrayListInt {
    /**
     * 遍历打印数组中的元素
     */
    public String printElements() {
        StringBuilder sb = new StringBuilder();
        sb.append("{size=").append(size).append(", [");
        for (int i = 0; i < size; i++) {
            sb.append(elements[i]);
            if (i != size - 1) {
                sb.append(", ");
            }
        }
        sb.append("]}");
        return sb.toString();
    }
}

🎨 遍历获取数组中的各个元素，然后进行拼接

🎨 Java 中大量字符串拼接用 StringBuilder 最好

☆写法2：

public class ArrayListInt {
 
    /**
     * 遍历打印数组中的元素
     */
    public String printElements() {
        StringBuilder sb = new StringBuilder();
        sb.append("{size=").append(size).append(", [");
        for (int i = 0; i < size; i++) {
            // 不是第 0 个元素就先拼接【, 】
            if (i != 0) {
                sb.append(", ");
            }
            sb.append(elements[i]);
        }
        sb.append("]}");
        return sb.toString();
    }
}

🎨 不是第 0 个元素就先拼接【, 】

🎨 相比写法1每次循环少了一次减法运算

(3) add (int index, int element)

☆ 往 index 位置插入元素 element

🎁 把 index 位置到 size - 1 位置【[index, size-1]】的元素往后挪动【空出 index 位置的元素】

🎁 把 element 元素赋值到 index 索引位置

🎁 从 索引为 size - 1 处开始挪动

public class ArrayListInt {
    /**
     * 在 index 位置插入元素 element
     */
    public void add(int index, int element) {
        // 当 index 等于 size 的时候, 是往数组的尾部添加元素
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("size: " + size + ", " + "index: " + index);
        }
        // TODO 扩容检测
        // 挪动元素（从最后一个元素开始挪动）
        for (int i = size - 1; i >= index; i--) {
            elements[i + 1] = elements[i];
        }
        // 把元素 element 赋值到 index 索引位置
        elements[index] = element;
        size++; // 数组元素加1
    }
}

(4) 数组越界异常的封装

public class ArrayListInt {
    public void outOfBounds(int index) {
        throw new IndexOutOfBoundsException("index: " + index + " size: " + size);
    }
    public void rangeCheck(int index) {
        if (index < 0 || index >= size) {
            outOfBounds(index);
        }
    }
    public void rangeCheck4Add(int index) {
        if (index < 0 || index > size) {
            outOfBounds(index);
        }
    }
}

✏️ outOfBounds(int index)：封装抛异常的方法

✏️ rangeCheck(int index)：索引 index 不能小于 0 或 大于等于 size，否则都会数组越界

✏️ rangeCheck4Add(int index)：添加元素的时候 index 是可以等于 size 的（此时是往数组的最后添加元素）

(5) MyJunit（接口测试）

🍃使用异常知识进行接口测试：当测试不通过的时候，会抛异常

🍃测试通过的时候，打印 Success!

public class MyJunit {
    public static void test(boolean boolean_) {
        try {
            if (!boolean_) throw new Exception("测试不通过");
            System.out.println("\nSuccess!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

(6) 扩容【 ensureCapacity() 】

📖① 申请全新的数组空间（容量适宜）

📖② 把就数据的数据复制到全新的数组中

📔 添加的时候才会考虑扩容操作

/**
     * 扩容检测
     *
     * @param capacity 数组容量至少是 capacity
     */
    private void ensureCapacity(int capacity) {
        int oldCapacity = elements.length;
        // 如果所需容量足够, 则不扩容
        if (oldCapacity >= capacity) return;
        // 申请全新的数组空间（新容量是旧容量的 1.5 倍）
        capacity = oldCapacity + (oldCapacity >> 1);
        int[] newElements = new int[capacity];
        // 把旧数组中的数据复制到新数组中
        for (int i = 0; i < size; i++) {
            newElements[i] = elements[i];
        }
        // elements 指针指向新数组
        elements = newElements;
        System.out.println(oldCapacity + "扩容为" + capacity);
    }

七、remove (int index)

📔 作用：删除 index 索引处的元素，返回之前 index 索引处的元素

📙 思路：① 用后面的元素把要 删除的索引 index 位置的元素覆盖掉

📙 ② 数组 size 减 1

📙 ③ 如何覆盖❓ 遍历

public class ArrayListInt {
    /**
     * 删除 index 位置的元素
     *
     * @param index 下标
     * @return 原来的元素
     */
    public int remove(int index) {
        // 取出 index 索引处原来的元素
        int old = get(index);
        // 覆盖掉 index 索引处的元素
        for (int i = index; i < size; i++) {
            elements[i] = elements[i + 1];
        }
        // 最后一个元素不被访问到的关键代码
        size--;
        return old;
    }
}

八、仅能存储 int 类型的动态数组 ArrayListInt 完整代码

/**
 * 只支持存储 int 类型数据的动态数组
 */
@SuppressWarnings("all")
public class ArrayListInt {
    private int size;
    private int[] elements;
    public static final int DEFAULT_CAPACITY = 10;
    public static final int ELEMENT_NOT_FOUND = -1;
    public ArrayListInt() {
        this(DEFAULT_CAPACITY);
    }
    public ArrayListInt(int capacity) {
        capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
        elements = new int[capacity];
    }
    public int size() {
        return size;
    }
    public boolean isEmpty() {
        return size == 0;
    }
    /**
     * 获取 index 索引处的元素
     */
    public int get(int index) {
        rangeCheck(index);
        return elements[index];
    }
    /**
     * 设置 index 位置的元素
     *
     * @param index   下标
     * @param element 要设置的元素
     * @return 原来的元素ֵ
     */
    public int set(int index, int element) {
        // 获取 index 位置的元素
        int old = get(index);
        elements[index] = element;
        return old;
    }
    /**
     * 返回元素的索引
     */
    public int indexOf(int element) {  
        for (int i = 0; i < size; i++) {
            if (element == elements[i]) return i;
        }
        return ELEMENT_NOT_FOUND;
    }
    /**
     * 检查数组中是否包含 element 元素
     */
    public boolean contains(int element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }
    /**
     * 清除全部元素
     * 只要【size = 0】就无法获取到数组中的任何元素了
     */
    public void clear() {
        size = 0;
    }
    /**
     * 往数组尾部添加元素
     */
    public void add(int element) {
        add(size, element);
    }
    /**
     * 在 index 位置插入元素 element
     */
    public void add(int index, int element) {
        rangeCheck4Add(index);
        // 扩容检测, 保证容量至少是【size+1】
        ensureCapacity(size + 1);
        // 挪动元素（从最后一个元素开始挪动）
        for (int i = size - 1; i >= index; i--) {
            elements[i + 1] = elements[i];
        }
        // 把元素 element 赋值到 index 索引位置
        elements[index] = element;
        size++; // 数组元素加1
    }
    /**
     * 扩容检测
     *
     * @param capacity 数组容量至少是 capacity
     */
    private void ensureCapacity(int capacity) {
        int oldCapacity = elements.length;
        // 如果所需容量足够, 则不扩容
        if (oldCapacity >= capacity) return;
        // 申请全新的数组空间（新容量是旧容量的 1.5 倍）
        capacity = oldCapacity + (oldCapacity >> 1);
        int[] newElements = new int[capacity];
        // 把旧数组中的数据复制到新数组中
        for (int i = 0; i < size; i++) {
            newElements[i] = elements[i];
        }
        // elements 指针指向新数组
        elements = newElements;
        System.out.println(oldCapacity + "扩容为" + capacity);
    }
    /**
     * 删除 index 位置的元素
     *
     * @param index 下标
     * @return 原来的元素
     */
    public int remove(int index) {
        // 取出 index 索引处原来的元素
        int old = get(index);
        // 覆盖掉 index 索引处的元素
        for (int i = index; i < size - 1; i++) {
            elements[i] = elements[i + 1];
        }
        // 最后一个元素不被访问到的关键代码
        size--;
        return old;
    }
    public void outOfBounds(int index) {
        throw new IndexOutOfBoundsException("index: " + index + " size: " + size);
    }
    public void rangeCheck(int index) {
        if (index < 0 || index >= size) {
            outOfBounds(index);
        }
    }
    public void rangeCheck4Add(int index) {
        if (index < 0 || index > size) {
            outOfBounds(index);
        }
    }
    /**
     * 遍历打印数组中的元素
     */
    public String printElements() {
        StringBuilder sb = new StringBuilder();
        sb.append("{size=").append(size).append(", [");
        for (int i = 0; i < size; i++) {
            // 不是第 0 个元素就拼接【, 】
            if (i != 0) {
                sb.append(", ");
            }
            sb.append(elements[i]);
        }
        sb.append("]}");
        return sb.toString();
    }
}

九、泛型（让动态数组中能存放各种类型的数据）

🎁 可使用 Java 中的泛型让动态数据更加通用（在动态数组中能存放任何数据类型的数据）

(1) clear () 【对象数组】

🧣 当动态数组中可以存储任何类型的时候，对于 clear() 方法，仅仅把 size 设置为 0 是不够的

🧣 把 size 设置为 0 后，虽然使用动态数组的人无法获取到任何数据，但这些数据仍然存活在内存中【这些数据依然存在，只是你无法使用它而已】

🧣 最佳的方式是：把 size 设置为 0，并把这些内存都回收掉（置为 null）

/**
     * 清除全部元素
     */
    public void clear() {
        // 销毁堆空间的对象数据
        for (int i = 0; i < elements.length; i++) {
            elements[i] = null;
        }
        
        size = 0;
    }

(2) 对象的比较不用 【==】

🎁 两个 对象用 == 运算符进行比较的时候，比较的是两个对象的内存地址

🎁 若不想比较两个对象的内存地址，需要用 equals() 方法

public int indexOf(E element) {
        if (element == null) return ELEMENT_NOT_FOUND;
        // 如果数组为空, 直接找不到
        if (isEmpty()) return ELEMENT_NOT_FOUND;
        for (int i = 0; i < size; i++) {
            if (element.equals(elements[i])) return i;
        }
        return ELEMENT_NOT_FOUND;
    }

(3) remove (int index) 清空最后一个元素

/**
     * 删除 index 位置的元素
     *
     * @param index 下标
     * @return 原来的元素
     */
    public E remove(int index) {
        // 取出 index 索引处原来的元素
        E old = get(index);
        // 覆盖掉 index 索引处的元素
        for (int i = index + 1; i < size; i++) {
            elements[i - 1] = elements[i];
        }
        // 把最后一个元素置空
        elements[--size] = null;
        return old;
    }

(4) null 值处理

动态数组中应该要能够存放 null 值

/**
     * 返回元素的索引
     */
    public int indexOf(E element) {
        if (null == element) {
            for (int i = 0; i < size; i++) {
                if (elements[i] == null) return i;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (element.equals(elements[i])) return i;
            }
        }
        return ELEMENT_NOT_FOUND;
    }

(5) ArrayList 完整代码

/**
 * 泛型让动态数组中能存放任何数据类型的数据
 */
@SuppressWarnings("all")
public class ArrayList<E> {
    private int size;
    private E[] elements;
    public static final int DEFAULT_CAPACITY = 10;
    public static final int ELEMENT_NOT_FOUND = -1;
    public ArrayList() {
        this(DEFAULT_CAPACITY);
    }
    public ArrayList(int capacity) {
        capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
        elements = (E[]) new Object[capacity];
    }
    public int size() {
        return size;
    }
    public boolean isEmpty() {
        return size == 0;
    }
    /**
     * 获取 index 索引处的元素
     */
    public E get(int index) {
        rangeCheck(index);
        return elements[index];
    }
    /**
     * 设置 index 位置的元素
     *
     * @param index   下标
     * @param element 要设置的元素
     * @return 原来的元素ֵ
     */
    public E set(int index, E element) {
        // 获取 index 位置的元素
        E old = get(index);
        elements[index] = element;
        return old;
    }
    /**
     * 返回元素的索引
     */
    public int indexOf(E element) {
        if (null == element) {
            for (int i = 0; i < size; i++) {
                if (elements[i] == null) return i;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (element.equals(elements[i])) return i;
            }
        }
        return ELEMENT_NOT_FOUND;
    }
    /**
     * 检查数组中是否包含 element 元素
     */
    public boolean contains(E element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }
    /**
     * 清除全部元素
     */
    public void clear() {
        // 销毁堆空间的对象数据
        for (int i = 0; i < elements.length; i++) {
            elements[i] = null;
        }
        size = 0;
    }
    /**
     * 往数组尾部添加元素
     */
    public void add(E element) {
        add(size, element);
    }
    /**
     * 在 index 位置插入元素 element
     */
    public void add(int index, E element) {
        rangeCheck4Add(index);
        // 扩容检测, 保证容量至少是【size + 1】
        ensureCapacity(size + 1);
        // 挪动元素（从最后一个元素开始挪动）
        for (int i = size - 1; i >= index; i--) {
            elements[i + 1] = elements[i];
        }
        // 把元素 element 赋值到 index 索引位置
        elements[index] = element;
        size++; // 数组元素加1
    }
    /**
     * 扩容检测
     *
     * @param capacity 数组容量至少是 capacity
     */
    private void ensureCapacity(int capacity) {
        int oldCapacity = elements.length;
        // 如果所需容量足够, 则不扩容
        if (oldCapacity >= capacity) return;
        // 申请全新的数组空间（新容量是旧容量的 1.5 倍）
        capacity = oldCapacity + (oldCapacity >> 1);
        E[] newElements = (E[]) new Object[capacity];
        // 把旧数组中的数据复制到新数组中
        for (int i = 0; i < size; i++) {
            newElements[i] = elements[i];
        }
        // elements 指针指向新数组
        elements = newElements;
        System.out.println(oldCapacity + "扩容为" + capacity);
    }
    /**
     * 删除 index 位置的元素
     *
     * @param index 下标
     * @return 原来的元素
     */
    public E remove(int index) {
        // 取出 index 索引处原来的元素
        E old = get(index);
        // 覆盖掉 index 索引处的元素
        for (int i = index + 1; i < size; i++) {
            elements[i - 1] = elements[i];
        }
        // 把最后一个元素置空
        elements[--size] = null;
        return old;
    }
    public void outOfBounds(int index) {
        throw new IndexOutOfBoundsException("index: " + index + " size: " + size);
    }
    public void rangeCheck(int index) {
        if (index < 0 || index >= size) {
            outOfBounds(index);
        }
    }
    public void rangeCheck4Add(int index) {
        if (index < 0 || index > size) {
            outOfBounds(index);
        }
    }
    /**
     * 遍历打印数组中的元素
     */
    public String printElements() {
        StringBuilder sb = new StringBuilder();
        sb.append("{size=").append(size).append(", [");
        for (int i = 0; i < size; i++) {
            // 不是第 0 个元素就拼接【, 】
            if (i != 0) {
                sb.append(", ");
            }
            sb.append(elements[i]);
        }
        sb.append("]}");
        return sb.toString();
    }
}

JDK 中内置了动态数组类：java.util.ArrayList

如有错误和疑问，欢迎和我交流

文章标签：
Java
索引
算法
存储
张思睿ZGQ
目录
相关文章
34789737
|
存储 Java 索引
用Java语言实现一个自定义的ArrayList类
自定义MyArrayList类模拟Java ArrayList核心功能，支持泛型、动态扩容（1.5倍）、增删改查及越界检查，底层用Object数组实现，适合学习动态数组原理。
34789737
652 4
荔枝科研社
|
机器学习/深度学习 运维 算法
【微电网多目标优化调度】多目标学习者行为优化算法MOLPB求解微电网多目标优化调度研究（Matlab代码实现）
【微电网多目标优化调度】多目标学习者行为优化算法MOLPB求解微电网多目标优化调度研究（Matlab代码实现）
荔枝科研社
465 1
HELLO程序员
|
缓存 Java 开发者
Java 开发者必看！ArrayList 和 LinkedList 的性能厮杀：选错一次，代码慢成蜗牛
本文深入解析了 Java 中 ArrayList 和 LinkedList 的性能差异，揭示了它们在不同操作下的表现。通过对比随机访问、插入、删除等操作的效率，指出 ArrayList 在多数场景下更高效，而 LinkedList 仅在特定情况下表现优异。文章强调选择合适容器对程序性能的重要性，并提供了实用的选择法则。
HELLO程序员
583 3
荔枝科研社
|
机器学习/深度学习 算法 数据挖掘
没发论文的注意啦！重磅更新！GWO-BP-AdaBoost预测！灰狼优化、人工神经网络与AdaBoost集成学习算法预测研究（Matlab代码实现）
没发论文的注意啦！重磅更新！GWO-BP-AdaBoost预测！灰狼优化、人工神经网络与AdaBoost集成学习算法预测研究（Matlab代码实现）
荔枝科研社
430 0
蓝易云
|
Java 索引
Java ArrayList中的常见删除操作及方法详解。
通过这些方法，Java `ArrayList` 提供了灵活而强大的操作来处理元素的移除，这些方法能够满足不同场景下的需求。
蓝易云
897 30
大数据文摘
|
人工智能 安全 JavaScript
Java ArrayList：动态数组
本文探讨Java中的数组，对比C/C++、JS/PHP/Python等语言的数组特性。文章分析了Java数组的定义、创建方式及其规范，指出其优缺点。Java数组作为引用类型，在堆上分配内存，支持动态大小，避免了C/C++中裸数组的常见问题（如越界访问）。然而，Java数组也存在性能瓶颈和设计缺陷，例如运行时的安全检查影响速度，无法创建超大数组或泛型数组，且多线程场景下缺乏同步机制。作者建议在实际开发中用集合替代数组以规避这些问题。
大数据文摘
421 1
游客yubogfpxqaaew
|
算法 数据可视化 开发者
为什么要学习数据结构与算法
今天，我向大家介绍一门非常重要的课程——《数据结构与算法》。这门课不仅是计算机学科的核心，更是每一位开发者从“小白”迈向“高手”的必经之路。
游客yubogfpxqaaew
501 7
为什么要学习数据结构与算法
卷福同学
|
负载均衡 算法
架构学习：7种负载均衡算法策略
四层负载均衡包括数据链路层、网络层和应用层负载均衡。数据链路层通过修改MAC地址转发帧；网络层通过改变IP地址实现数据包转发；应用层有多种策略，如轮循、权重轮循、随机、权重随机、一致性哈希、响应速度和最少连接数均衡，确保请求合理分配到服务器，提升性能与稳定性。
卷福同学
3288 11
架构学习：7种负载均衡算法策略
智物科技库
|
Java 索引 容器
Java ArrayList扩容的原理
Java 的 `ArrayList` 是基于数组实现的动态集合。初始时，`ArrayList` 底层创建一个空数组 `elementData`，并设置 `size` 为 0。当首次添加元素时，会调用 `grow` 方法将数组扩容至默认容量 10。之后每次添加元素时，如果当前数组已满，则会再次调用 `grow` 方法进行扩容。扩容规则为：首次扩容至 10，后续扩容至原数组长度的 1.5 倍或根据实际需求扩容。例如，当需要一次性添加 100 个元素时，会直接扩容至 110 而不是 15。
智物科技库
871 4
Java ArrayList扩容的原理
阿里云大数据Al技术
|
机器学习/深度学习 人工智能 自然语言处理
【EMNLP2024】基于多轮课程学习的大语言模型蒸馏算法 TAPIR
阿里云人工智能平台 PAI 与复旦大学王鹏教授团队合作，在自然语言处理顶级会议 EMNLP 2024 上发表论文《Distilling Instruction-following Abilities of Large Language Models with Task-aware Curriculum Planning》。
阿里云大数据Al技术
1371 8

热门文章

最新文章

  • 1
    数据结构与算法之链表(超详细，适合入门）
  • 2
    好家伙，被我发现了个数据结构与算法可视化网站！
  • 3
    【数据结构与算法 刷题系列】判断链表是否有环（图文详解）
  • 4
    20120920-AVL树定义《数据结构与算法分析》
  • 5
    【数据结构与算法】详解循环队列：基于数组实现高效存储与访问
  • 6
    快速排序-数据结构与算法
  • 7
    Java数据结构与算法：图算法之广度优先搜索（BFS）
  • 8
    JS数据结构与算法-栈
  • 9
    Java数据结构与算法(二)-简单排序
  • 10
    数据结构与算法-实验2 树的二叉链表表示及其遍历
  • 1
    （Pandas）Python做数据处理必选框架之一！（一）：介绍Pandas中的两个数据结构；刨析Series：如何访问数据；数据去重、取众数、总和、标准差、方差、平均值等；判断缺失值、获取索引...
    909
  • 2
    （Python基础）新时代语言！一起学习Python吧！（一）：认识Python、Py解释器作用；编写第一个Python程序；Python中的基本数据结构
    815
  • 3
    Redis数据结构：别小看这5把“瑞士军刀”，用好了性能飙升！
    943
  • 4
    软考中级软件设计师专项-数据结构与算法上篇
    1180
  • 5
    【Redis】常用数据结构之List篇：从常用命令到典型使用场景
    1014
  • 6
    Redis基础命令与数据结构概览
    485
  • 7
    Redis各类数据结构详细介绍及其在Go语言Gin框架下实践应用
    686
  • 8
    【Redis】 常用数据结构之String篇：从SET/GET到INCR的超全教程
    1029
  • 9
    【📕分布式锁通关指南 12】源码剖析redisson如何利用Redis数据结构实现Semaphore和CountDownLatch
    1027
  • 10
    Redis核心数据结构与分布式锁实现详解
    1440

    • 相关课程

    更多
  • 神经网络概览及算法详解
  • Java Web项目实战 - 图书商城
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门

    • 相关电子书

    更多
  • 【云栖精选7月刊】抛开晦涩的算法、模型，让我们来谈谈互联网架构
  • 聚星台—客户运营核心大数据 与算法技术
  • Apache Flink 流式应用中状态的数据结构定义升级
    • 下一篇
    一条命令迁移，帮你实现 OpenClaw 与 Hermes Agent 记忆互通！