Java集合之LinkedList详解

最新推荐文章于 2024-03-25 09:24:42 发布
最新推荐文章于 2024-03-25 09:24:42 发布
阅读量1.4k 收藏 7
点赞数
分类专栏： 《并发编程》专栏 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39939541/article/details/131367198
版权

Java集合之LinkedList

一、LinkedList类的继承关系

LinkedList

1. 基类功能说明

1.1. Iterator：提供了一种方便、安全、高效的遍历方式。

  1. Iterator是一个迭代器接口，它提供了一种安全的遍历集合元素的方法，可以避免在遍历过程中修改集合引起的ConcurrentModificationException异常，同时还可以避免在遍历过程中删除集合元素时出现索引越界等问题。

  2. LinkedList使用Iterator遍历集合时，可以使用hasNext()方法判断是否还有元素，使用next()方法获取下一个元素，使用remove()方法安全地删除当前元素。因此，使用Iterator遍历LinkedList既方便又安全，是一种非常推荐的遍历方式。

  3. 另外，Iterator接口是Java集合框架中的一部分，实现Iterator接口可以使LinkedList更加符合集合框架的统一标准，方便与其他集合类一起使用。

1.2. Collection：为了使ArrayList具有集合的基本特性和操作。

  1. LinkedList是Java中常用的集合类之一，它实现了Collection接口，这是为了使LinkedList具有集合的基本特性和操作，例如添加、删除、遍历等。
  2. 实现Collection接口可以让LinkedList能够和其他Java集合类兼容，可以方便地进行集合之间的转换和使用。同时，实现Collection接口也使得LinkedList能够支持泛型，可以在编译期间进行类型检查，避免了运行时出现类型错误的问题。
  3. 总之，LinkedList实现Collection接口是为了使其具有更多的特性和更好的兼容性。

1.3. Queue: LinkedList是一种队列（Queue）数据结构的实现。

  1. Queue接口定义了一些基本的队列操作，例如添加元素、删除元素、查看队首元素等，LinkedList实现了这些操作，因此可以被视为一种队列数据结构。

1.4. List：为了让其具有列表的特性和更多的操作。

  1. ArrayList实现了List接口，是为了使其具有列表的特性和操作，例如按索引访问元素、插入、删除、替换等。List是Collection接口的子接口，提供了更多针对列表的操作。
  2. 例如按索引操作、排序、子列表等。因此，实现List接口可以让ArrayList具有更多的操作和更好的兼容性，可以和其他实现List接口的Java集合类进行交互和转换。

1.5. AbstractCollection：提供了一些通用的集合操作。

  1. 例如containsAll、removeAll、retainAll等方法，这些方法可以被ArrayList直接继承和使用，从而避免了重复实现这些操作。
  2. 同时，AbstractCollection也提供了一些抽象方法，例如size、iterator、toArray等方法，这些方法需要由具体的集合类去实现，LinkedList也需要实现这些方法以完成自身的功能。

1.6. Deque: 使得LinkedList可以满足更多的使用场景，例如实现双端队列、实现栈等数据结构。

  1. 这使得LinkedList可以满足更多的使用场景，例如实现双端队列、实现栈等数据结构。同时，LinkedList还可以在队首和队尾进行高效的插入和删除操作，因为它的底层实现是双向链表，而双向链表可以在常数时间内进行插入和删除操作。
  2. 因此，LinkedList继承Deque接口的作用在于让LinkedList具备了双端队列的功能，同时也提高了LinkedList的灵活性和可用性。

1.7. AbstractList：为了使其具有列表的抽象特性和操作。

  1. AbstractList是List接口的一个抽象实现，实现了List接口的大部分方法，包括添加、删除、获取元素、遍历等。

  2. LinkedList作为List接口的一个具体实现，需要实现List接口中定义的所有方法。

  3. 通过继承AbstractList抽象类，LinkedList可以重用AbstractList中已经实现的方法，减少重复代码，提高代码的复用性和可维护性。

  4. 另外，AbstractList还提供了一些抽象方法，例如get()、set()、add()、remove()等，这些抽象方法需要LinkedList子类实现，从而使得LinkedList具备列表的基本操作。

  5. AbstractList还提供了一些模板方法，例如addAll()、removeAll()等，这些方法可以通过调用抽象方法实现具体的操作。通过继承AbstractList抽象类，LinkedList可以利用这些模板方法快速实现各种列表操作，提高了开发效率。

  6. 综上所述，LinkedList实现了AbstractList抽象类是为了重用AbstractList中已经实现的方法，提高代码的复用性和可维护性，同时也能够利用AbstractList中提供的模板方法快速实现各种列表操作。

1.8. AbstractSequentialList：可以更方便地实现List接口中的方法，同时也提供了一些保护方法，供LinkedList实现自己特有的方法。

  1. AbstractSequentialList是一个抽象类，它实现了List接口中大部分方法，例如add、remove、get、set等。而这些方法的实现都是基于迭代器（Iterator）进行的，迭代器是用于遍历集合中元素的一个对象。因此，继承AbstractSequentialList可以让LinkedList更容易地实现List接口中的这些方法，只需要实现迭代器即可。

  2. 另外，AbstractSequentialList还提供了一些保护方法（protected method），例如getIterator、getListIterator等，可以供子类使用。LinkedList继承了AbstractSequentialList后，可以使用这些保护方法来实现自己特有的方法。

  3. 总之，LinkedList继承AbstractSequentialList的作用在于可以更方便地实现List接口中的方法，同时也提供了一些保护方法，供LinkedList实现自己特有的方法。

1.9. Cloneable：支持克隆操作。

  1. Cloneable接口是一个标记接口，用于表示实现该接口的对象可以进行克隆操作。

  2. 在LinkedList中，克隆操作可以用于创建一个与原列表相同的新列表，这个新列表与原列表相互独立，对新列表的修改不会影响到原列表。这在某些场景下非常有用，例如需要对一个列表进行操作，但是又需要保留原列表不变的情况下，可以先克隆出一个新列表进行操作。

  3. 需要注意的是，LinkedList实现Cloneable接口只是表示它支持克隆操作，并不代表它的克隆操作一定是完全正确和安全的。在进行克隆操作时，需要注意可能存在的浅拷贝和深拷贝问题，以及可能会影响到对象的不变性和线程安全性问题等。

  4. 因此，在使用LinkedList的克隆操作时，需要仔细考虑其对程序的影响，并进行必要的安全性和正确性检查。

10. Serializable：支持序列化。

  1. 序列化是将对象转换为字节流的过程，可以用于持久化对象、网络传输等操作。实现Serializable接口可以让LinkedList的实例对象被序列化，以便于在需要的时候进行序列化操作。

二、LinkedList的优缺点

1. 优点：

1.1. 高效的插入和删除操作

  1. 由于LinkedList底层实现是双向链表，因此在插入和删除操作方面具有高效性。在链表的任意位置插入或删除一个元素的时间复杂度是O(1)，而在数组中插入或删除元素的时间复杂度是O(n)。

1.2. 不需要预先分配空间

  1. 由于LinkedList是动态的数据结构，因此在使用时不需要预先分配空间，可以根据需要动态地添加或删除元素，使得空间利用率更高。

1.3. 可以作为双端队列使用

  1. 由于LinkedList实现了Deque接口，因此可以在队首和队尾进行高效的插入和删除操作，使得LinkedList可以作为双端队列使用。

2. 缺点：

2.1. 随机访问性能较差

  1. 由于LinkedList底层实现是链表，因此在访问某个元素时需要从头开始遍历整个链表，时间复杂度为O(n)。而在数组中，访问某个元素的时间复杂度为O(1)。

2.2. 占用更多的内存空间

  1. 由于LinkedList需要存储指向下一个元素和上一个元素的指针，因此占用的内存空间相对于数组要更多。

2.3. 不支持随机访问

  1. 由于LinkedList是基于链表实现的，因此不支持随机访问，只能通过遍历整个链表来访问元素。这也使得LinkedList在某些场景下性能较差，例如在对元素进行排序、查找等操作时。

3. 总结

  1. 总之，LinkedList的优点在于高效的插入和删除操作、不需要预先分配空间、可以作为双端队列使用；缺点在于随机访问性能较差、占用更多的内存空间、不支持随机访问。因此，在使用LinkedList时需要根据具体的场景进行选择。

三、LinkedList数据结构

数据结构

四、LinkedList源码分析

1. 基本属性

1.1 size ：节点个数

transient int size = 0;

1.2 first：头结点

transient Node<E> last;

1.3 last：尾结点

transient Node<E> last;

2. 构造方法

public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
  1. 无参构造方法：因为底层是双向链表，所以无需指定初始长度。
  2. 有参构造方法：创建一个包含指定Collection中所有元素的LinkedList对象。
  3. 这两个构造方法的使用场景如下：
    3.1 无参构造方法可以用于创建一个空的LinkedList对象，然后通过add()方法逐个添加元素。
    3.2 带有Collection参数的构造方法可以用于创建一个包含指定元素的LinkedList对象，例如：
List<Integer> list = Arrays.asList(1, 2, 3);
LinkedList<Integer> linkedList = new LinkedList<>(list);
  1. 总之，LinkedList的两个构造方法分别用于创建一个空的LinkedList对象和创建一个包含指定元素的LinkedList对象。通过这两个构造方法，我们可以实现LinkedList的快速创建和初始化。

3. add方法

public boolean add(E e) {
	linkLast(e);
	return true;
}
public void add(int index, E element) {
	checkPositionIndex(index);
	if (index == size)
	    linkLast(element);
	else
	    linkBefore(element, node(index));
}

add(E e) ：调用linkLast方法将当前元素添加到链表尾部。（linkLast见下文）
add(int index, E element)：

  1. 调用checkPositionIndex校验下标是否越界（index >= 0 && index <= size）。
  2. 如果要添加的元素下标位于链表的最后一个，则调用linkLast方法追加到链表尾部。
  3. 否则不是最后一个，调用linkBefore方法将元素插入指定位置。（linkBefore见下文）。

4. set方法

public E set(int index, E element) {
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}
  1. 调用checkPositionIndex校验下标是否越界（index >= 0 && index <= size）
  2. 调用node(index) (见下文)
  3. 获取要插入结点的原值oldVal
  4. 将当前元素设置找到的结点位置
  5. 返回结点的原值（oldVal ）

5. get方法

public E get(int index) {
	 checkElementIndex(index);
	 return node(index).item;
}
public E getFirst() {
	 final Node<E> f = first;
	 if (f == null)
	     throw new NoSuchElementException();
	 return f.item;
}

get(int index)：

  1. 调用checkPositionIndex校验下标是否越界（index >= 0 && index <= size）
  2. 调用node(index) (该方法见下文)
    getFirst()：
  3. 返回链表的头结点

6. remove方法

public boolean remove(Object o) {
	 if (o == null) {
	     for (Node<E> x = first; x != null; x = x.next) {
	         if (x.item == null) {
	             unlink(x);
	             return true;
	         }
	     }
	 } else {
	     for (Node<E> x = first; x != null; x = x.next) {
	         if (o.equals(x.item)) {
	             unlink(x);
	             return true;
	         }
	     }
	 }
 return false;
}
public E remove(int index) {
	 checkElementIndex(index);
	 return unlink(node(index));
}

remove(int index)：

  1. 调用checkPositionIndex校验下标是否越界（index >= 0 && index <= size）
  2. 调用node(index) (见下文)
  3. 调用unlink方法，移除index位置的节点（unlink方见下文）

remove(Object o) ：

  1. 如果 o == null 从链表的第一个结点first开始遍历，寻找结点item属性为null的结点，调用unlink()方法将该节点移除。
  2. 如果 o 不等于 null 从链表的第一个结点first开始遍历，寻找item属性与之相同的为null的结点，调用unlink()方法将该节点移除。

7. clear方法

public void clear() {
    // Clearing all of the links between nodes is "unnecessary", but:
    // - helps a generational GC if the discarded nodes inhabit
    //   more than one generation
    // - is sure to free memory even if there is a reachable Iterator
    for (Node<E> x = first; x != null; ) {
        Node<E> next = x.next;
        x.item = null;
        x.next = null;
        x.prev = null;
        x = next;
    }
    first = last = null;
    size = 0;
    modCount++;
}
  1. 从头结点first开始遍历，将所有属性item、next、prev置为null。
  2. 将头尾结点置为null。
  3. 将size属性设置为0。
  4. 将modCount++，在这个过程中，LinkedList的结构发生了变化，因此modCount需要+1。

8. node(index)方法

Node<E> node(int index) {
 // assert isElementIndex(index);
    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}
  1. 根据下标调用node(index)找到目标结点
  2. 判断当前下标位于链表的左侧还是右侧（size >> 1）
  3. 如果是左侧从first结点开始遍历
  4. 否则从链表的尾部last结点往前遍历，根据prev指针遍历

9. unlink方法

E unlink(Node<E> x) {//移除链表上的x结点
    // assert x != null;
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;

    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}
  1. 分别获取当前结点的ele元素、前驱结点prev、后继结点next
  2. 如果prev等于null,则头结点first指向next,否则将prev的下一个结点指向当前结点的下一个结点。
  3. 如果next等于null,将last指向当前要删除结点的前一个结点，也即prev。否则将next的前驱结点指向要删除的前驱结点prev,同时将当前要删除的结点的next指向为null
  4. 将当前结点的item元素置为null
  5. size元素数量个数-1
  6. modCount+1,因为链表结构发生改变了

10. linkBefore方法

//将元素e插入succ结点的前面
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}
  1. 定义succ的前驱结点pred
  2. 构造一个新的结点newNode pred就是前驱结点、e当前元素、succ做为当前newNode 的下一个结点。
  3. 修改succ结点的前驱结点为newNode
  4. 如果pred == null 说明链表中只有一个结点succ,则将newNode 作为头结点，将first指向newNode
  5. 否则pred 不等于null，修改pred的后续结点指向，将pred.next 指向刚刚构造出来的新结点newNode
  6. 将size+1
  7. 修改modCount

助解图：

linkbefore

11. linkLast方法

void linkLast(E e) { //将当前元素插入链表的尾部
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}
  1. 将变量 l 指向链表的最后一个结点last（暂存）。
  2. 把传进来的元素e,构造一个新的结点newNode。
  3. 将last引用指向newNode。
  4. 如果l == null，说明链表中没有元素，将first指向newNode，做为头结点。
  5. 否则l 不等于null，将 newNode 追加为链表的最后一个元素。
  6. 将链表的size元素数量+1，modCount+1，用来实现快速失败机制。

五、常见遍历方式

LinkedList有以下4种常见的遍历方式：

1、使用for循环遍历：

可以使用for循环和get方法，从头到尾遍历LinkedList中的元素。

for (int i = 0; i < linkedList.size(); i++) {
    E element = linkedList.get(i);
    // 处理当前元素
}

2、使用foreach循环遍历：

可以使用foreach循环，从头到尾遍历LinkedList中的元素。

for (E element : linkedList) {
    // 处理当前元素
}

3、使用Iterator遍历：

可以使用Iterator，从头到尾遍历LinkedList中的元素。

Iterator<E> iterator = linkedList.iterator();
while (iterator.hasNext()) {
    E element = iterator.next();
    // 处理当前元素
}

4、使用ListIterator遍历：

可以使用ListIterator，从头到尾遍历LinkedList中的元素，还可以在遍历时进行添加、删除、修改等操作。

ListIterator<E> listIterator = linkedList.listIterator();
while (listIterator.hasNext()) {
    E element = listIterator.next();
    // 处理当前元素
}
Run，boy
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java基础之LinkedList
qq_45344586的博客
04-09 1401
Java基础之LinkedList
【Java 基础篇】Java LinkedList 详解：数据结构的灵活伙伴
繁依Fanyi的博客
09-11 452
LinkedList是 Java 中的一个双向链表数据结构。它由一系列节点组成，每个节点包含数据元素和指向前一个节点和后一个节点的引用。这种结构使LinkedList在插入和删除操作方面非常高效，因为它不需要像数组一样重新分配内存空间。LinkedList是 Java 中强大的数据结构，它在插入和删除操作方面非常高效。但是，在随机访问元素时性能较差，因此需要谨慎选择使用。希望本篇博客能够帮助您更好地理解和使用LinkedList，并在编写 Java 代码时做出明智的选择。
Java 集合全教程—List
最新发布
Java毕设项目分享
03-25 1077
列表是一个有序的集合（有时称为序列）。列表可能包含重复的元素。位置访问-根据元素在列表中的数字位置来操作元素。这包括get、set、add、addAll和remove等方法。搜索-在列表中搜索指定的对象并返回其数字位置。搜索方法包括indexOf和lastIndexOf。迭代-扩展了Iterator语义，以利用列表的顺序性。listIterator方法提供了这种行为。范围视图-子列表方法对列表执行任意范围操作。Java平台包含两个通用的List实现。
java的linkedlist详解
chenziang1的博客
02-20 3131
先看java之中linkedlist的源码 public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable { transient int size = 0; /** * Pointer to first node. * Inv
Java LinkedList（Java自带链表类和Java实现链表）
weixin_44730746的博客
03-20 1176
Java LinkedList（Java自带链表类和Java实现链表）
Java中LinkList的基本介绍和细节讨论。双向链表的代码和LinkList的源码。LinkList和ArrayList的比较与选择。
m0_72014660的博客
08-25 1273
Java中LinkList的基本介绍和细节讨论。双向链表的代码和LinkList的源码。LinkList和ArrayList的比较与选择。
Java集合框架LinkedList详解及实例
08-30
《Java集合框架LinkedList详解及实例》 在Java编程语言中，集合框架是处理对象集合的重要工具，而LinkedList是这个框架中的一个重要组成部分。LinkedList是一种双端链表，它不仅提供了列表的基本功能，还支持高效的...
java集合 collection-list-LinkedList详解
08-31
总之，`LinkedList`是Java集合框架中一个重要的列表实现，适用于需要高效执行链式操作的场景。理解其工作原理和特性对于优化Java程序的性能至关重要。在实际编程中，开发者应根据具体需求选择合适的集合类型。
详解Java 集合系列（三）—— LinkedList
08-26
Java 集合系列——LinkedList Java 集合系列中的 LinkedList 是一种可以在任何位置进行高效地插入和删除操作的有序序列。它的最基本存储结构是一个节点：每个节点将存储对象，以及前后节点的引用。结构图中，我们...
Java集合框架之Collection接口详解
08-31
Java集合框架是Java编程语言中用于存储和管理对象的核心组件，它位于`java.util`包下，提供了多种数据结构和算法来高效地处理对象。在Java集合框架中，`Collection`接口是所有单值容器的基础接口，而`Map`接口则是...
Java中集合LinkedList的原理与使用方法
08-25
主要给大家介绍了关于Java中集合LinkedList的原理与使用方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Java集合继承体系详解
08-28
Java集合继承体系详解 Java集合继承体系是Java语言中一个非常重要的概念，它提供了一种灵活的方式来存储和处理大量的数据。Java集合继承体系主要分为三个部分：Set、List和Map。 Collection接口是List、Set、和...
Java集合-List接口-LinkedList
baidu_38126306的博客
09-20 1047
Java集合——LinkedList 1. Java LinkedList 特性 LinkedList（链表）底层是用双向链表实现的存储。是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。 链表可分为单向链表和双向链表： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ZNePWKr-1600610375482)(D:\JavaAno\pictures\单向链表&双向链表示例.png)] 与 A
Java中List集合介绍（炒鸡详细呦）
热门推荐
偏偏爱吃梨的博客
11-04 3万+
Java中List集合介绍（炒鸡详细呦） 1，Java集合介绍 作为一个程序猿，Java集合类可以说是我们在工作中运用最多、最频繁的类。相比于数组（Array）来说，集合类的长度可变，更加方便开发。 Java集合就像一个容器，可以存储任何类型的数据，也可以结合泛型来存储具体的类型对象。在程序运行时，Java集合可以动态的进行扩展，随着元素的增加而扩大。在Java中，集合类通常存在于java....
Java基础知识讲解-LinkedList类
编程小鹏的博客
07-21 825
Java基础知识汇总-链表LinkedList
java linkedlist用法_Java linkedList详细介绍及使用示例
weixin_30456719的博客
02-12 1393
①LinkedList简单介绍是一个继承于AbstractSequentialList的双向链表。它可以被当成堆栈、队列或双端队列进行操作。实现了List接口，能对它进行队列操作。实现了Deque接口，能当作双端队列使用。实现了Cloneable接口，覆盖了clone(),能克隆。实现了java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。是非同...
java集合 LinkedList
riant110的博客
03-22 82
一、实现接口 1、Deque Deque:double ended queue,双端队列，允许在两边进行插入和删除元素 Queue：队列，先进先出，在尾部插入元素，在头部删除元素。 boolean add(E e);//在尾部插入元素，当队列满时，抛出异常 boolean offer(E e);//在尾部插入元素，队列满时，返回false E remove();//返回头部元素，并从队列中删除，当队列为空时，会抛出异常 E poll();//返回头部元素，并从队列中删除，当队列为空时，会返回特殊值null
深入理解Java集合之LinkedList
qq_42499816的博客
09-22 316
一、LinkedList概述 1.初识LinkedList LinkedList是基于链表实现的（双向链表） 什么是链表？ 链表原先是C/C++的概念，是一种线性的存储结构，意思是将要存储的数据存在一个存储单元里面，这个存储单元里面除了存放有待存储的数据以外，还存储有其下一个存储单元的地址（下一个存储单元的地址是必要的，有些存储结构还存放有其前一个存储单元的地址），每次查找数据的时候，通过某个存储...
linkedlist详解
03-30
链表是一种数据结构，它由一系列节点组成，每个节点包含一个数据元素和指向下一个节点的指针。链表的特点是可以动态地添加或删除节点，而不需移动其他节点的位置。 链表可以分为单向链表、双向链表和循环链表三种。单向链表每个节点只有一个指针指向下一个节点，双向链表每个节点有两个指针，分别指向前一个节点和后一个节点，循环链表的尾节点指针指向头节点。 链表的优点是可以动态地添加或删除节点，但其缺点是访问节点时需要遍历链表，因此访问效率较慢。 在实现链表时，需要定义节点类，包含数据元素和指向下一个节点的指针。同时还需要定义链表类，包含头节点指针和尾节点指针，以及添加、删除、查找节点等操作方法。在链表的实现中，需要注意处理边界情况和空链表的情况。 链表的应用非常广泛，例如在实现堆栈、队列、哈希表等数据结构时都可以使用链表。在操作系统中，进程控制块也可以使用链表来实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Run，boy

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

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

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

打赏作者

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

抵扣说明：

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

余额充值