【大数据开发必看】Java集合和泛型

最新推荐文章于 2022-12-16 23:38:51 发布
最新推荐文章于 2022-12-16 23:38:51 发布
阅读量149 收藏
点赞数
分类专栏： bigdata 文章标签： 数据库 hadoop spark hdfs java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42397330/article/details/115107886
版权

第一章 集合

1.1 集合概述

  1. 定义：集合是java提供的一种容器，用来存储多个数据。
  2. 数组与集合的区别：
    1. 数组的长度是固定的，集合长度是可变的
    2. 数组中存储的是基本数据类型或者对象，集合存储的都是对象

1.2 集合框架

1.2.1 单列集合（Collection）
  1. 定义：单列集合类的根接口。
  2. 子接口：
    1. List子接口：
      1. 特点：元素有序可重复
      2. 实现类：
        1. ArrayList
        2. LinkedList
        3. Vector
    2. Set子接口:
      1. 特点：元素无序不可重复
      2. 实现类：
        1. TreeSet
        2. HashSet
          1. LinkedHashSet(元素有序)
1.2.2 双列集合（Map）
  1. 实现类：
    1. HashMap类
      1. LinkedHashMap子类
    2. Hashtable类

1.3 Collection集合

1.3.1 Collection接口

  1. 定义：由于它是一个接口，我们无法直接使用，需要间接使用Collection接口的实现类对象来操作集合。

  2. Collection对象创建：Collection接口有很多的实现类，例如ArrayList类。 （多态）

  3. 常用方法：

    public boolean add(E e): 把给定的对象添加到当前集合中
public void clear(): 清空集合中所有的元素
public boolean remove(E e): 把给定的对象在当前集合中删除
public boolean contains(E e): 判断当前集合中是否包含给定的对象
public boolean isEmpty(): 判断当前集合是否为空
public int size(): 返回集合中元素的个数
public Object[] toArray(): 把集合中的元素，存储到数组中
1.3.2 Iterator接口

  1. 定义：也叫迭代器，用于集合的遍历，由于它是一个接口，我们无法直接使用，需要间接使用Iterator接口的实现类对象来操作集合。

  2. Iterator对象创建：Collection接口中有一个方法叫做iterator()，返回的就是迭代器的实现类对象**（多态）**

  3. 迭代器使用步骤：

    1. 使用Collection中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收
      1. 获取实现类对象，并会把指针指向集合的-1索引
    2. 使用Iterator接口中的方法hasNext判断还有没有下一个元素
    3. 使用Iterator接口中的方法next取出集合中的下一个元素
      1. 第一步：取出下一个元素
      2. 第二步：指针后移一位

    例如：

    // 遍历集合中的元素
Iterator<String> iter = coll.iterator();
while(iter.hasNext()){
    System.out.println(iter.next());
}

  4. 常用方法：

    boolean hasNext(): 判断集合中还有没有下一个元素
E next(): 取出集合中的下一个元素

  5. 增强for：

    1. 定义：内部原理也是Iterator迭代器，专门用来遍历集合和数组

    2. 格式：

      for(元素的数据类型 变量 : 集合or数组){  }

    遍历共有三种方式：通过索引(有索引)，通过Iterator，通过增强for

1.3.3 List子接口

  1. 三大特点:

    1. 它是一个元素存取有序的集合
    2. 它是一个带索引的集合
    3. 它可以包含重复的元素

  2. 常用方法:

    public void add(int index, E e): 添加元素
public E get(int index): 获取元素
public E remove(int index): 删除元素
public E set(int index, E e): 设置元素(不可新增元素，只能修改元素)
1.3.3 ArrayList类

  1. 特点：底层是数组结构，因此增删慢，查找快

  2. 创建对象：

    1. 格式：ArrayList 对象名 = new ArrayList<>();
    2. 注意：
      1. 代表泛型，也就是装在集合当中的所有元素，全都是统一的什么类型
      2. 泛型只能是引用类型，不能是基本类型
      3. 对于ArrayList集合来说，直接打印得到的不是地址值，而是内容，如果内容是空，得到的是空的中括号:[]

  3. 常用方法：

    public boolean add(E e): 向集合当中添加元素，参数的类型和泛型一致
public E get(int index): 从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素
public E remove(int index): 从集合当中删除元素，参数是索引编号，返回值就是被删除的元素
public int size(): 获取集合的尺寸长度，返回值就是集合中包含的元素个数
1.3.4 LinkedList类

  1. 特点：底层是链表结构，因此增删快，查找慢

  2. 常用方法：

    public void addFirst(E e): 将指定元素插入到此列表的开头
public void addLase(E e): 将指定元素插入到此列表的结尾
public E getFirst(): 返回此列表的第一个元素
public E getLast(): 返回此列表的最后一个元素
public E removeFirst(): 移除并返回此列表的第一个元素
public E removeLast(): 移除并返回此列表的最后一个元素
public E pop(): 弹出一个元素    【等效于 removeFirst(E e)】
public void push(E e): 推入一个元素  【等效于 addFirst(E e)】
public boolean isEmpty(): 如果列表不包含元素，返回true
1.3.5 Vector类(了解)

​ 底层和ArrayList一样，也是数组结构

1.3.6 Set子接口
  1. 特点：
    1. 不允许存储重复的元素
    2. 没有索引，因此没有带索引的方法
  2. 常用方法：和Collection接口一致
1.3.7 HashSet类

  1. 特点：

    1. 它是一个元素存取无序集合
    2. 底层是一个哈希表结构，查询速度非常的快

  2. 常用方法：和Collection接口一致

  3. 哈希表：

    jdk1.8版本之前：哈希表=数组+链表

    jdk1.8版本之后：哈希表=数组+链表/红黑树

    注意：数组结构：把元素进行了分组(相同哈希值的元素是一组)；链表/红黑树结构：把相同哈希值的元素链接到一起。如果链接到一起的数据超过了8个，会把链表转换为红黑树结构。

  4. 调用add方法的过程：

    集合在调用add方法的时候，会同时调用hashCode方法和equals方法，判断元素是否重复（如果两个元素的哈希值相同，就会调用equals方法，进而判断两个元素是否相同，相同就不会存储该元素）

总结：HashSet存储元素的时候，必须重写hashCode方法和equals方法。（Alt+Insert）

1.3.7.1 LinkedHashSet类
  1. 特点：底层是一个哈希表+链表：多了一条链表（用来记录元素的存储顺序），保证元素有序
1.3.8 可变参数

  1. 使用前提：当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用

  2. 使用格式：定义方法时使用

    修饰符 返回值类型 方法名(数据类型…变量名){}

  3. 原理：底层是一个数组，根据传递参数的个数不同，会创建不同长度的数组，来存储这些参数，传递的参数个数可以是0个、1个…

  4. 注意事项：

    1. 一个方法的参数列表，只能有一个可变参数
    2. 如果方法的参数有多个，那么可变参数写在参数列表的末尾

  5. 终极写法：

    修饰符 返回值类型 方法名(Object… obj){}

1.4 Collections工具类

  1. 常用静态方法：

    public static <T> boolean addAll(Collection<T> list, T... elements): 往集合中添加一些元素
public static void shuffle(List<?> list): 打乱集合顺序
public static <T> void sort(List<T> list): 将集合中元素按照默认规则排序
public static <T> void sort(List<T> list, Comparator<? super T>): 将集合中元素按照指定规则排序

    注意：

    1. sort(List list)使用前提：被排序的集合里边存储的元素，必须实现Comparable接口，要重写接口中的compareTo方法(定义排序规则)

    2. Comparable接口的排序规则：【自己(this) 减 参数 表示升序】

    3. Comparator和Comparable的区别：

      1. Comparable：自己(this)和别人(参数)比较，自己需要实现Comparable接口
      2. Comparator：相当于找一个第三方的裁判，比较两个
      // 按照指定规则排序----使用匿名对象和匿名内部类
Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        // return o1-o2; // 升序
        return o2-o1;  // 降序
    }
});

1.5 Map集合

1.5.1 Map接口

  1. 特点：

    1. 它是一个双列集合，一个元素包含两个值(一个key，一个value)
    2. 集合中的元素，key和value的数据类型可以相同，也可以不同
    3. 集合中的元素，key是不允许重复的，value是可以重复的
    4. 集合中的元素，key和value是一一对应的

  2. 常用方法：

    public V put(K key, V value): 把指定的键与指定的值添加到Map集合中(key不重复返回null，key重复会使用新的value替换旧的value，返回被替换的value)
public V remove(Object key): 把指定的键所对应的的键值对元素在Map集合中删除(key存在返回被删除的value，key不存在返回null)
public V get(Object key): 根据指定的键，在Map集合中获取对应的值
boolean containsKey(Object key): 判断集合中是否包含指定的键
public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中
public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合

  3. Entry键值对对象：

    1. 定义：在Map接口中有一个内部接口Entry
    2. 作用：当Map集合一创建，那么就会在Map集合中创建一个Entry对象，用来记录键与值的映射关系。
    3. 常用方法：【getKey() ：获取key】 【getValue()：获取value】

  4. 遍历：

    1. 利用keySet方法遍历的步骤：
      1. 获取集合中所有的key值，并存入Set集合中
      2. 遍历Set集合即可
    2. 利用entrySet方法遍历的步骤：
      1. 获取集合中所有的Entry对象，并存入Set集合中
      2. 遍历Set集合即可

注意：作为key的元素，必须重写hashCode方法和equals方法，以保证key不重复

1.5.2 HashMap实现类
  1. 特点：
    1. 底层是哈希表，查询速度特别快
    2. 它是一个无序集合
  2. 注意：
    1. HashMap存储自定义类型键值的时候，如果要保证key不重复，在自定义类中必须重写hashCode方法和equals方法。（快捷键生成）
    2. 它会自动按照key值进行排序(与哈希值有关)
1.5.2.1 LinkedHashMap子类
  1. 定义：extends HashMap
  2. 特点：
    1. 底层是哈希表+链表
    2. 它是一个有序集合
1.5.3 Hashtable实现类

  1. 特点：

    1. 底层也是一个哈希表，是一个线程安全的集合，是单线程的集合，速度慢
    2. 不可以存储null值、null键
    3. 它和Vector集合一样，在jdk1.2版本之后被更先进的集合(HashMap，ArrayList)取代了
    4. 它的子类Properties依然活跃在历史舞台

  2. Properties集合

    1. java.util.Properties：extends Hashtable<k,v> implements Map<k,v>
    2. 作用：Properties集合是一个唯一和IO流相结合的集合
      • 可以使用Properties集合中的方法store，把集合中的临时数据，持久化写入硬盘中存储
        • void store(OutputStream out, String comments)：不可以写入中文，comments注释
        • void store(Writer writer, String comments)：可以写入中文
      • 可以使用Properties集合中的方法load，把硬盘中保存的文件(键值对),读取到集合中使用
        • void load(InputStream input)
        • void load(Reader reader)
    3. 属性列表中每个键及其对应值都是一个字符串(默认)
    4. 操作字符串的特有方法.：
      1. Object setProperty(String key, String value)：相当于Map集合中的put(key,value)
      2. String getProperty(String key)：相当于Map集合中的get(key)
      3. Set<String> stringPropertyName()：相当于Map集合中的keySet()（用于集合的遍历）
1.5.4 补充知识点
  1. JDK9的新特性：
    1. 概述：List接口、Set接口、Map接口：里边增加了一个静态的方法of，可以给集合一次性添加多个元素
    2. 格式：static List of (E… elements)
    3. 使用前提：当集合中存储的元素的个数已经确定了，不在改变时使用
    4. 注意:
      1. of方法只适用于List接口、Set接口、Map接口，不适用于接口的实现类
      2. of方法的返回值是一个不能改变的集合，集合不能再使用add，put方法来添加元素
      3. Set接口和Map接口在调用of方法的时候，不能有重复的元素

第二章 泛型

2.1 泛型概述

​ 泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型。例如E、T

2.2 使用泛型的好处

  1. 创建集合对象，不使用泛型
    1. 好处：默认的类型是Object类型，可以存储任意类型的数据
    2. 弊端：不安全，易引发异常
  2. 创建集合对象，使用泛型
    1. 好处：避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型；把运行期异常提升到了编译期
    2. 弊端：泛型是什么类型，就只能存储什么类型的数据

2.3 泛型的定义和使用

  1. 定义和使用含有泛型的类：

    // 定义
public class GenericClass<E> {
    private E name;  
    public E getName() {
        return name;
    }
    public void setName(E name) {
        this.name = name;
    }
}
// 使用
public class Demo05Generic {
    public static void main(String[] args) {
        GenericClass<Integer> gc = new GenericClass<>();
        gc.setName(123);
        System.out.println(gc.getName());
    }
}

    注意：创建集合对象的时候，就会确定泛型的数据类型

    1. 定义和使用含有泛型的方法：
    // 格式：修饰符 <泛型> 返回值类型 方法名(参数列表){}
// 定义
public class GenericMethod {
    public <M> void method01(M m){
        System.out.println(m);
    }
}
// 使用
public class Demo06Generic {
    public static void main(String[] args) {
        GenericMethod gm = new GenericMethod();
        gm.method01("sunlei");
        gm.method01(10);    
    }
}

    注意：在调用方法的时候确定泛型的数据类型。

    1. 定义和使用含有泛型的接口：

      1. 实现类的定义方式：
      2. 第一种实现方式：定义接口的实现类，实现接口，指定接口的泛型
      3. 第二种实现方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
    // 接口定义
public interface GenericInterface<T> {
    public abstract void method(T i);
}
// 实现类定义的两种方式
// 第一种方式
public class GenericInterfaceImpl implements GenericInterface<String>{
    @Override
    public void method(String i) {
        System.out.println(i); 
    }
}	
public static void main(String[] args) {
    GenericInterfaceImpl gii = new GenericInterfaceImpl();
    gii.method("sunlei");
}
// 第二种方式
public class GenericInterfaceImpl<T> implements GenericInterface<T>{
    @Override
    public void method(T i) {
        System.out.println(i); 
    }
}
public static void main(String[] args) {
    GenericInterfaceImpl<String> gii = new GenericInterfaceImpl<>();
    gii.method("sunlei");
}

    1. 泛型通配符

      1. 定义：不知道使用什么类型来接收的时候，此时可以使用?表示未知通配符

      2. 使用方式：不能创建对象使用，只能作为方法的参数使用

      ArrayList<?> list = new ArrayList<>();   // 不正确
public static void printArray(ArrayList<?> list){} // 正确

      1. 高级使用之受限泛型（看懂代码即可）

      2. 泛型的上限限定：? extends E 代表使用的泛型只能是E类型的子类/本身

      3. 泛型的下限限定：? super E 代表使用的泛型只能是E类型的父类/本身

        // 此时的泛型，必须是Number类型或者Number类型的子类
public static void printArray(ArrayList<? extends Number> list){}
// 此时的泛型，必须是Number类型或者Number类型的父类
public static void printArray(ArrayList<? super Number> list){}
三石大数据
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大数据Java基础之枚举类与注解
尚拙的博客
02-24 111
大数据Java基础之枚举类与注解
【Java数据结构】泛型
C、Java知识分享
05-10 244
为什么使用泛型 泛型的目的 语法 擦除机制 T[] ts = new T[N]创建报错之谜 泛型的上界 泛型方法 通配符 通配符的上界 通配符的下界
Java期末考试试题及参考答案(08)
谷哥的小弟
12-16 5926
泛型的主要目标是提高Java程序的类型安全性，即可以通过泛型定义对变量类型进行限制，在对变量类型限制之后编译器可以更好的进行类型验证
Java SE第9章 泛型
m0_61466355的博客
04-09 228
Java SE第9章 泛型 1. 编译时类型检查的重要性 2. 使用泛型实现编译时进行类型检查 3. 定义泛型接口，泛型类 4. 派生泛型接口，泛型类的子类，实现类 5. 使用类型通配符 6. 设定类型通配符的上限 7. 设定类型通配符的下限 8. 设定泛型形参的上限 9. 在方法签名中定义泛型 10. 泛型方法和类型通配符的区别和联系 11. 泛型方法和方法重载 12. 类型推断 13. 擦除和转换 14. 泛型和数组 1. 编译时类型检查的重要性 在没有泛型之前，集合会把所有的对象当成 Object
Java 泛型详解
zsm653983的专栏
10-30 2247
首先在没有泛型之前，一旦把一个对象丢进java集合中，集合就会忘记对象的类型，把所有对象当成Object类型来处理。当程序从集合中取出对象时，就需要进行强制类型转换，这种强制类型转换不仅代码臃肿，而且容易引起ClassCastException异常。 public class ListErr { public static void main(String[]
JAVA泛型 基本概念学习
qq_37040929的博客
09-04 180
泛型入门 增加泛型这一功能很大程度上都是为了让集合能记住元素的数据类型。在没有泛型之前，一旦把一个对象放进JAVA集合中，集合就会忘记对象的类型，并当成Object处理，取出时需要强制转换。 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型中T和?的区别： https:/
Java基础——集合List+Set+泛型+Map
Mr_YangXianfa__的专栏
05-10 3050
1. 集合类概述 为什么出现集合类？ •面向对象语言对事物的体现都是以对象的形式，所以为了方便对多 个对象的操作，就对对象进行存储，集合就是存储对象最常用的一 种方式，不能存储基本数据类型，但是出现自动装箱后，可以存储基本数据类型。 数组和集合类同是容器，有何
大数据开发成长之路——Java基础（四）
12-21
Java中的集合是用来存放对象的容器 集合可以存放不同类型，不限数量的数据 分为两块：Collection和Map，也称之为集合接口 集合类都存放在java.util包中 Collection Collection分别被List和Set继承 List List被...
java实现把一个List集合拆分成多个的操作
09-07
List集合是Java集合框架中常用的一种数据结构，用于存储有序的元素序列。本篇文章将详细讲解如何使用Java实现将一个List集合拆分成多个固定长度的小集合。 首先，我们来看一个简单的例子，这个例子中定义了一个名为...
达内Java大数据 Day01练习题及答案
11-04
Day01的练习题旨在帮助初学者巩固和深化对Java基本概念的理解，为后续的大数据技术学习打下坚实的基础。以下是基于这个主题的详细知识点讲解： 1. **Java基础语法**：Java是一种面向对象的编程语言，其语法严谨。...
Java开发详解.zip
09-02
031314_【第13章：Java类集】_集合工具类：Collections笔记.pdf 031315_【第13章：Java类集】_Stack类笔记.pdf 031316_【第13章：Java类集】_属性类：Properties笔记.pdf 031317_〖第13章：Java类集〗_范例讲解：一...
大数据开发工程师需掌握技术.docx
11-24
* 集合：掌握 Java 的集合框架和泛型编程 * IO/NIO：掌握 Java 的输入/输出流和 NIO 编程 * Java 实用技术：掌握 Java 的实用技术，如反射、注解等 * Mysql 数据库：掌握 Mysql 数据库的基本概念和 SQL 语句 * 阶段...
JAVA数据结构集合框架泛型
于小袁的博客
08-27 332
我们在接收新的技术的时候怎么接受他的好 ? 1:性能方面 改变比较大 2:使用方面比较简单(如果新的性能高十分麻烦也会用新的数据) 此时我们来恶心一下自己,来改一下数组实现和容器差不多的功能有多麻烦,然后我们在来接触集合,那么我们首先来模拟一下ArrayList的底层操作 模拟ArrayList 作用:计算机存储组织数据的方式,然后就是模拟数据进行增删改查 模拟ArrayList的增删改查 先初始化数组一下 然后对集合数组进行增删改查操作 public class PlayerList{ //存储
11-Java集合总结
lym905612018的博客
05-03 171
Java 集合 注：有序、无序是指再进行插入的操作时，插入的位置顺序性先插的位置在前后插的位置在后，则为有序，反之无序 Java 集合关于javaEE听课的笔记欢迎访问查看 概述 一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象 的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊 端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。 数组在内存存储方面的特点： 数组初始化以后，长度就确定了。 数组声明的类型，就决定了进行元素初始化时的类型 数
java泛型(笔记)
uzong
06-18 711
一、泛型的基本用法 使用泛型，可以在编译时进行类型转换检查，而不使用泛型，在运行时才检查 二、内部原理及更深应用 泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入。编译器编译带类型说明的集合时会去除类型信息。对于参数化的泛型类型，getClass()方法的返回值和原始类型的完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要跳过编译器，...
java面向对象高级泛型与list,set,Map
love超1314的专栏
08-06 1745
泛型 泛型，即 “参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。 参数化类型：就是将类型由原来具体的类型参数化，类似于方法中的变量参数，此时类型也可以定义成参数形式（可以称之为类型参数），然后在使用/调用时传入具体的类型（类型实参） 数据结构和算法简介 数据结构概念 数据的逻辑结构和存储结构及运算 逻辑结构 数据元素和元素之间的关系
九、Java 泛型
qq_54522796的博客
03-21 250
泛型入门 泛型的作用，很大程度上是为了让集合记住其元素的数据类型，而在没有泛型之前，集合是把所有对象都当成 Object 类型处理。而当取出集合的元素时，需要进行强制转换，此时就很可能会引发 ClassCastExeception 异常。 public static void main(String[] args) { List list = new ArrayList(); list.add("Java"); list.add("泛型");
Java泛型详解，史上最全图文详解
jacklin_01的博客
06-17 205
泛型在java中有很重要的地位，无论是开源框架还是JDK源码都能看到它。毫不夸张的说，泛型是通用设计上必不可少的元素，所以真正理解与正确使用泛型，是一门必修课。一：泛型本质 Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
【大数据开发必看】可视化BI神器---FineBI
qq_42397330的博客
03-19 3528
数据可视化分析平台FineBI 1. 可视化的应用 1.1 数据可视化 可视化分析平台：不用写代码，直接对原始数据通过图形化操作实现分析和构建报表平台 主要用于提供给业务人员快速上手实现数据分析 构建可视化报表 通过图的形式来展示对应的数据，实现信息的传递 传递信息的方式 文字：不太适合表达数据的信息结果 图片：简单直观 体现数据走势 体现数据大小 体现数据比例 声音：不太适合数据的表达 视频：太笨重，不太方便 1.2 目的 通过图片来展示数据的结果，从图中可以发现数据的规律
Java集合、泛型和枚举
最新发布
06-14
Java集合、泛型和枚举是在编程中非常重要和常用的概念。在进行编程时，我们经常会需要保存多个对象，对数量不确定的数据进行操作，以及保存具有映射关系的数据。在这些情况下，Java提供了集合类来解决这些问题。集合...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值