【DS】详解ArrayList及其扩容机制

已于 2023-01-16 16:14:50 修改
阅读量1.1k 收藏 79
点赞数 120
分类专栏： # 数据结构 JavaSE 文章标签： java jvm 数据结构
于 2022-09-22 15:49:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Trong_/article/details/126993188
版权

在这里插入图片描述✨博客主页: XIN-XIANG荣
✨系列专栏:【Java实现数据结构】
✨一句短话: 难在坚持,贵在坚持,成在坚持!

文章目录

一. ArrayList简介

ArrayList类又称动态数组, 同时实现了 Collection 和 List 接口，其内部数据结构由数组实现，因此可对容器内元素实现快速随机访问; 具体的框架图如下:img

【说明】

  1. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
  2. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
  3. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
  4. ArrayList不是线程安全的，在单线程下可以使用
  5. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表
  6. ArrayList中插入或删除一个元素需要移动其他元素，所以不适合在插入和删除操作频繁的场景下使用

二. ArrayList的构造方法

ArrayList有三种构造方法:

  1. 无参的构造方法
  2. 根据传入的数值大小，创建指定长度的数组
  3. 通过传入Collection元素列表进行生成

要学习这些构造方法需要先了解源码中的一些成员变量和常量

// 默认的容量大小（常量）
private static final int DEFAULT_CAPACITY = 10;

// 定义的空数组（final修饰，大小固定为0）
private static final Object[] EMPTY_ELEMENTDATA = {};

// 定义的默认空容量的数组（final修饰，大小固定为0）
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// 定义的不可被序列化的数组，实际存储元素的数组
transient Object[] elementData; 

// 数组中元素的个数
private int size;

1. 无参的构造方法

// 无参的构造方法
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

观察这里给出的无参构造方法, 可以发现当我们直接无参实例化一个ArrayList时, elementData被赋予了默认空容量的数组;

要注意的是, 默认空容量数组是被final修饰的，这个数组是无法进行修改的, 所以此时ArrayList数组是空的、固定长度的，也就是说ArrayList数组此时的容量为0, 元素的个数size为默认值0.

看到这里小伙伴们可能会有一些疑问, 可能大家知道的是实例化ArrayList掉用无参构造方法时不是默认时分配10个空间的容量吗,这里为啥是0呢, 其实这跟ArrayList的扩容机制有关, 在后文中会有解释, 对于无参构造方法默认开辟10个空间这个说法是不准确的.

示例:

实例化一个0容量的顺序表

List list = new ArrayList<>();

2. 根据传入的数值大小, 创建指定长度的数组

// 传容量的构造方法
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}
  • 当initialCapacity > 0时，会在堆上new一个大小为initialCapacity的数组，然后将其引用赋给elementData，此时ArrayList的容量为initialCapacity，元素个数size为默认值0。
  • 当initialCapacity = 0时，elementData被赋予了默认空数组，因为其被final修饰了，所以此时ArrayList的容量为0，元素个数size为默认值0。
  • 当initialCapacity < 0时，会抛出异常。

示例:

实例化一个容量为5的顺序表

List<Integer> list2 = new ArrayList<>(15);

3. 通过传入Collection元素列表进行生成

// 传入Collection元素列表的构造方法
public ArrayList(Collection<? extends E> c) {
    // 将列表转化为对应的数组
    elementData = c.toArray();
    //更新size
    if ((size = elementData.length) != 0) {
        if (elementData.getClass() != Object[].class)
            // 把数组类型变成Object类型
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 赋予空数组
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

传入Collection元素列表后，构造方法首先会将其转化为数组，将其索引赋给elementData;

如果此数组的长度为0，会重新赋予elementData为默认的空数组，此时ArrayList的容量是0，元素个数size为0。

如果此数组的长度大于0，会更新size的大小为其长度，同时将数组的类型转化为Object, 此时ArrayList的容量为传入序列的长度，也就是size的大小，同时元素个数也为size，也就是说，此时ArrayList是中放的就是传进来的元素列表中的元素。

示例:

实例化一个和list2元素一致的顺序表

List<Integer> list2 = new ArrayList<>(15);
List<Integer> list3 = new ArrayList<>(list2);

4. 错误的实例化

观察下面的实例化方式有什么问题, 初学时很容易写出这样的代码;

List list = new ArrayList();

这种实例化方式，没有指定泛型的类型，此时顺序表中可以存放任意类型的元素，这样的代码使用和维护都不太方便。

三. ArrayList的扩容机制

1. 源码分析

上面在介绍无参构造方法时, 强调了当使用无参构造方法时, 顺序表中其实是一个容量为0的空数组, 那么既然容量为0, 又如何往其中添加元素呢, 这里就引出了它的扩容机制了.

首先看源码中的add方法, 假设我们是第一次往顺序表中添加元素, 那么size此时就是0;

img

add方法中首先调用 ensureCapacityInternal 这个方法, 此时这里的参数应当为 size +1 = 1, 此时继续往下看这几个方法;

img

在ensureCapacityInternal方法中又调用了 ensureExplicitCapacity 方法,

ensureExplicitCapacity 方法的参数为 calculateCapacity 方法的返回值,

calculateCapacity 方法中, 如果数组是默认的空数组, 那么返回值为DEFAULT_CAPACITY 和 minCapacity两者中的较大值,

此时的minCapacity为1, 所以返回值当为DEFAULT_CAPACITY, 也就是10, 此时10又作为ensureExplicitCapacity的参数, minCapacity(10) - elementData.length(0) > 0 , 此时就会调用grow方法,

img

grow方法中首先会获取到数组当前的容量oldCapacity, 然后定义一个新的容量值变量newCapacity, 赋值为oldCapacity + (oldCapacity >> 1),

oldCapacity >> 1的功能是将oldCapacity 进行位运算，右移一位，也就是减半，此时newCapacity 为 oldCapacity 的1.5 倍;

后面的第一个if语句是 如果用户需要扩容大小超过原空间的1.5倍，按照用户所需大小扩容

第二个if语句是 如果需要扩容大小超过MAX_ARRAY_SIZE(等于int的最大值 - 8)，那么由于要扩容的空间太大, 需要重新计算容量大小, 调用 hugeCapacity 方法,

img

此时如果minCapacity小于0，抛出OutOfMemoryError异常 , 超过MAX_ARRAY_SIZE返回

Integer.MAX_VALUE (int 类型的最大值) .

返回后最后进行的就是扩容了, 通过copyOf将原来数组的的内容拷贝过来, 并将新数组空间容量设置为newCapacity , 将新数组的引用赋值给 elementData .

通过对于源码的分析此时我们就知道了当第一次add时, 先执行的操作是将数组的容量是由0扩容为10;

    Object[] elementData; // 存放元素的空间
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 默认空间
    private static final int DEFAULT_CAPACITY = 10; // 默认容量大小
    public boolean add(E e) {
        ensureCapacityInternal(size + 1); // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    private void grow(int minCapacity) {
        // 获取旧空间大小
        int oldCapacity = elementData.length;
        // 预计按照1.5倍方式扩容
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 如果用户需要扩容大小 超过 原空间1.5倍，按照用户所需大小扩容
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 如果需要扩容大小超过MAX_ARRAY_SIZE，重新计算容量大小
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 调用copyOf扩容
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    private static int hugeCapacity(int minCapacity) {
        // 如果minCapacity小于0，抛出OutOfMemoryError异常
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }

【总结】

  1. 检测是否真正需要扩容，如果是调用grow准备扩容
  2. 预估需要库容的大小
  • 初步预估按照1.5倍大小扩容
  • 如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容
  • 真正扩容之前检测是否能扩容成功，防止太大导致扩容失败
  1. 使用copyOf进行扩容

2. 关于构造和扩容的总结

[扩容可分为两种情况]：

第一种情况，当ArrayList的容量为0时，此时添加元素的话，需要扩容，三种构造方法创建的ArrayList在扩容时略有不同：

  1. 无参构造，创建ArrayList后容量为0，添加第一个元素后，容量变为10，此后若需要扩容，则正常扩容。
  2. 传容量构造，当参数为0时，创建ArrayList后容量为0，添加第一个元素后，容量为1，此时ArrayList是满的，下次添加元素时需正常扩容。
  3. 传列表构造，当列表为空时，创建ArrayList后容量为0，添加第一个元素后，容量为1，此时ArrayList是满的，下次添加元素时需正常扩容。

第二种情况，当ArrayList的容量大于0，并且ArrayList是满的时，此时添加元素的话，进行正常扩容，每次扩容到原来的1.5倍。

三. ArrayList常见方法

1. add方法

  • 方法介绍
方法名称方法描述
public boolean add(E e)将指定的元素添加到当前列表的尾部
public void add(int index,E element)在当前列表的指定位置添加指定元素
public boolean addAll(Collection<? extends E> c)将指定的列表添加到此列表的尾部
public boolean addAll( int index,Collection<? extends E e> c )在当前列表的指定位置添加指定的列表

[代码演示]:

public static void main(String[] args) {
        List<String> list1  = new ArrayList<>();
        list1.add("张三");
        list1.add("李四");
        list1.add(1,"王五");
        
        List<String> list2= new ArrayList<>();
        list2.add("赵钱");
        list2.add("孙李");
        
        list1.addAll(list2);
        list1.addAll(0, list2);
        System.out.println(list1);
    }

[执行结果]:

img

2. get和set方法

  • 方法介绍
方法名称方法描述
public E get(int index)返回此列表指定索引处的元素
public E set(int index ,E element)用指定的元素替换此列表中指定位置的元素

[代码演示]:

public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("张三");

        list.set(0,"李四");
        String s2=list.get(0);
        System.out.println(list);
    }

[执行结果]:

img

3. contains方法

  • 方法介绍
方法名称方法描述
public boolean contains(Object o)如果此列表包含指定的元素，则返回true
public boolean containsAll(Collection<?> C)如果此列表包含指定的列表，则返回true

[代码演示]:

public static void main(String[] args) {
        List<String> list1  = new ArrayList<>();
        list1.add("张三");
        list1.add("李四");
        list1.add(1,"王五");

        List<String> list2= new ArrayList<>();
        list2.add("赵钱");
        list2.add("孙李");

        System.out.println(list1.contains("李四"));
        System.out.println(list1.containsAll(list2));
    }

[执行结果]:

img

[注意]：

  • contains方法判断元素是否存在是根据元素的equals方法进行比较，若元素中没有重写equals方法，那么contains将比较的是对象的引用 , 这里代码中的String类中是重写了equals方法的。

4. remove方法

  • 方法介绍
方法名称方法描述
public E remove(int index )删除该列表中指定位置的元素
public boolean remove(Object o)删除该列表中第一个指定的元素
public boolean removeAll(Collection<?> c)从此列表中删除指定集合包含的所有元素
public boolean retainAll()collection<?> c除了集合c中的元素全部删除

[代码演示]:

public static void main(String[] args) {
        List<String> list1  = new ArrayList<>();
        list1.add("张三");
        list1.add("李四");
        list1.add("王五");


        String s1=list1.remove(1);
        System.out.println("删除的元素为:"+s1+"\n删除后集合list1:"+list1);

        boolean flag1=list1.remove("王五");
        System.out.println("删除结果为:"+flag1+"\n删除后集合list1:"+list1);

        List<String> list2=new ArrayList<>();
        list2.add("张三");
        list2.add("赵钱");
        list2.add("孙李");
        list2.add("张三");
        boolean flag2=list2.removeAll(list1);
        System.out.println("删除结果为:"+flag2+"\n删除后集合list2:"+list2);

        list2.add("张三");
        boolean flag_3=list2.retainAll(list1);
        System.out.println("删除结果为:"+flag_3+"\n删除后集合list2:"+list2);
    }

[执行结果]:

img

5. toArray方法

  • 方法介绍
方法名称方法描述
public Object[] toArray()将集合转换为数组, 返回一个包含当前列表所有元素的数组
public T[] toArray(T[] a)将集合转换为数组, 返回一个包含当前列表所有元素的数组，指定类型

[代码演示]:

public static void main(String[] args) {

        List<String> list=new ArrayList<>();

        list.add("张三");
        list.add("李四");
        list.add("王五");

        Object[] o1=list.toArray();
        System.out.println(Arrays.toString(o1));

        String[] s1=list.toArray(new String[]{});
        System.out.println(Arrays.toString(s1));
    }

[执行结果]:

img

6. indexOf方法

  • 方法介绍
方法名称方法描述
int indexOf(Object o)从前往后找 , 返回第一个 o 所在下标
int lastIndexOf(Object o)从后往前找 , 返回最后一个 o 的下标

[代码演示]:

public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(2);
        list.add(1);
        list.add(1);
        list.add(2);
        System.out.println(list.indexOf(1));
        System.out.println(list.lastIndexOf(1));
    }

[执行结果]:

img

7. subList方法

  • 方法介绍
方法名称方法描述
List subList(int fromIndex, int toIndex)截取部分 list

[代码演示]:

public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        list1.add("张三");
        list1.add("李四");
        list1.add("王五");
        list1.add("赵钱");
        System.out.println("截取之前的list1:"+list1);

        List<String> list2 = list1.subList(0,2);
        System.out.println("截取到的list2"+list2);
        list1.set(1,"孙李");
        System.out.println("修改lest2"+list2);

        System.out.println("截取之后的list1:"+list1);
    }

[执行结果]:

img

[注意]:

这里的截取并不是获取到列表范围内的元素再拷贝到一个新的列表中 , 也就是说 , 截取所得到的列表和被截取的列表是同一个列表 , 在同一个空间范围内 , 只是指向不同 , 所以上面的代码中修改截取到列表中的元素 , 原来的列表中的内容也会被修改.

img

8. clear方法

  • 方法介绍
方法名称方法描述
void clear()清空顺序表

这个就不做演示了

四. 遍历ArraayList

ArrayList 可以使用四种方式遍历：直接输出, for循环+下标, foreach, 使用迭代器

1. 直接输出

直接输出有一个缺陷 , 它不能修改其中的内容 , 只能一次性全部输出.

public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵钱");
        list.add("孙李");
        System.out.println(list);
    }

[执行结果]:

img

2. for循环+下标/foreach

public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵钱");
        list.add("孙李");
       
        //for循环+下标
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");
        }
        
        //foreach
        for (String s:list) {
            System.out.print(s+" ");
        }
    }

3. 通过迭代器遍历和删除

迭代器是一种设计模式，迭代器可以用于遍历集合，开发人员不必去了解这个集合的底层结构。迭代器封装了数据获取和预处理逻辑，屏蔽了容器的实现细节，无需暴露数据结构内部。在数据量非常庞大时使用迭代器进行数据迭代获取，避免全部取出占用过多的服务器资源，且可以对部分数据进行预加载，提升性能。

下面给出的是Iterator迭代器接口的源码 , Iterator中有三个方法：分别为hasNext() , next() , remove()

package java.util;

import java.util.function.Consumer;

public interface Iterator<E> {
    //如果迭代有更多元素，则返回true
    boolean hasNext();

    //返回迭代中的下一个元素
    //如果没有元素则抛出NoSuchElementException异常
    E next();

    //从底层集合中移除此迭代器已经返回的最后一个元素，只能在next被调用后使用
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    //对每个剩余元素执行给定的操作，直到处理完所有元素或操作引发异常。 
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

集合想要获取一个迭代器可以使用 iterator() 方法返回一个用Iterator接收的对象 , 这个对象所对应的类是ArrayList中的内部类 , 其中重写了Iterator接口中的那些方法。

注意：iterator()方法是java.lang.Iterable接口中的抽象方法 , 被Collection继承; 最终在ArrayList中实现了iterator(); 要使用迭代器, 必须是在实现迭代器接口的前提下.

也可以使用 listIterator() 方法 , 对应的 listIterator 接口其实是继承了Iterator接口.

[代码示例1]:

  • 遍历操作
public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵钱");
        list.add("孙李");

        System.out.println("遍历元素");
        Iterator<String> it = list.listIterator();
        while (it.hasNext()) {
            System.out.print(it.next()+" ");
        }
    }
  • 执行结果

img

[代码示例2]:

  • 删除元素
public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵钱");
        list.add("孙李");

        Iterator<String> it = list.listIterator();
        System.out.println("删除第一个元素");
        it.next();
        it.remove();
        System.out.println(list);
    }
  • 执行结果

img

韵秋梧桐
关注
  • 120
    点赞
  • 踩
  • 79
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 95
    评论
专栏目录
对Java ArrayList的自动扩容机制示例讲解
08-26
对Java ArrayList的自动扩容机制示例讲解 在Java中，ArrayList是最常用的集合类之一，它提供了动态扩容的功能，能够自动地根据添加元素的数量来调整内部数组的大小，以满足元素的存储需求。今天，我们将深入探讨...
ArrayList扩容机制源码解析.md
12-06
本资源根据个人学习和总结，主要介绍Java中ArrayList扩容机制源码的解析，主要包含文字和代码等内容，以源码的形式进行分析，详细介绍了ArrayList扩容机制的整个流程，特此将该资源分享
【DS】详解Java集合中ArrayList的扩容机制
weixin_56952690的博客
02-21 536
【Java集合】本文介绍了ArrayList的概念以及使用方法，还有详细解释了ArrayList的扩容机制。
【DS】PriorityQueue （堆） 详解
Gmerrysong 的博客
08-30 92
当年面试问的最多的那批 Java 集合框架现在问的还多么？ 编程十年（狗头) ， 我把这些集合框架做成盲盒， 无论你多难， 我都想去了解你， 今天来看-----pia~，PriorityQueue，优先级队列，根据元素的优先级进行排序, 可以快速访问和删除具有最高优先级的元素, 由数据结构 堆 实现，具有高效的插入和删除操作。常用于任务调度、事件处理和资源分配等场景。
java基础详解
weixin_56680764的博客
03-09 3026
java基础知识
Java集合详解
weixin_47367099的博客
10-24 333
HashSet 实现 Set 接口，其底层是 HashMap，由于 HashMap 的底层是数组+链表+红黑树，所以 HashSet 的底层就是数组+链表+红黑树，存储时，底层通过 equles（）和 hash（）方法来确定存储位置，所以存入与取出的顺序不一致。要注意的是，HashSet 的底层也是 HashMap，也是以键值对的形式进行存储的，只不过在进行录入时，把 value 值设置为一个常数，所以在 HashSet 中，不能存储相同的值（会进行覆盖）。可以通过整数索引访问元素，并搜索列表中的元素。
JDBC详解
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
03-03 1284
jdbc就是Java语言连接数据库，学习数据库和Java后，再学习jdbc,我们可以清楚如何把前面所学联系一起，本文带你从一个技术的出现到原理到实战，层层递进，让你领会其中的方方面面，并且对以后的框架也有帮助
详解JDBC
m0_61302184的博客
04-09 2578
详解JDBC
【详解栈Stack与队列Queue】
TheMyth142857的博客
05-24 2095
本章主要介绍了栈和队列这两种数据结构，它们属于特殊线性表，通常在学习栈的时候对比学习队列。本文如有不足之处，请广大读者提出宝贵意见！！！谢谢！！！
【DS】3.顺序表&链表万字全总结！
moteandsunlight的博客
10-06 694
顺序表、链表万字全总结！！！
集合详解
qq_39027486的博客
08-16 1534
集合详解集合的诞生集合应该具备以下功能:数组和集合的区别:集合的概述: 集合是一套容器框架 集合的诞生 为什么学习集合? 集合就是容器 容器有 数组 StringBuffer StringBuider 数组的局限性: 1.只能够存储一组相同数据类型的容器 2.数组中只有length属性,没有供我们操作对象的方法 Book[] int[] StringBuffer StringBuider特点:...
Java中Arraylist动态扩容方法详解
08-29
这篇文章将深入探讨ArrayList的动态扩容机制。 首先，ArrayList的初始化可以通过以下三种方式： 1. 不带参数的构造器：`ArrayList()` - 默认创建一个容量为10的内部数组。在JDK 1.6及以前版本，这个默认值是10，但...
Java ArrayList扩容问题实例详解
08-28
"Java ArrayList扩容问题实例详解" Java ArrayList扩容问题实例详解是Java编程语言中一个非常重要的知识点。ArrayList是Java中最常用的集合类之一，它提供了动态数组的功能，可以存储大量的数据。但是，ArrayList在...
Arraylist扩容原理走读.png
08-25
Arraylist扩容原理走读
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 464
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 569
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 683
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1187
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
arraylist的扩容机制
08-30
ArrayList 的扩容机制是在添加元素时，当当前数组的容量不足以容纳新元素时，会触发扩容操作。具体扩容机制如下： 1. 创建一个新的数组，长度为当前数组的 1.5 倍 (初始容量为 10 时，扩容后为 15)。 2. 将当前数组...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

韵秋梧桐

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

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

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

打赏作者

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

抵扣说明：

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

余额充值