第二章 动态数组

最新推荐文章于 2023-01-30 16:24:19 发布
最新推荐文章于 2023-01-30 16:24:19 发布
阅读量207 收藏 1
点赞数
分类专栏： 恋上数据结构与算法 第一季 文章标签： 链表 数据结构 算法 数组 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sj15814963053/article/details/122741468
版权

第二章 动态数组

什么是数据结构？

  • 数据结构是计算机存储、组织数据的方式
  • 数据结构是指相互之间存在一种或多种特定关系的数据元素的集合
  • 在实际应用中，根据使用场景来选择最合适的数据结构

Untitled

线性表

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

Untitled

  • a1 是首节点（首元素）， an 是尾结点（尾元素）
  • a1 是 a2 的前驱节点， a2 是 a1 的后继节点
  • 常见的线性表有：
    • 数组
    • 链表
    • 栈
    • 队列
    • 哈希表（散列表）

数组（Array）

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

Untitled

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

动态数组（Dynamic Array）

动态数组接口设计

int size(); // 元素的数量
boolean isEmpty(); // 是否为空
boolean contains (E element); // 是否包含某个元素
void add (E element); // 添加元素到尾部
E get (int index); // 获取index位置的元素
E set (int index, E element); // 设置index位置的元素
void add (int index, E element); // *在index位置插入一个元素*E remove (int index); // 删除index位置对应的元素
int indexOf (E element); // 查看元素的索引
void clear (); // 清除所有元素

数组的默认形态

Untitled

添加元素 - add(E element)

add(E element)：默认往数组最后添加元素

Untitled

/**
 * 添加元素到尾部
 *
 * @param element
 */
public void add(int element) {
    elements[size++] = element;
}

删除元素 - remove(int index)

Untitled

Untitled

/**
 * 删除index位置的元素
 *
 * @param index
 * @return 返回删掉的元素
 */
public int remove(int index) {
    if (index < 0 || index >= size) {
        throw new IndexOutOfBoundsException("Index：" + index + ", Size：" + size);
    }
    int old = elements[index];
    for (int i = index + 1; i <= size - 1; i++) {
        elements[i - 1] = elements[i];
    }
    size--;
    return old;
}

思考：最后一个元素如何处理？

  • 如果存放 int 类型，size-- 后，最后一个元素已经无法访问了
  • 如果使用泛型，数组要注意内存管理（将元素置为 null）
  • 使用泛型技术可以让动态数组更加通用，可以存放任何数据类型

添加元素 - add(int index,E element)

add(int index, E element)：在 index 位置插入一个元素

比如要往 index = 2 的地方添加元素：

正确的顺序应当是：从后往前开始将 index = 2 以后的元素依次后移，然后赋值：

Untitled

如果从前往后开始移动元素，会造成如下错误的后果：

Untitled

Untitled

/**
 * 在index位置插入一个元素
 *
 * @param index
 * @param element
 */
public void add(int index, int element) {
    //注意这个地方的index > size
    if (index < 0 || index > size) {
        throw new IndexOutOfBoundsException("Index：" + index + ", Size：" + size);
    }
    for (int i = size - 1; i >= index; i--) {
        elements[i + 1] = elements[i];
    }
    elements[index] = element;
    size++;
}

如何扩容？- ensureCapacity(int capacity)

暴力方法：直接申请一块更大的内存

Untitled

/**
 * 扩容
 */
private void ensureCapacity(int capacity) {
    int oldCapacity = elements.length;
    if (oldCapacity >= capacity) {
        return;
    }
    //扩容到原来容量的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    int[] newElements = new int[newCapacity];
    for (int i = 0; i < size; i++) {
        newElements[i] = elements[i];
    }
    elements = newElements;
}

清空数组 - clear( )

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

int型动态数组完整代码

/**
 * @author xiexu
 * @create 2021-07-21 9:36 上午
 */
public class IntArrayList {
    private int size; //元素的数量
    private int[] elements; //所有的元素

    private static final int DEFAULT_CAPACITY = 10; //默认容量
    private static final int ELEMENT_NOT_FOUND = -1;

    public IntArrayList(int capaticy) {
        //小于默认容量的一律按默认容量处理
        capaticy = (capaticy <= DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capaticy;
        elements = new int[capaticy];
    }

    public IntArrayList() {
        //默认是10个容量
        this(DEFAULT_CAPACITY);
    }

    /**
     * 清除所有元素
     */
    public void clear() {
        size = 0;
    }

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

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

    /**
     * 是否包含某个元素
     *
     * @return
     */
    public boolean contains(int element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }

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

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

    /**
     * 添加元素到尾部
     *
     * @param element
     */
    public void add(int element) {
        add(size, element);
    }

    /**
     * 在index位置插入一个元素
     *
     * @param index
     * @param element
     */
    public void add(int index, int element) {
        rangeCheckForAdd(index);
        //扩容
        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 int remove(int index) {
        rangeCheck(index);
        int old = elements[index];
        for (int i = index + 1; i <= size - 1; i++) {
            elements[i - 1] = elements[i];
        }
        size--;
        return old;
    }

    /**
     * 查看元素的索引
     *
     * @param element
     * @return
     */
    public int indexOf(int element) {
        for (int i = 0; i < size; i++) {
            if (elements[i] == element) {
                return i;
            }
        }
        return ELEMENT_NOT_FOUND; //找不到就返回-1
    }

    //抛出异常
    private void outOfBounds(int index) {
        throw new IndexOutOfBoundsException("Index：" + index + ", Size：" + size);
    }

    /**
     * 检查范围
     *
     * @param index
     */
    private void rangeCheck(int index) {
        if (index < 0 || index >= size) {
            outOfBounds(index);
        }
    }

    /**
     * 检查添加到指定位置元素的范围
     *
     * @param index
     */
    private void rangeCheckForAdd(int index) {
        if (index < 0 || index > size) {
            outOfBounds(index);
        }
    }

    /**
     * 扩容
     */
    private void ensureCapacity(int capacity) {
        int oldCapacity = elements.length;
        if (oldCapacity >= capacity) {
            return;
        }
        //扩容到原来容量的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        int[] newElements = new int[newCapacity];
        for (int i = 0; i < size; i++) {
            newElements[i] = elements[i];
        }
        elements = newElements;
        System.out.println(oldCapacity + "扩容为：" + newCapacity);
    }

    /**
     * 打印数组
     *
     * @return
     */
    @Override
    public String toString() {
        //size = 3, [99,88,77]
        StringBuilder string = new StringBuilder();
        string.append("size = ").append(size).append(", [");
        for (int i = 0; i < size; i++) {
            if (i != 0) {
                string.append(", ");
            }
            string.append(elements[i]);
        }
        string.append("]");
        return string.toString();
    }
}

对象数组

Untitled

泛型动态数组完整代码

使用泛型技术可以让动态数组更加通用，可以存放任何数据类型

/**
 * @author xiexu
 * @create 2021-07-12 5:11 下午
 */
public class ArrayList<E> {

    private int size; //元素的数量
    private E[] elements; //所有的元素

    private static final int DEFAULT_CAPACITY = 10; //默认容量
    private static final int ELEMENT_NOT_FOUND = -1;

    public ArrayList(int capaticy) {
        //小于默认容量的一律按默认容量处理
        capaticy = (capaticy < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capaticy;
        elements = (E[]) new Object[capaticy];
    }

    public ArrayList() {
        //默认是10个容量
        this(DEFAULT_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 isEmpty() {
        return size == 0;
    }

    /**
     * 是否包含某个元素
     *
     * @return
     */
    public boolean contains(E element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }

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

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

    /**
     * 添加元素到尾部
     *
     * @param element
     */
    public void add(E element) {
        add(size, element);
    }

    /**
     * 在index位置插入一个元素
     *
     * @param index
     * @param element
     */
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        //扩容
        ensureCapacity(size + 1);
        for (int i = size; i > index; i--) {
            elements[i + 1] = elements[i];
        }
        elements[index] = element;
        size++;
    }

    /**
     * 删除index位置的元素
     *
     * @param index
     * @return 返回删掉的元素
     */
    public E remove(int index) {
        rangeCheck(index);
        E old = elements[index];
        for (int i = index + 1; i < size; i++) {
            elements[i - 1] = elements[i];
        }
        elements[--size] = null;
        return old;
    }

    /**
     * 查看元素的索引
     *
     * @param element
     * @return
     */
    public int indexOf(E element) {
        //null值的判断
        if (element == null) { //如果当前元素是null
            for (int i = 0; i < size; i++) {
                if (elements[i] == null) {
                    return i;
                }
            }
        } else { //如果当前元素不是null
            for (int i = 0; i < size; i++) {
                if (element.equals(elements[i])) {
                    return i;
                }
            }
        }
        return ELEMENT_NOT_FOUND; //找不到就返回-1
    }

    //抛出异常
    private void outOfBounds(int index) {
        throw new IndexOutOfBoundsException("Index：" + index + ", Size：" + size);
    }

    /**
     * 检查范围
     *
     * @param index
     */
    private void rangeCheck(int index) {
        if (index < 0 || index >= size) {
            outOfBounds(index);
        }
    }

    /**
     * 检查添加到指定位置元素的范围
     *
     * @param index
     */
    private void rangeCheckForAdd(int index) {
        if (index < 0 || index > size) {
            outOfBounds(index);
        }
    }

    /**
     * 扩容
     */
    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);
    }

    /**
     * 打印数组
     *
     * @return
     */
    @Override
    public String toString() {
        //size = 3, [99,88,77]
        StringBuilder string = new StringBuilder();
        string.append("size = ").append(size).append(", [");
        for (int i = 0; i < size; i++) {
            if (i != 0) {
                string.append(", ");
            }
            string.append(elements[i]);
        }
        string.append("]");
        return string.toString();
    }
}

Person类

/**
 * @author xiexu
 * @create 2021-07-12 9:42 下午
 */
public class Person {

    private int age;
    private String name;

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (obj instanceof Person) {
            Person person = (Person) obj;
            return this.age == person.age;
        }
        return false;
    }

}

null值的处理

/**
 * 查看元素的索引
 *
 * @param element
 * @return
 */
public int indexOf(E element) {
    //null值的判断
    if (element == null) {
        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; //找不到就返回-1
}

动态缩容操作的动态数组完整代码

/**
 * 有动态缩容操作
 *
 * @author xiexu
 * @create 2021-07-12 5:11 下午
 */
public class ArrayList2<E> extends AbstractList<E> {

    private E[] elements; //所有的元素

    private static final int DEFAULT_CAPACITY = 10;

    public ArrayList2(int capaticy) {
        //小于默认容量的一律按默认容量处理
        capaticy = (capaticy < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capaticy;
        elements = (E[]) new Object[capaticy];
    }

    public ArrayList2() {
        //默认是10个容量
        this(DEFAULT_CAPACITY);
    }

    /**
     * 清除所有元素
     */
    public void clear() {
        for (int i = 0; i < size; i++) {
            elements[i] = null;
        }
        size = 0;
        if (elements != null && elements.length > DEFAULT_CAPACITY) {
            elements = (E[]) new Object[DEFAULT_CAPACITY];
        }
    }

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

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

    /**
     * 是否包含某个元素
     *
     * @return
     */
    public boolean contains(E element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }

    /**
     * 获取index位置的元素
     *
     * @param index
     * @return
     */
    public E get(int index) { // O(1)
        rangeCheck(index);
        // index * 4 + 数组的首地址
        return elements[index];
    }

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

    /**
     * 添加元素到尾部
     *
     * @param element
     */
    public void add(E element) { //O(1)
        add(size, element);
    }

    /**
     * 在index位置插入一个元素
     *
     * @param index
     * @param element
     */
    public void add(int index, E element) {
        /**
         * 最好：O(1)
         * 最坏：O(n)
         * 平均：O(n)
         */
        rangeCheckForAdd(index);
        //扩容
        ensureCapacity(size + 1);
        for (int i = size; i > index; i--) {
            elements[i] = elements[i - 1];
        }
        elements[index] = element;
        size++;
    }

    /**
     * 删除index位置的元素
     *
     * @param index
     * @return 返回删掉的元素
     */
    public E remove(int index) {
        /**
         * 最好：O(1)
         * 最坏：O(n)
         * 平均：O(n)
         */
        rangeCheck(index);
        E old = elements[index];
        for (int i = index + 1; i < size; i++) {
            elements[i - 1] = elements[i];
        }
        elements[--size] = null;
        trim();
        return old;
    }

    /**
     * 查看元素的索引
     *
     * @param element
     * @return
     */
    public int indexOf(E element) {
        //null值的判断
        if (element == null) {
            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; //找不到就返回-1
    }

    /**
     * 扩容
     */
    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 oldCapacity = elements.length;
        int newCapacity = oldCapacity >> 1;
        if (size >= (newCapacity) || oldCapacity <= DEFAULT_CAPACITY) {
            return;
        }
        //剩余空间还有很多
        E[] newElements = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newElements[i] = elements[i];
        }
        elements = newElements;

        System.out.println(oldCapacity + "缩容为：" + newCapacity);
    }

    /**
     * 打印数组
     *
     * @return
     */
    @Override
    public String toString() {
        //size = 3, [99,88,77]
        StringBuilder string = new StringBuilder();
        string.append("size = ").append(size).append(", [");
        for (int i = 0; i < size; i++) {
            if (i != 0) {
                string.append(", ");
            }
            string.append(elements[i]);
        }
        string.append("]");
        return string.toString();
    }
}
猿小羽
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
动态数组的简单应用
Jormungand_V的博客
04-19 278
文章目录题目注意代码输出结果 题目 连接两个字符串字面常量，将结果保存在一个动态分配的char数组中。重写，连接两个标准库string对象。 注意 使用头文件cstring的strcpy拷贝字符串、strcat连接字符串。注意释放动态数组。 代码 #include <iostream> #include <string> #include <cstring> using namespace std; int main(int argc, char const *arg
C++第6章数组.ppt
11-13
"C++第6章数组" 在C++语言中，数组是一种非常重要的数据结构。数组是一种集合，集合中每个元素的类型相同，数组的每个元素都可以通过数组名和下标来访问。下标是从0开始的整数，例如：a[0]、a[1]、a[2]等。 一维...
C语言中动态数组的作用,C语言中动态数组的实现
weixin_31951319的博客
05-16 95
C语言中动态数组的实现在大型程序设计中,当程序中间数据量大需(本文共3页)阅读全文>>在许多程序设计中都要用到多维数组,如果数组每一维的大小都已知,则在变量说明中定义即可,否则,通常的方...(本文共2页)阅读全文>>在应用中,特别是在大型数值计算中,经常会遇到各种矩阵运算。在程序中用数组可以存储这些矩阵数据。但如果无法预先知...(本文共3页)阅读全文>>随着...
C语言中动态数组的作用,C语言实现动态数组
weixin_29416629的博客
05-16 540
前言在纯C语言编程中，数组的创建必须是固定的大小，因为C语言本身没有提供动态数组这种数据结构，这是一个让习惯了使用高级语言编程的人转做C开发面临的一个很头疼的问题，本篇文章就将介绍如何使用纯C语言编程实现一个对象来作为动态数组。阅读本篇文章前，作者假设读者已经对C语言的基础概念有了一定了解，比如知道什么叫数组，知道C语言的基础语法等。如果读者还对C语言一无所知，请先对C语言做一个了解和入门级的学习...
add(int index, E element) 在列表的指定位置插入元素
博客
09-22 1943
void add(int index, E element) 在列表的指定位置插入指定元素（可选操作）。将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（在其索引中加 1）。参数： index - 要在其中插入指定元素处的索引 element - 要插入的元素 抛出： UnsupportedOperationException - 如果列表不支持 add 操作 ClassCas
ArrayList的add(int index,E element)插入元素问题
Java学习之旅
11-24 529
在此列表中的指定位置插入指定元素（可选操作）。移动当前位于该位置的元素（如果有）和权利的任何后续元素（在其索引）将此列表中指定位置的元素替换为指定元素（可选操作）。
Java课件第二章补充数组.ppt
09-28
虽然第二种方式是合法的，但通常不推荐使用，因为它可能会引起混淆。 2.2 初始化数组 声明数组后，需要通过`new`关键字分配内存空间并指定数组长度。数组元素可以同时初始化或稍后赋值。初始化数组的例子如下： ``...
c语言学习-第七章-数组完整.pptx
11-14
"C语言学习-第七章-数组完整" 本章主要介绍了数组的概念、定义、使用以及查找算法。下面是详细的知识点： 1. 数组的概念 数组是一种数据结构，由多个相同类型的元素组成，每个元素可以通过下标来访问。数组可以是...
第6章_数组2
09-07
第6章_数组2掌握一维、二维数组的定义和引用方法、存储结构和初始化方法。
第六章利用数组处理批量数据2022优秀文档.ppt
12-02
题目中的第二个问题涉及到数组的引用，当`i=10`时，`a[a[i]]`实际上是指`a[10]`，根据给定的数组初始化，其值为9。 二维数组可以看作是一维数组的数组，每个元素都是一个一维数组。定义二维数组的一般形式为`类型符...
list集合 add(int index, E element) 方法的妙用
weixin_43558205的博客
03-04 1954
list集合 add(int index, E element) 方法的妙用 方法解释和妙用技巧 add(int index, E element) 将指定的元素插入此列表中的指定位置（可选操作）。 将当前在该位置的元素（如果有）和任何后续元素右移（将其索引添加一个）。 参数： index-要插入指定元素的索引 element–要插入的元素 当你插入的元素的位置已经有元素的话，会将此位置已经存在的和后面的全部往后移动 如果你需要将数据每次插入到最前面，那么就可以add（0，element）； 算法题举例
类加载器&反射&模块化
HYJ940228的博客
08-15 289
1.类加载器 1.1类加载【理解】 类加载的描述 当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接，类的初始化这三个步骤来对类进行初始化。如果不出现意外情况，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载或者类初始化 类的加载 就是指将class文件读入内存，并为之创建一个 java.lang.Class 对象 任何类被使用时，系统都会为...
Java中listElem_Java List add(int index, E element)用法及代码示例
weixin_39723655的博客
02-25 433
Java中List接口的add(int index，E ele)方法用于将指定元素插入当前列表中的给定索引。用法:public void add(int index, E element)参数：此方法接受两个参数，如上面的语法所示：index：此参数指定要在其中插入给定元素的索引。element：此参数指定要插入列表中的元素。返回值：该函数的返回类型为void，并且不返回任何内容。异常：Unsup...
ArrayList的add(int index,E element)和set(int index, E element)插入元素问题
最新发布
zpf1813763637的博客
01-30 574
1，注意：上面两个方法都不能在集合下标没有赋值的情况下操作该下标，否则会报错2，add(index,value) 插入，长度+1：会在对应下标下插入数据。之前的index索引及之前的数据都会后移。集合长度+1: list.size() + 1。3，set(index,value) 覆盖，长度不变：会在对应下标下覆盖数据。之前的index索引位置的值被新值覆盖，后面的数据不变。上面两个方法都不能在集合下标没有赋值的情况下操作该下标，否则会报错。
java.util.ArrayList
weixin_30603633的博客
12-16 196
/* * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * ...
ArrayList原理解析之add(int index, E element)方法分析（jdk1.8）
loveking6的博客
06-12 1049
1.ArrayList的add(index,element)方法 ArrayList<Object> list = new ArrayList<>(); list.add("张三"); list.add("李四"); list.add("王五"); list.add(1,"zhaoliu"); 2.在add方法中，先判断下标是否合法，合法不做处理，不合法抛出异常 public void add(int in
ArrayList.add(int index, E element)
KingKazma 的专栏
02-23 1494
之前一直不知道 Java 的 ArrayList 有 add(int index, E element)， Inserts the specified element at the specified position in this list. 这个方法。 如果使用 add(0, element)， 就相当于把元素一直插入到头。 就免去了reverse的过程。 之前不知道可以这样，
List.add(int index,E element)
wt_better的博客
05-10 1185
/** * Inserts the specified element at the specified position in this list * (optional operation). Shifts the element currently at that position * (if any) and any subsequent elements to the ri...
C语言第07章-一维数组和二维数组1完整.pptx
11-14
二维数组中的元素可以使用两个下标进行访问，第一个下标表示行号，第二个下标表示列号。行号和列号都是从0开始，依次递增。例如，要访问二维数组matrix中的第2行第3列的元素，可以使用`matrix[1][2]`来表示。 2、二...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猿小羽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值