JAVA集合框架学习记录

最新推荐文章于 2022-01-15 22:10:32 发布
最新推荐文章于 2022-01-15 22:10:32 发布
阅读量160 收藏
点赞数 1
分类专栏： JAVA基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44073614/article/details/110449568
版权

JAVA集合框架

什么是集合

集合，数组都是对多个数据进行存储操作的结构，简称JAVA容器。
此时的存储是指内存层面的存储，不涉及持久化存储

和数组的区别

  1. 数组长度固定，集合长度不固定
  2. 数组可以存储基本类型和引用类型，集合只能存储引用类型

位置

java.util.*;

一.Collection体系

单列集合，用来存储一个一个对象。

在这里插入图片描述

特点：代表一组任意类型的对象，无序、无下标、不能重复。

创建集合 Collection collection = new ArrayList();

常用方法

  1. 添加元素 collection.add();
    添加的对象重写equals方法
  2. 删除元素

区分list中remove(index)和remove(Object obj)
collection.remove();

collection.clear();

  1. 遍历元素（重点）

    1. 使用增强for（因为无下标）

      for(Object object : collection){ }

    2. 使用迭代器

      迭代器只能使用 迭代器的remove方法，不能使用collection.remove()方法

      //haNext(); 有没有下一个元素
//next(); 获取下一个元素
//remove(); 删除当前元素
Iterator it = collection.iterator();
while(it.hasNext()){
  String object = (String)it.next(); //强转
    //System.out.println(object);
  // 可以使用it.remove(); 进行移除元素
  // collection.remove(); 不能用collection其他方法 会报并发修改异常
}

  2. 判断 collection.contains(); collection.isEmpty();
    判断时会调用obj对象equals（）方法，重写equals方法

1.List 子接口("动态"数组)

特点：有序、有下标、元素可重复

创建集合对象 List list = new ArrayList<>( );

常用方法

  1. 添加元素 list.add( ); 会对基本类型进行自动装箱

    例：list.add(20); 自动将数字20转成包装类

  2. 删除元素 可以用索引 list.remove(0)

    当删除数字与索引矛盾时 对数字强转

    list.remove((Object) 10) 或 list.remove(new Integer(10))

  3. 遍历

    1. 使用for遍历

      for(int i = 0; i < lise.size(); i++){
  sout(list.get(i)); 
}

    2. 使用增强for

      for(Object list: collection){ }

    3. 使用迭代器

      Iterator it = collection.iterator();
while(it.hasNext()){
  String object = (String)it.next(); //强转
  // 可以使用it.remove(); 进行移除元素
  // collection.remove(); 不能用collection其他方法 会报并发修改异常
}

    4. 使用列表迭代器 💡（注意和迭代器区别）

      ListIterator li = list.listIterator();
while(li.hasNext()){
  System.out.println(li.nextIndex() + ":" + li.next()); //从前往后遍历
}

while(li.hasPrevious()){
  System.out.println(li.previousIndex() + ":" + li.previous()); //从后往前遍历
}

  4. 获取 list.indexOf( );

  5. 返回子集合 sublist(x, y); 左闭右开

    List subList = list.subList(1, 3); 返回索引 1、2

List实现类

  • ArrayList 【重点】
  • 作为list的主要实现类
    • 数组结构实现，必须要连续空间，查询快、增删慢
    • jdk1.2版本，运行效率块、线程不安全
    • 底层使用object[] elementdata存储
  • Vector
  • 作为Listd的 古老实现类
    • 数组结构实现，查询快、增删慢
      • jdk1.0版本，运行效率慢，线程安全。
      • 底层使用object[] elementdata存储
  • LinkedList
    • 底层使用双向链表结构存储，无需连续空间，增删快，查询慢
    • jdk1.2版本

ArrayList主要实现类

创建集合 ArrayList arrayList = new ArrayList<>();

  1. 添加元素 arrayList.add(s1);

  2. 删除元素

    通过下标删除：arrayList.remove(0);

    通过元素删除：arrayList.remove(s1);

    想通过 arrayList.remove(new Student("name", 10));删除对象

    这里重写了 equals(this == obj) 方法

    public boolean equals(Object obj){
  //1 判断是不是同一个对象
  if(this == obj){
    return true;
  }
  //2 判断是否为空
  if(obj == null){
    return false;
  }
  //3 判断是否是Student类型
  if(obj instanceof Student){
    Student == (Student)obj;
    //4 比较属性
    if(this.name.equals(s.getName()) && this.age == s.getAge()){
      return true;
    }
  }
  //5 不满足条件返回false
  return false;
}

  3. 遍历元素【重点】

    1. 使用迭代器

      Iterator it = arrayList.iterator();
while(it.hasNext()){
  Student s = (Student)it.next(); //强转
}

    2. 列表迭代器

      ListIterator li = arrayList.listIterator();
while(li.hasNext()){
  Student s = (Student)li.next(); //从前往后遍历
}

while(li.hasPrevious()){
  Student s = (Student)li.previous();//从后往前遍历
}

  4. 判断

    arrayList.contains(); 和 arrayList.isEmpty();

  5. 查找

    arrayList.indexof();

源码分析

DEFAULT_CAPACITY = 10; //默认容量
//注意：如果没有向集合中添加任何元素时，容量0，添加一个后，容量为10
//每次扩容是原来的1.5倍
elementData存放元素的数组
size 实际元素个数

Vector实现类

创建集合 Vector vector = new Vector<>();

增加、删除、判断同上

遍历中枚举器遍历

Enumeration en = vector.elements();
while(en.hasMoreElements()){
  String o = (String)en.nextElement();
  sout(o);
}

LinkedList实现类

创建链表集合LinkedList li = new LinkedList<>();

常用方法与List一致

2.Set 子接口(数据不可重复)

要求：向Set中添加的元素所在类为保证不可重复性，必须重写equals和hashcode方法,以实现对象相等规则。既：“相等的对象必须具备相同的哈希值”
没有额外定义新方法，继承父类Collection中所有方法

特点：无序、无下标、元素不可重复

方法：全部继承自Collection中的方法

增、删、遍历、判断与collection一致

重写hashCode()方法的基本原则：

  • 在程序运行时，同一个对象多次调用hashCode()方法应该返回相同的值。
  • 当两个对象的equals()方法比较返回ture时，这两个对象的hashCode()方法的返回值也应相等。
  • 对象中用作equals()方法比较的属性。都应该用来计算hashCode值。

HashSet主要实现类

线程不安全，可以存储Null值
无序性和不可重复性都是因为底层数据结构的特性所决定的。
无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加。根据hashcode()计算出的哈希值添加.
不可重复性：相同的元素只能添加一个,存储过程决定了不可重复性
存储结构：哈希表（数组+链表+红黑树）

存储过程（重复依据）

  1. 向HashSet中添加元素a，调用元素a所在类中hashCode()方法，再根据哈希函数计算保存的位置，如果位置为空，直接保存，若不为空，进行第二步
  2. 先判断冲突哈希值是否完全相同，如果不同，形成链表存储，如果相同，进行第三步
  3. 调用元素a所在类equals方法，如果equals为true，则认为是重复，添加失败，否则添加成功，形成链表。

特点

  • 基于HashCode计算元素存放位置
    • 利用31这个质数，减少散列冲突
      • 31提高执行效率 31 * i = (i << 5) - i 转为移位操作
    • 当存入元素的哈希码相同时，会调用equals进行确认，如果结果为true，则拒绝后者存入

新建集合 HashSet<String> hashSet = new HashSet<String>();

添加元素 hashSet.add( );

删除元素 hashSet.remove( );

遍历操作

  1. 增强for for( type type : hashSet)

  2. 迭代器 Iterator<String> it = hashSet.iterator( );

判断 hashSet.contains( ); hashSet.isEmpty();

LinkedHashSet实现类

作为HashSet的子类，遍历内部数据时可以按照添加时的顺序遍历
在添加数据的同时，每个数据同时维护了两个引用，记录了前一个数据和后一个数据，数据形成链表.
对于频繁的遍历操作，LinkedHashSet效率高于HashSet
在这里插入图片描述

TreeSet实现类

特点

  • 基于排列顺序实现元素不重复
  • 实现SortedSet接口，对集合元素自动排序
  • 元素对象的类型必须实现Comparable接口，重写compareTo方法，指定排序规则
  • 通过CompareTo方法确定是否为重复元素

存储结构：红黑树
两种排序方式： 自然排序(实现Comparable接口)，定制排序(Comparator接口)

  • 自然排序：自然排序中比较两个对象是否相同的标准为：compareTo返回0，不再是equals().
  • 定制排序：Comparator重写compare方法,TreeSet使用有参构造，定制排序中比较两个对象相同的标准为compare()返回0，不再是equals().
Comparator comparator=new Comparator(){
// 重写compare
@override
public int compare(Person o1, Person o2){
  int n1 = o1.getAge()-o2.getAge();
  int n2 = o1.getName().compareTo(o2.getName());
  return n1 == 0 ? n2 : n1;
	}
};
 TreeSet=new TreeSet(comparator);

集合使用
创建集合 TreeSet<String> treeSet = new TreeSet<>()

添加元素 treeSet.add();

删除元素 treeSet.remove();

遍历 1. 增强for 2. 迭代器

判断 treeSet.contains();

泛型

  • 本质是参数化类型，把类型作为参数传递
  • 常见形式有泛型类、泛型接口、泛型方法
  • 语法 T成为类型占位符，表示一种引用类型，可以写多个逗号隔开
  • 好处
    1. 提高代码重用性 2. 防止类型转换异常，提高代码安全性

泛型类

// 写一个泛型类
public class MyGeneric<T>{
  //使用泛型T
  //1 创建变量
  T t;
  //2 泛型作为方法的参数
  public void show(T t){
    System.out.println(t);
  }
  //3 泛型作为方法的返回值
  public T getT(){
    return t;
  }
}

// 使用泛型类
public class TestGeneric{
  public static void main(String[] args){
    //使用泛型类创建对象
    // 注意： 1. 泛型只能使用引用类型
    //			 2. 不用泛型类型对象之间不能相互赋值
    MyGeneric<String> myGeneric = new MyGeneric<String>();
    myGeneric.t = "hello";
    myGeneric.show("hello world!");
    String string = myGeneric.getT();
    
    MyGeneric<Integer> myGeneric2 = new MyGeneric<Integer>();
    myGeneric2.t = 100;
    myGeneric2.show(200);
    Integer integer = myGeneric2.getT();
    
  }
}

泛型接口

语法：接口名

注意：不能泛型静态常量

泛型方法

语法： 返回值类型

public class MyGenericMethod{
  //泛型方法
  public <T> T show(T t){
    sout("泛型方法" + t);
    return t;
  }
}

//调用
MyGenericMethod myGenericMethod = new MyGenericMethod();
myGenericMethod.show("字符串");// 自动类型为字符串
myGenericMethod.show(200);// integer类型
myGenericMethod.show(3.14);// double类型

泛型集合

概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致

特点：

  • 编译时即可检查，而非运行时抛出异常
  • 访问时，不必类型转换（拆箱）
  • 不同泛型之间应用不能相互赋值，泛型不存在多态

二.Map体系

双列集合，用来存储一对（key,value）一对的数据
在这里插入图片描述

Map接口的特点

  1. 用于存储任意键值对（key - value）
  2. 键：无序、无下标、不允许重复（唯一）–>key所在类重写equals()方法和hashcode()方法（以HashMap为例）
  3. 值：无序、无下标、允许重复–>重写equals()方法
  4. 一个键值对（key - value）构成了一个entry对象

方法：

5. V put(K key, V value) 将对象存到集合中，关联键值
6. Object get(Object key) 根据键获得对应的值
7. keySet<K> 返回所有的Key
8. Collection<V> values() 返回包含所有值的Collection集合
9. Set<Map.Entry<K, V>> 键值匹配的Set集合

Map接口的使用

//创建Map集合
Map<String, String> map = new HashMap<>();
// 1. 添加元素
map.put("cn", "中国");
map.put("uk", "英国");
map.put("cn", "zhongguo"); // 会替换第一个 
// 2. 删除
map.remove("uk");
// 3. 遍历
// 3.1 使用KeySet()
//Set<String> keyset = map.keySet(); // 所有Key的set集合
for(String key : map.keyset){
  sout(key + "---" + map.get(key));
}
// 3.2 使用entrySet()
//Set<Map.Entry<String, String>> entries = map.entrySet();
for(Map.Entry<String, String> entry : map.entries){
  sout(entry.getKey() + "---" + entry.getValue();
}

HashMap(Map的主要实现类)

线程不安全，效率高
可以存储null的key和value
存储结构：

  • （jdk7）哈希表（数组+链表）
  • （jdk8）哈希表（数组+链表+红黑树）

使用key可使hashcode和equals作为重复

源码分析总结：

  1. HashMap刚创建时，table是null，节省空间，当添加第一个元素时，table容量调整为16
  2. 当元素个数大于阈值（16*0.75 = 12）时，会进行扩容，扩容后的大小为原来的两倍，目的是减少调整元素的个数
  3. jdk8底层的数组不是Entry[]而是Node[],实现的Map里的Entry接口
  4. jdk1.8 当每个链表长度 >8 ，并且数组元素个数 ≥64时，会调整成红黑树，目的是提高效率
  5. jdk1.8 当链表长度 <6 时 调整成链表
  6. jdk1.8 以前，链表时头插入，之后为尾插入

LinkedHashMap

HashMap的子类,在原有的HashMap基础上添加了一对指针，指向前一个和后一个元素，对于频繁的遍历操作，此类执行效率高于HashMap

Hashtable(古老实现类)

线程安全，运行效率慢；不允许null作为key或是value

TreeMap

底层使用红黑树
实现了SortedMap接口（是map的子接口），可以对key自动排序
考虑key的自然排序和定制排序，和TreeSet类似

Properties

hashtable的子类，要求key和value都是string，通常用于配置文件的读取

Collections工具类

概念：集合工具类，定义了除了存取以外的集合常用方法

直接二分查找int i = Collections.binarySearch(list, x); 成功返回索引

其他方法 ： copy复制、reverse反转、shuffle打乱、sort排序（元素类型必须实现Comparable）

补充：

// list转成数组
Integer[] arr = list.toArray(new Integer[10]);
sout(arr.length);
sout(Array.toString(arr));

// 数组转成集合
// 此时为受限集合，不能 添加和删除！
String[] name = {"张三","李四","王五"};
List<String> list2 = Arrays.asList(names);

// 把基本类型数组转为集合时，需要修改为包装类
Integer[] nums = {100, 200, 300, 400, 500};
List<Integer> list3 = Arrays.asList(nums);

集合总结

  • 集合的概念：

    对象的容器，和数组类似，定义了对多个对象进行操作的常用方法。

  • List集合：
    有序，有下标，元素可以重复。(ArrayList,LinkedList,Vector)

  • Set集合:
    无序，无下标，元素不可重复。(HashSet,LinkedListHashSet,TreeSet)

  • Map集合:
    存储一对数据，无序，键不可重复，值可重复 。(HashMap,HashTable,TreeMap)

  • Collections:
    集合工具类，定义了除了存取以外的集合常用方法。

CodingPeppa
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java集合4——list实现类之Vector
小仙女的博客
07-20 325
Vector简介 以下源码都是jdk1.7.8.0 Vector 是古老的实现类，继承于AbstractList，实现了List, RandomAccess, Cloneable这些接口。 Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。 在各种list中，最好把ArrayList作为缺省选择。当插入、删除频繁...
JavaSE学习笔记(五)：集合
weixin_46476301的博客
04-17 1066
前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matp...
能够排序的Map实现类TreeMap类
iteye_5722的博客
09-14 321
1 TreeMap类的介绍         Map接口派生了一个SortedMap子接口，SortedMap有一个TreeMap实现类。         TreeMap是基于红黑树对TreeMap中所有key进行排序，从而保证TreeMap中所有key-value对处于有序状态。TreeMap也有两种排序方式： 自然排序：TreeMap的所有key必须实现Comparable接口，而且所...
集合collection常用的方法和深入remove方法和contains方法
weixin_46489622的博客
06-01 410
1. Collection中能存放什么元素? 没有使用“泛型”之前, Collection中可以存储object的所有子类型。 使用了“泛型”之后, Collection中只能存储某个具体的类型。 集合后期我们会学习“泛型”语法。目前先不用管。Collection中什么都能存， 只要是object的子类型就行。( 集合中不能直接存储基本数据类型,也不能存 java对象，只是存储java对象的内存地址。) 2. Collection 中的常用方法 boolean add(0bject e)向集合中添加元素 i
为什么创建集合对象时用List＜String＞ list = new ArrayList＜String＞()而不是用ArrayList＜Object＞ list = new ArrayList＜＞()
毕业势必进大厂的博客
08-02 2103
为什么创建集合对象时用List<String> list = new ArrayList<String>()而不是用ArrayList<Object> list = new ArrayList<>()呢？ 道理很简单，我们知道List是一个接口，ArrayList是一个类，ArrayList继承了List接口并实现了它，那么ArrayList就有很多List中没有定义的方法，如果我么在编程中使用ArrayList<Object> list = n
java集合框架学习总结
赵睿宇的博客
01-15 622
话不多说先上图 Collection
JAVA学习Java集合框架.pptx
最新发布
11-21
JAVA集合框架学习笔记 JAVA集合框架是Java语言中提供的一种数据结构，用于存储和管理大量数据。它提供了多种接口和实现类，例如Collection、List、Map等，帮助开发者更方便地处理数据。 什么是异常？ 在Java中，...
JAVA集合框架学习总结
01-25
本文档为本人学习 java 集合框架期间的学习总结笔记，希望对新学习的朋友有所帮助和参考价值。本人java 开发时间不是太长，可能存在不完善或不对之处，欢迎指正！
集合框架学习笔记
04-02
这篇学习笔记将深入探讨Java集合框架的基础概念、主要类库以及常见应用场景。 首先，Java集合框架分为两种基本类型：List（列表）和Set（集）。List接口代表有序的集合，允许重复元素，如ArrayList和LinkedList；而...
Java集合框架学习笔记
05-21
Java集合框架做深入浅出的分析，有系统总结，以及常见错误等等
详解集合框架和各个实现类的源码分析
weixin_45943192的博客
07-06 153
一 集合框架的概述 1、集合 、数组都是对多个数据进行存储操作的结构，简称java容器 说明：此时的存储，主要是指内存层面的存储，不涉及到持久化的存储 2.1 数组在存储多个数据方面的特点 > 一旦被初始化以后，其长度也就确定了 > 数组一旦定义好，其元素类型也就确定了，我们也就只能操作指定类型的数据了 比如;String[] arr;int [] arr1; 2.1 数组在存储多个数据方面的特点 ...
List常用实现类的对比
zhuyutong202的博客
03-09 223
Array与List的区别 数组：一旦初始化，长度不能改变，不能扩容 List: 相当于动态的数组，不需考虑长度 List的三种实现类：Arraylist, LinkedList, Vector 相同点：都实现了List接口，存储有序的，可重复的数据 不同点： ArrayList：作为List接口主要实现类。线程不安全，效率高；底层使用Object[]数组存储； LinkedList：对于频繁插入和删除操作，使用此类效率比ArrayList高；底层使用双向链表存储； Vector：List接口的古老实现类
解决collection调用removeAll()移除不了不同引用同值对象的问题
tavor的专栏
06-02 6503
问题：两个List都是ArrayList, 其中一个list1是另一个list2的子集，我想从list2中移除list1中的内容，但是使用removeAll方法不好用， 似乎只有两个集合的交集元素持有相同的引用时removeAll才起作用,而list2和list1中是不同的引用，虽然值相同。有没有什么高效的办法让我做到这一点？解决方法：这个问题不是很难，我们仔细分析一下list及其子类Ar
java 集合工具_Java 常用工具-集合
weixin_35822833的博客
02-20 286
1.集合简介什么是集合？简称集，是用来存储多个元素的容器集合和数组的区别1.元素类型集合：引用类型(存储基本类型是自动装箱)数组：基本类型，引用类型2.元素个数集合：不固定，可以任意扩容数组：固定，不能改变容量集合的好处不受容器大小限制，可以随时添加、删除元素，提供大量操作元素的方法(判断、获取)Java的集合体系1.单列集合(Collection)List：ArrayListSet：HashSe...
Java 使用LocalDate获取前n天
qq_44073614的博客
11-23 2912
//获取当前日期 LocalDate now = LocalDate.now(); System.out.println(now); LocalDate tenDaysAgo = now.plusDays(-10); System.out.println(tenDaysAgo); //获取指定日期 System.out.println("测试跨年————————————————"); Local.
Integer和String做对象锁的问题
qq_44073614的博客
10-17 921
在并发编程时，对象锁是无法回避的问题，什么样的对象可以用了做锁呢？就Java语法而言，只要是对象就能作为锁来使用，然而，仍有几点必须遵守： 锁不能为空，即用作锁的对象不能为空，这种错误很容易暴露，一般都能避免； 锁应该是final的，此处并非要求用作锁的对象的引用一定要声明为final，而是指一个对象要用作锁的话，其引用不应该存在被修改指向的可能，否则引用指向变了，对象锁也就变了，锁可能会失效。 如果使用基本数据类型的封装类型，如Integer、Long等对象做锁时， 基于JVM的一些优化，如同Stri
自定义注解 @Retention相关注意事项
qq_44073614的博客
05-07 382
记录原因 isAnnotationPresent() 返回False 解决方案 自定义注解时,如果想通过反射获取注解信息必须加上@Retention(RetentionPolicy.RUNTIME) 声明该注解的存活策略可以保留到运行时 扩展 @Retention 有3个值 @Retention(RetentionPolicy.SOURCE) 仅仅停留在源码,编译时去除 @Retention(RetentionPolicy.RUNTIME)保留到运行时,通过反射可以获取注解信息 只有保留到运行时,调用isA
Junit快速入门
qq_44073614的博客
12-05 361
一、什么是单元测试 单元测试是针对最小的功能单元编写测试代码 Java程序最小的功能单元是方法 单元测试就是针对单个Java方法的测试 二、为什么要使用单元测试 2.1使用main()方法测试的缺点： 只能有一个main()方法 ，不能把测试代码分离； 没有打印出测试结果和期望结果； 需要一种测试框架，帮助我们编写测试。 2.2单元测试的好处： 确保单个方法运行正常； 如果修改了代码，只需要确保其对应的单元测试通过； 测试代码本身就可以作为实例代码； 可以自动
Synchronized同步静态方法和非静态方法总结
qq_44073614的博客
10-18 321
1.Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，俗称“对象锁”。 Java中每个对象都有一个锁，并且是唯一的。假设分配的一个对象空间，里面有多个方法，相当于空间里面有多个小房间，如果我们把所有的小房间都加锁，因为这个对象只有一把钥匙，因此同一时间只能有一个人打开一个小房间，然后用完了还回去，再由JVM 去分配下一个获得钥匙的人。 情况1：同一个对象在两个线程中分别访问该对象的两个同步方法 结果：会产生互斥。 解释：因为锁针对的是对象，当对象调用一个synchronized方法时，
Java集合框架：数组与集合概述及其优缺点
集合框架是Java中用于处理多样化的逻辑关系，存储和操作对象的工具，它们不同于数组的固定大小和特定的存储方式。集合的核心在于其灵活性，支持动态添加、删除和查找元素，而不需要预先知道集合的具体大小。 1. **...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

CodingPeppa

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

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

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

打赏作者

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

抵扣说明：

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

余额充值