ArrayList 底层源码详解

最新推荐文章于 2024-04-24 22:51:49 发布
最新推荐文章于 2024-04-24 22:51:49 发布
阅读量672 收藏 5
点赞数 4
分类专栏： 集合 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y13672651519/article/details/107733595
版权

目录

ArrayList概述

      我们先复习一下ArrayList：它封装了一系列操作，如增删改查，对比使用传统的数组方便了很多，因为java代码已经替我们写好了，我们直接用即可。
      但是，面对即将走向工作岗位的你们，单单知道如何使用远远不够，首先面试官就是一个槛，大部分面试都会问集合的实现原理，这也是大部分面试者的薄弱点。
      我们今天就来详细了解一下ArrayList的实现原理

扩容技术

      ArrayList的最大优点其一就是实现了数组长度可变，因为其底层实现还是一个数组，但不局限于固定长度的普通数组了，所以最重要的就是ArrayList的数组扩容技术。其实原理也很简单，ArrayList就是新创建了一个长度大一点的数组，并将原数组复制到新数组中，仅此而已。

add()方法源码

      既然想知道数组是如何扩容的，所以直接看add()方法即可，我们上源码：

public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}

      add()方法接收了一个E类型的参数e（想添加的元素），其实就是任意类型，进入方法体后我们发现，它其实就是把传进来的参数e赋值给elementData[]的索引size上，我们先来看看elementData是什么：

transient Object[] elementData;

      elementData就是一个存放Object类型的数组，并且定义为transient，是不可被序列化和反序列化的。既然它定义了elementData[]数组，那必然会对其初始化，我们查看ArrayList的构造方法：

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

      到这里我们就蒙圈了，DEFAULTCAPACITY_EMPTY_ELEMENTDATA这一长串英文是什么意思呢？
      我们查看它的定义：

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

      它实际上是一个空数组，是初始化了的。当然这里只说了ArrayList的无参构造方法，有参构造方法与这是不同的，这里暂且先放一放，后续会提到。
那么此无参构造方法作用就是让elementData数组指向DEFAULTCAPACITY_EMPTY_ELEMENTDATA这个空数组，所以此时的elementData也是一个空数组。
      了解完elementData之后，继续查看add()方法，执行elementData[size++] = e时，因为elementData数组长度是0，必然此元素e是添加不进去的，所以执行赋值之前需要对数组进行扩容，所以就有了ensureCapacityInternal(size + 1)，我们继续跟进：

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

第一次add添加元素

      假设我们现在是第一次添加元素，此时的size+1就是1，因此minCapacity = 1，minCapacity可以理解为最小容量。该方法先调用了calculateCapacity(elementData, minCapacity)，我们继续跟进：

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

      这里先做了一个判断：elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA，因为之前的无参构造方法就是将DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋值给elementData的，所以进入if语句，返回DEFAULT_CAPACITY与minCapacity中的较大者，我们看看DEFAULT_CAPACITY：

private static final int DEFAULT_CAPACITY = 10;

      好！这里我们知道了一个最重要的点：默认数组容量是10，注意这点很关键，先记住。继续往下看，因为minCapacity = 1，所以这里返回的是10。走出方法，继续查看：

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

      调用了ensureExplicitCapacity(10)：

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

      modCount这个变量先不用管，因为它涉及到迭代器，我们后面仍会详细说明。
      这里的minCapacity参数是10，进行minCapacity与数组长度的大小判断，10 - 0 > 0，因此满足条件，执行grow(10)方法：

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

这里涉及了很多判断，我们一个一个来看：

  • int oldCapacity = elementData.length;//int oldCapacity = 0;
  • int newCapacity = oldCapacity + (oldCapacity >> 1);//int newCapacity = 0 + 0/2 = 0
    注意这里，每次扩容的大小就是这一段代码的体现，即扩容至原数组长度的1.5倍。
  • if(newCapacity - minCapacitry = 0 - 10 = -10 < 0)
  • newCapacity = 10;//新数组容量为10
if (newCapacity - MAX_ARRAY_SIZE > 0)
    newCapacity = hugeCapacity(minCapacity);

      这一段较为复杂，我们先看MAX_ARRAY_SIZE：

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

      我们再来看Integer.MAX_VALUE的值是多少：

public static final int   MAX_VALUE = 0x7fffffff;

      0x7fffffff(16进制) = 2147483647(10进制)，Integer.MAX_VALUE - 8 = 2147483639，所以说这一个判断(newCapacity - MAX_ARRAY_SIZE > 0)遇到的情况很少，意思就是如果新数组容量比2147483639还要大，则执行hugeCapacity()方法：

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

      当然这里不是我们研究的重点，既然讲到这，我们也不妨提一提。此方法判断了最小容量minCapacity是否比MAX_ARRAY_SIZE大，如果是则使用MAX_VALUE作为数组的容量，如果不是则使用MAX_ARRAY_SIZE作为数组的容量。
      经过一系列比较后，最终算得newCapacity = 10，即新数组容量，这时总算开始进行数组复制了，也就是grow()方法的最后一行代码：

elementData = Arrays.copyOf(elementData, newCapacity);

      创建了一个新的容量为10数组，并覆盖原数组elementData，兜了这么一大圈总算完成数组的扩容了，这回我们再回到add()方法：

public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}

      ensureCapacityInternal()方法完成数组扩容后，将添加的元素e加入进数组elementData中，到此整个add()方法执行完成。

第二次add添加元素

      那么当第二次进行add操作会是怎么个执行流程呢？我们继续分析：

public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}

      这时候size = 1，以为前面一个元素在进入集合后，size进行了自增++操作。因此传入的size + 1 = 2，进入ensureCapacityInternal()方法

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++;
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

      注意，这个时候calculateCapacity方法计算容量，直接返回minCapacity = 2了。
      因为此时的elementData数组不是空数组了，并不指向DEFAULTCAPACITY_EMPTY_ELEMENTDATA，所以说该判断语句只会在第一次添加元素时才会执行，并且只执行一次，以后再不会执行，而是直接进行数组扩容了。

//此方法只会执行一次，并且只在第一次添加元素时执行
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
    return Math.max(DEFAULT_CAPACITY, minCapacity);
}

      返回minCapacity值为2后，调用ensureExplicitCapacity(2)，进行最小容量minCapacity与数组长度大小比较，minCapacity = 2，elementData.length = 10，因此不进行数组扩容，当然添加第10个元素时也不会扩容，直到第11个。

add添加时大于原容量的情况

      那么在添加第11个元素时会发生什么呢？我们继续分析：

public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}

      调用ensureCapacityInternal(11)：

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++;
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

      calculateCapacity(elementData, 11)方法返回11，然后进入ensureExplicitCapacity(11)方法进行判断：minCapacity = 11 > elementData.length = 10，所以需要进入grow(11)方法进行扩容：

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

逐个计算分析：

  • int oldCapacity = elementData.length = 10;
  • int newCapacity = oldCapacity + (oldCapacity >> 1) = 10 + 10/2 = 15;
  • if (newCapacity - minCapacity < 0) 不进入
  • if (newCapacity - MAX_ARRAY_SIZE > 0) 亦不进入
  • 直接进行Arrays.copyOf(elementData, 15);//复制并扩容

      到此，我们基本上了解add方法的执行流程，需要注意的点，每次进行数组扩容时，均扩容至原来的1.5倍，如果说一开始创建ArrayList时没有指定容量大小，默认是10，因此进行一次扩容后为15，第二次为22…33…51以此类推。

有参构建与无参构建

      说完这些，我们继续分析如果在创建ArrayList时指定容量大小，又会是怎样的情况，我们先看带参的构造方法：

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时，EMPTY_ELEMENTDATA会赋值给elementData，紧接着我们继续看什么是EMPTY_ELEMENTDATA：

private static final Object[] EMPTY_ELEMENTDATA = {};

      咦，这个不也是一个空的Object类型数组吗，跟之前的：

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

      DEFAULTCAPACITY_EMPTY_ELEMENTDATA空数组有区别吗？答案肯定是有区别的。
      我们不妨回顾一下，之前除了在初始化DEFAULTCAPACITY_EMPTY_ELEMENTDATA数组时出现，还有在哪出现过吗？答案在下面，就是计算容量的方法中用到了：

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

      这里它判断了当前的elementData数组是否为DEFAULTCAPACITY_EMPTY_ELEMENTDATA，是的话则将DEFAULT_CAPACITY(10)和minCapacity中的较大值返回，否则直接返回minCapacity。
      也就是说，如果使用的是无参构造方法创建的ArrayList，则elementData值即为DEFAULTCAPACITY_EMPTY_ELEMENTDATA，所以他才会默认指定大小为10；如果使用的是指定容量的有参构造方法创建的ArrayList，假设定义的容量参数是0，则elementData值为EMPTY_ELEMENTDATA 。
      所以使用有参构造方法创建的ArrayList（这里假设参数是0，不是0的情况一会再分析），是不会默认指定大小的，只能是添加一个，检查一个，判断是否满足容量，经过分析可以得知其容量的变化0->1->2->3->4->6->9->13以此类推。
当参数不为0且大于0的情况下：

if (initialCapacity > 0) {
    this.elementData = new Object[initialCapacity];
}

      这写得已经非常明确了，直接创建一个Object型数组，并且长度为initialCapacity，即我们传递来的参数。
      使用有参构造方法创建，添加元素时，不会设置默认数组初始大小。对此，我们已经对两个构造方法有初步的了解了，为了更深刻地理解，我们再举个例子：

ArrayList<Integer> array1 = new ArrayList<Integer>();
ArrayList<Integer> array2 = new ArrayList<Integer>(0);

      这里创建了两个ArrayList对象，分别使用无参构建和有参构建，且有参构建情况下参数指定了0。
      现在我们分别对两者进行add操作：

array1.add(1);
array2.add(1);

有参构建与无参构建的区别：

  • 使用无参构建时，因为当前elementData空数组与DEFAULTCAPACITY_EMPTY_ELEMENTDATA数组是相等的，所以返回的最小容量minCapacity是默认值10，因此数组扩容至默认长度10，当前数组elementData.length
    = 10；
  • 使用有参构建时，因为当前的elementData空数组是EMPTY_ELEMENTDATA
    ，而不是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，因此计算容量的函数返回值是minCapacity =
    1，因此数组扩容至长度1，当前数组elementData.length = 1。

      这也是这两者比较直观的区别了。

modCount、迭代器解析

      我们在讲解add()时，其中的一个函数是不是使用了modCount这个变量，我们看源码：

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

      这个modCount究竟是什么？这里我明确告诉大家，他与迭代器遍历密切相关，我们直接看迭代器Iterator源码：

public Iterator<E> iterator() {
    return new Itr();
}
private class Itr implements Iterator<E> {
    int expectedModCount = modCount;
    public E next() {
        checkForComodification();
    }
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();//抛出并发修改异常
    }
}

      这里我们就能看到modCount了，他把值赋给了expectedModCount，用处是什么？我们发现每当调用迭代器的next()方法取数据时，会先调用checkForComodification()来检测，检测什么？该方法内判断了modCount与expectedModCount值是否相等，如果不相等则抛出并发修改异常ConcurrentModificationException，看到这里，再回想一下刚刚什么时候对modCount进行了修改，如果修改了，又会造成什么后果？

      我们首先举一个例子：遍历一个长度为3的ArrayList，因其调用了3次add方法，所以modCount = 3，进入iterator()方法后将modCount赋给expectedModCount，此时两者大小相等。如果在迭代中途add添加了元素，则modCount = 4，但此时expectedModCount不等于4，就会抛出异常。

      我们可以这样理解：你虽然向集合中添加了元素，但迭代器不知道，所以如果想在遍历过程中add()添加、remove()删除元素，只能使用for循环遍历。但修改元素时不会受影响，因为它没有对modCount进行修改。

  • 总结：
  • 集合迭代器只能遍历集合，如果在迭代过程中对集合进行add增加、remove删除元素，则会抛出ConcurrentModificationException异常（并发修改异常），不仅ArrayList如此，HashMap等等也如此。
Sadness°
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Java ArrayList源码剖析
12-22
总体介绍 　　ArrayList实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量（capacity），表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添加元素时，如果容量不足，容器会自动增大底层数组的大小。前面已经提过，Java泛型只是编译器提供的语法糖，所以这里的数组是一个Object数组，以便能够容纳任何类型的对象。 　　size()， isEmpty()， get()， set()方法均能在常数时间内完成，add
深入Java集合ArrayList的源码解析
12-21
现在由大恶人付有杰来从增删改查几个角度轻度解析ArrayList的源码 首先ArrayList的底层数据结构非常简单，就是一个数组。 从源码第115行我们可以得出信息，他的默认数组长度是10。 /** * Default initial capacity. */ private static final int DEFAULT_CAPACITY = 10; 那么我们经常调用的size方法是什么呢？ 源码第281行，142行 /** * Returns the number of elements in this list. *返回链表中元素
ArrayList底层结构和源码分析
weixin_53616401的博客
04-24 493
1.permits all elements, including null，ArrayList 可以加入null，并且多个2.ArrayList是由数组来实现数据存储的3.ArrayList 基本等同于Vector，除了ArrayList是线程不安全(执行效率高)看源码.在多线程情况下，不建议使用ArrayList。
Java常用集合之ArrayList（深入源码）
m0_62609939的博客
03-18 996
Java常用集合之ArrayList（深入源码）
Java-ArrayList 源码、缩容、扩容机制分析
ALONG的博客
02-26 429
ArrayList 的底层是数组队列，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。ArrayList继承于 AbstractList ，实现了 List, RandomAccess, Cloneable, java.io.Serializable 这些接口。是一个标志接口，表明实现这个这个接口的 List 集合是支持快速随机访问的。
【Java 基础】ArrayList 的底层原理和源码分析
激流丶的博客
06-07 1126
ArrayList 是 Java 中常用的动态数组实现，它的底层是基于数组实现的。当创建一个 ArrayList 对象时，实际上是创建了一个 Object 类型的数组，初始容量为 10。当添加元素时，如果数组已满，ArrayList 会自动扩容，它会创建一个新的数组，并将原数组中的元素复制到新数组中。
集合源码：ArrayList的底层实现
weixin_58210065的博客
03-29 1453
1、ArrayList的概述： ArrayList是List的实现类，存储多个Object对象；特点是：有序、有下标、元素可以重复；下标范围是：0~size()-1；线程不安全，因为底层方法是非同步的 2、ArrayList的实现原理： ArrayList，底层封装了一个数组，利用一个int size()统计数组中元素的个数(应用层：集合中元素的个数)，创建集合对象时，底层数组长度为0，只有当第一次往集合中添加(第一次调用add方法)元素的时候，为数组分配空间，长度默认...
ArrayList 源码
ironmanoOOoo的博客
07-22 1692
集合类中，最基础也是最常用的，大概就是ArrayList了吧。ArrayList的本质，是一个可变长的数组。那有人可能就会问，哎呀这个数组老简单了，有什么好看的啊……但事实上，在面试时，有些人还是对源码的细节说不清楚，从而留下较差的印象。这里，我就带着大家，一点一点地梳理一下，ArrayList的底层源码吧。概览..ArrayList类继承自AbstractList类，且实现了List、RandomAccess、Cloneable和Serializable接口。...
ArrayList底层源码解析
蔚蓝
08-11 329
ArrayList集合实际上就就是一个可变数组，是对List接口的实现。该集合可以存储任何内容元素，包括null值。它实现了List接口中所有的方法，并且提供了一些独有的方法来操作内部存储列表的数组。......
ArrayList底层源码分析
qq_42600094的博客
05-07 1738
下面，我们来对 ArrayList 做一个简单的小结：ArrayList 是基于 [] 数组实现的 List 实现类，支持在数组容量不够时，一般按照 1.5 倍自动扩容。同时，它支持手动扩容、手动缩容。ArrayList 随机访问时间复杂度是 O(1) ，查找指定元素的平均时间复杂度是 O(n)。ArrayList 移除指定位置的元素的最好时间复杂度是 O(1) ，最坏时间复杂度是 O(n) ，平均时间复杂度是 O(n)。最好时间复杂度发生在末尾移除的情况。因为移除头部或者中间的元素要位移。
ArrayList 深入理解底层
12-21
ArrayList 集合源码解读介绍构造方法add方法remove方法总结 介绍 ArrayList Jdk1.8采用的是数组的数据结构，是非线程安全的一个集合 （多线程下数据不安全），本文章主要讲解ArrayList集合添加和集合扩容，其他方法都相对简单，读懂这个后相信你翻翻源码即可读懂其他方法原理，下面讲解源码的可能会有点枯燥，请着重去了解集合添加和扩容的一个流程 构造方法 我们来看源码迅速带过这三个构造方法,为了方便阅读，以下我们将当前集合数组统称为集合 无参构造方法，创建一个空集合 //存放数据的Object数组 transient Object[] elementData;
对ArrayList和LinkedList底层实现原理详解
08-26
今天小编就为大家分享一篇对ArrayList和LinkedList底层实现原理详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Java ArrayList的底层实现方法
08-26
今天小编就为大家分享一篇Java ArrayList的底层实现方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
ArrayList源码分析
01-20
它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable的方法，我们从它的源码中可以清楚的看到 //默认的初始化容量为10 private static final int DEFAULT_CAPACITY = 10; //用于...
ArrayList 源码深度解析
01-20
ArrayList 源码深度解析 一、重新认识ArrayList 什么是ArrayList？ ArrayList是基于数组实现的List类，封装了一个动态再分配的Object数组，以达到可以动态增长和缩减的索引序列。 长啥样？ 如图，是一个长度为6，...
ArrayList源码.zip
03-13
ArrayList源码.zip
string模拟实现
m0_73969414的博客
04-23 1267
c++中string的模拟实现，面试必会知识点
javaweb-SpringBoot基础
kussm_的博客
04-20 1193
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
Java | 冒泡排序算法实现
最新发布
yingzix688的博客
04-24 584
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
Arraylist底层源码分析
02-20
Arraylist的底层源码是一个非常复杂的结构，它主要是由一组Object数组来实现的，并且它还使用一个计数器来跟踪元素的数量，以及一个可调节大小的容量来管理数组的大小。而且它在添加或删除元素时还会调整数组大小，以及当容量不足时会自动扩容。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Sadness°

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

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

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

打赏作者

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

抵扣说明：

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

余额充值