Collection、Iterator(迭代器)、增强for循环、Generic(泛型)

最新推荐文章于 2024-07-24 11:43:52 发布
最新推荐文章于 2024-07-24 11:43:52 发布
阅读量327 收藏 1
点赞数
分类专栏： 笔记 文章标签： java 接口 intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YyjYsj/article/details/108163343
版权

目录

1、Collection（所有单列集合的父接口，定义的是所有单列集合（List和Set）中共性的方法）

（1）使用add()方法向集合中添加元素

（2）使用remove()方法从集合中删除指定的元素（返回boolean类型数据）

（3）使用contains()方法判断当前集合中是否包含给定元素（返回boolean类型数据）

（4）使用isEmpty()方法判断当前集合是否为空（返回boolean类型数据）

（5）使用size()方法返回集合中元素的个数（返回int类型数据）

（6）使用toArray()方法把集合中的元素存储到数组中

（7）使用clear()方法清空集合中所有的元素（并非删除集合，集合还存在）

2、Iterator（迭代器）

（1）使用while循环遍历

（2）使用for循环遍历 

3、增强for循环（用来遍历集合和数组）（快捷键：数组名/集合名.for -> 回车）

（1）使用增强for循环来遍历集合 

（2）使用增强for循环来遍历数组 

4、Generic（泛型）

（1）普通泛型示例

a）使用泛型

b）不使用泛型

（2）泛型类

a）不使用泛型类（只能设置指定类型的数据，很不方便）

b）使用泛型类（可以设置多种类型的数据）

（3）泛型方法

a）不使用含有泛型的方法

b）使用含有泛型的方法

（4）泛型接口

（5）泛型的通配符  ？

1、Collection（所有单列集合的父接口，定义的是所有单列集合（List和Set）中共性的方法）

（1）使用add()方法向集合中添加元素

//首先创建集合对象，可以使用多态
Collection<String> coll = new ArrayList<>();
System.out.println(coll);// [] ，重写了toString方法
//向集合中添加元素
coll.add("张三");
coll.add("李四");
coll.add("迪丽热巴");
coll.add("古力娜扎");
coll.add("马尔扎哈");
System.out.println(coll);

打印结果：
[]
[张三, 李四, 迪丽热巴, 古力娜扎, 马尔扎哈]

（2）使用remove()方法从集合中删除指定的元素（返回boolean类型数据）

【还使用（1）中的coll集合】
//删除指定的元素
boolean rem = coll.remove("张三");//删除“张三”
if (rem == true) {
    System.out.println("删除成功，剩下的集合为：" + coll);
} else {
    System.out.println("删除失败，剩下的集合为：" + coll);
}
boolean rem2 = coll.remove("王五");//删除“王五”
if (rem2 == true) {
    System.out.println("删除成功，剩下的集合为：" + coll);
} else {
    System.out.println("删除失败，剩下的集合为：" + coll);
}

打印结果：
删除成功，剩下的集合为：[李四, 迪丽热巴, 古力娜扎, 马尔扎哈]
删除失败，剩下的集合为：[李四, 迪丽热巴, 古力娜扎, 马尔扎哈]

（3）使用contains()方法判断当前集合中是否包含给定元素（返回boolean类型数据）

【还使用（1）中的coll集合】
//判断当前集合中是否包含给定元素
boolean co = coll.contains("迪丽热巴");
if (co == true){
    System.out.println("集合中包含此元素");
}else {
    System.out.println("集合中不包含此元素");
}
boolean co1 = coll.contains("张三");
if (co1 == true){
    System.out.println("集合中包含此元素");
}else {
    System.out.println("集合中不包含此元素");
}

打印结果：
集合中包含此元素
集合中不包含此元素

（4）使用isEmpty()方法判断当前集合是否为空（返回boolean类型数据）

【还使用（1）中的coll集合】
//判断当前集合是否为空
boolean empty = coll.isEmpty();
System.out.println("当前集合是否为空？" + empty);

打印结果：
当前集合是否为空？false

（5）使用size()方法返回集合中元素的个数（返回int类型数据）

【还使用（1）中的coll集合】
//返回集合中元素的个数
int size = coll.size();
System.out.println("当前集合有" + size + "个元素");

打印结果：
当前集合有5个元素

（6）使用toArray()方法把集合中的元素存储到数组中

【还使用（1）中的coll集合】
//把集合中的元素存储到数组中
Object[] arr = coll.toArray();
for (int i = 0; i < arr.length; i++) {//遍历数组（快捷键：arr.fori -> 回车）
    System.out.println(arr[i]);
}

打印结果：
张三
李四
迪丽热巴
古力娜扎
马尔扎哈

（7）使用clear()方法清空集合中所有的元素（并非删除集合，集合还存在）

【还使用（1）中的coll集合】
//清空集合中所有的元素，但是不删除集合，集合还存在
coll.clear();
System.out.println(coll);//[]
boolean empty1 = coll.isEmpty();//判断是否为空
System.out.println("当前集合是否为空？" + empty1);

打印结果：
[]
当前集合是否为空？true

2、Iterator（迭代器）

Iterator迭代器，是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象。 Collection接口中有一个方法，叫iterator()，这个方法返回的就是迭代器的实现类对象

（1）使用while循环遍历

//创建一个集合对象
Collection<String> coll = new ArrayList<>();
//往集合中添加元素
coll.add("库里");
coll.add("汤普森");
coll.add("欧文");
coll.add("詹姆斯");
coll.add("杜兰特");

//获取迭代器的实现类对象
Iterator<String> iterator1 = coll.iterator();//多态写法
//循环遍历，输出打印【while循环】
while (iterator1.hasNext()) {//也可以写while (iterator1.hasNext()==true)
    System.out.println(iterator1.next());
}

打印结果：
库里
汤普森
欧文
詹姆斯
杜兰特

（2）使用for循环遍历 

//创建一个集合对象
Collection<String> coll = new ArrayList<>();
//往集合中添加元素
coll.add("库里");
coll.add("汤普森");
coll.add("欧文");
coll.add("詹姆斯");
coll.add("杜兰特");

//获取迭代器的实现类对象
Iterator<String> iterator2 = coll.iterator();//多态写法
//循环遍历，输出打印【for循环】
for (int i = 0; i < coll.size(); i++) {
    if (iterator2.hasNext()) {
        System.out.println(iterator2.next());
    }
}

打印结果：
库里
汤普森
欧文
詹姆斯
杜兰特

3、增强for循环（用来遍历集合和数组）（快捷键：数组名/集合名.for -> 回车）

（1）使用增强for循环来遍历集合 

//创建一个ArrayList集合
ArrayList<String> list = new ArrayList<>();
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马尔扎哈");
//使用增强for循环遍历集合
for (String s : list) {//快捷键：list.for -> 回车
    System.out.println(s);
}

打印结果：
迪丽热巴
古力娜扎
马尔扎哈

（2）使用增强for循环来遍历数组 

//创建一个int类型的数组
int[] arr = {1, 2, 3, 4, 5};
//使用增强for循环遍历数组
for (int i : arr) {//快捷键：arr.for -> 回车
    System.out.println(i);
}

打印结果：
1
2
3
4
5

4、Generic（泛型）

（1）普通泛型示例

a）使用泛型

好处：避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型。另外，把运行期异常提升到了编译期（只要程序出现异常，就直接报错，不会等到运行之后才发现异常）

弊端：泛型是什么类型，就只能存储什么类型的数据（这个弊端可以忽略）

ArrayList<String> arr = new ArrayList<>();//使用泛型，只能向集合中添加String类型的数据
arr.add("迪丽热巴");
arr.add("古力娜扎");
arr.add("马尔扎哈");
//arr.add(123);//泛型是String类型，就只能存储String类型的数据，因此会报错

//使用迭代器循环遍历打印
Iterator<String> iterator1 = arr.iterator();
while (iterator1.hasNext()){
    System.out.println(iterator1.next());
}

打印结果：
迪丽热巴
古力娜扎
马尔扎哈

b）不使用泛型

好处：集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据

弊端：集合不安全，会引发异常。因为不使用泛型，默认Object类型，则一定是使用多态写法（Object obj1 = "zhangsan"、Object obj2 = 123）。但是如果想获取每个字符串的长度时，就要用到String类中特有的length()方法，但是多态的弊端就是不能使用子类特有的方法，因此就需要向下转型。obj1 = "zhangsan"可以向下转型为String类型，就可以调用length()方法获取其长度，但是要想获取obj1 = 123的长度，因为int类型的数据不能转型为String类型，因此会报错。这也就是不安全，会引发异常的原因。

ArrayList list = new ArrayList();//不使用泛型，就是默认Object类型，可以向集合中添加任何类型的数据
list.add("迪丽热巴");
list.add(123);
list.add('中');
list.add(3.14);
list.add(true);

//使用增强for循环遍历
for (Object s : list) {
    System.out.println(s);
}

打印结果：
迪丽热巴
123
中
3.14
true

（2）泛型类

a）不使用泛型类（只能设置指定类型的数据，很不方便）

1️⃣创建一个Student类，用来创建对象使用，指定具体数据类型为String类型（不使用泛型）

package com.itheima.demo03Generic;

public class Student {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

2️⃣创建一个DemoStudent类，使用Student类来创建对象，并传递参数

package com.itheima.demo03Generic;

public class DemoStudent {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");//只能设置String类型的数据
        System.out.println(student.getName());
//        student.setName(123);//错误写法，因为指定了泛型为String类型，就不能设置Integer类型的数据
    }
}

打印结果：
张三

b）使用泛型类（可以设置多种类型的数据）

泛型是一个未知的数据类型，当我们不确定使用什么数据类型时，可以使用泛型，泛型可以接收任意的数据类型

1️⃣创建一个GenericClass类，用来创建对象使用，不指定具体数据类型（使用泛型）

package com.itheima.demo03Generic;

public class GenericClass<E> {
    //自定义泛型
    private E name;
    public E getName() {
        return name;
    }
    public void setName(E name) {
        this.name = name;
    }
}

2️⃣创建一个DemoGenericClass类，使用GenericClass类来创建对象，并传递参数

package com.itheima.demo03Generic;

public class DemoGenericClass {
    public static void main(String[] args) {
        //不指定泛型，默认为Object类型，什么类型的数据都可以赋值
        GenericClass gc1 = new GenericClass();
        gc1.setName("张三");
        System.out.println(gc1.getName());
        gc1.setName(123);
        System.out.println(gc1.getName());
        System.out.println("===========");

        //使用Integer泛型
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(123);
        System.out.println(gc2.getName());
//        gc2.setName("张三");//错误写法，因为指定了泛型为Integer类型，就不能设置String类型的数据
        System.out.println("==========");

        //使用String泛型
        GenericClass<String> gc3 = new GenericClass<>();
        gc3.setName("张三");
        System.out.println(gc3.getName());
//        gc3.setName(123);//错误写法，因为指定了泛型为String类型，就不能设置Integer类型的数据
    }
}

打印结果：
张三
123
===========
123
==========
张三

（3）泛型方法

a）不使用含有泛型的方法

1️⃣创建一个GenericMethod类，用来创建对象和调用方法使用（不使用泛型，指定类型）

package com.itheima.demo03Generic;

public class GenericMethod {
    //定义一个不含泛型的普通方法
    public void method1(int i){//只能传递int类型的参数
        System.out.println(i);
    }

    //定义一个不含泛型的静态方法
    public static void method2(String s){//只能传递String类型的参数
        System.out.println(s);
    }
}

2️⃣ 创建一个DemoGenericMethod类，用来创建GenericMethod对象和调用其中的方法

package com.itheima.demo03Generic;

public class DemoGenericMethod {
    public static void main(String[] args) {
        //创建GenericMethod对象
        GenericMethod gm = new GenericMethod();
        gm.method1(123);//调用method1方法，并且只能传递int类型的参数
        System.out.println("===========");

        gm.method2("静态方法，不建议创建对象使用！");
        //静态方法，通过类名.方法名(参数)  调用
        GenericMethod.method2("张三");//调用method2方法，并且只能传递String类型的参数
    }
}

打印结果：
123
静态方法，不建议创建对象使用！
张三

b）使用含有泛型的方法

1️⃣创建一个GenericMethod类，用来创建对象和调用方法使用（使用泛型）

package com.itheima.demo03Generic;

public class GenericMethod {
    //定义一个含有泛型的普通方法
    public <M> void method1(M m){
        System.out.println(m);
    }

    //定义一个含有泛型的静态方法
    public static <S> void method2(S s){
        System.out.println(s);
    }
}

2️⃣ 创建一个DemoGenericMethod类，用来创建GenericMethod对象和调用其中的方法

package com.itheima.demo03Generic;

public class DemoGenericMethod {
    public static void main(String[] args) {
        //创建GenericMethod对象
        GenericMethod gm = new GenericMethod();
        //调用含有泛型的方法method1。传递什么类型，泛型就是什么类型
        gm.method1("张三");
        gm.method1(123);
        gm.method1(true);
        gm.method1(3.14);
        gm.method1('于');
        System.out.println("===========");

        gm.method2("静态方法，不建议创建对象使用！");
        //静态方法，通过类名.方法名(参数)  调用
        GenericMethod.method2("张三");
        GenericMethod.method2(123);
        GenericMethod.method2(true);
        GenericMethod.method2(3.14);
        GenericMethod.method2('于');
    }
}

打印结果：
张三
123
true
3.14
于
===========
静态方法，不建议创建对象使用！
张三
123
true
3.14
于

（4）泛型接口

1️⃣创建一个含有泛型的接口，里面写一个抽象方法

package com.itheima.demo03Generic;
//定义含有泛型的接口
public interface GenericInterface<I> {
    public abstract void method(I i);
}

2️⃣定义一个接口的实现类GenericInterfaceImpl1，用于实现上面的接口（这个接口实现类指定接口的泛型）

package com.itheima.demo03Generic;
//指定接口的泛型为String
public class GenericInterfaceImpl1 implements GenericInterface<String> {
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

3️⃣定义一个接口的实现类GenericInterfaceimpl2，用于实现上面的接口（这个接口实现类不指定接口的泛型）

package com.itheima.demo03Generic;
//自定义泛型（不指定接口的泛型）
public class GenericInterfaceImpl2<A> implements GenericInterface<A> {
    @Override
    public void method(A a) {
        System.out.println(a);
    }
}

4️⃣创建一个DemoGenericInterface类，用来测试含有泛型接口

package com.itheima.demo03Generic;
//测试含有泛型的接口
public class Demo04GenericInterface {
    public static void main(String[] args) {
        GenericInterfaceImpl1 impl1 = new GenericInterfaceImpl1();
        impl1.method("迪丽热巴");
//        impl1.method(123);//错误写法，因为指定了泛型为String类型，就不能设置Integer类型的数据

        GenericInterfaceImpl2<String> impl2 = new GenericInterfaceImpl2<>();//创建String类型的对象
        impl2.method("迪丽热巴");//传递String类型的参数

        GenericInterfaceImpl2<Integer> impl3 = new GenericInterfaceImpl2<>();//创建int类型的对象
        impl3.method(123);//传递int类型的参数

        GenericInterfaceImpl2<Double> impl4 = new GenericInterfaceImpl2<>();//创建Double类型的对象
        impl4.method(3.14);//传递double类型的参数
    }
}

打印结果：
迪丽热巴
迪丽热巴
123
3.14

（5）泛型的通配符  ？

不知道使用什么类型来接收数据的时候，此时可以使用 ? 来接收

package com.itheima.demo03Generic;

import java.util.ArrayList;
import java.util.Iterator;
//泛型的通配符：？ 代表任意的数据类型
//不能创建对象使用，只能作为方法的参数使用
public class Demo05Generic {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("迪丽热巴");
        list1.add("古力娜扎");
        list1.add("马尔扎哈");

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(123);
        list2.add(456);
        list2.add(789);

        printArray(list1);
        printArray(list2);
    }

    //定义一个方法，能遍历所有类型的ArrayList集合
    //当不知道ArrayList集合使用什么数据类型，可以使用泛型的通配符？来接收数据类型
    public static void printArray(ArrayList<?> list){
        //使用迭代器遍历集合
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

打印结果；
迪丽热巴
古力娜扎
马尔扎哈
123
456
789

 

于小猿
关注
专栏目录
迭代 循环 区别
sqk1988-IT心园
08-26 8886
个人认为迭代是循环的一种，循环体代码分为固定循环体，和变化的循环体。 迭代：“迭”：轮流，轮番，替换，交～。更～。“代”：代替。所以迭代的意思是：变化的循环，这种变化就是轮番代替，轮流代替。 循环：不变的重复。 固定的循环： for(int i=0;i System
Collection集合&Iterator迭代器&泛型
m0_63158445的博客
02-22 491
** Collection、Iterator、泛型、数据结构 能够说出集合与数组的区别 数组: 1.是引用数据类型的一种,可以存储多个元素 2.数组的长度是固定的 int[] arr1 = new int[10]; int[] arr2 = {1,2,3}; 3.数组即可以存储基本类型的数据,又可以存储引用数据类型的数据 int[],double[],String[],Student[] 集合: 1.是引用数据类型的一种,可以存储多个元素 2.集合的长度是可以变化的(可以往集
Java迭代器以及增强for循环
weixin_44976835的博客
11-09 290
package Interface_Iterator; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; /* * 迭代器 * 是一种用于Collection集合通用的取出集合中元素的工具 * (对集合进行遍历) * * 两个常用方法 * boolean hasNext() 如果集合中仍有元素可以迭代 则返回true(判断集合里还有没有下一个元素) * E next()
循环、递归、遍历、迭代的区别
最新发布
2301_79540484的博客
07-24 226
1，循环（loop） 指的是在满足条件的情况下，重复执行同一段代码。比如，while语句。循环则技能对应集合，列表，数组等，也能对执行代码进行操作。
迭代 与 循环的区别、迭代和递归的区别
zxf347085420的博客
02-23 713
迭代和循环的效率都取决于循环的次数和执行的代码。在循环次数相同的情况下，迭代的效率通常比循环低，因为迭代需要根据上次执行的结果来进行下一次执行，而循环的执行结果是相同的，不需要进行额外的计算。在一些编程语言中，迭代和循环的语法是不同的，例如Python和Ruby中的迭代语法和Java和C++中的循环语法是不同的。从概念上来看，迭代强调的是根据上一次执行的结果来进行下一次执行，而循环强调的是每次执行的结果都是相同的。从实现的方式上看，迭代的执行次数是不确定的，而循环的执行次数是确定的。
漫谈递归：循环与迭代是一回事吗？
仰望星空
12-29 4145
先摘抄“为之漫笔”对这几个概念的一段理解：loop、iterate、traversal和recursion这几个词是计算机技术书中经常会出现的几个词汇。众所周知，这几个词分别翻译为：循环、迭代、遍历和递归。乍一看，这几个词好像都与重复（repeat）有关，但有的又好像不完全是重复的意思。那么这几个词到底各是什么含义，有什么区别和联系呢？下面就试着解释一下。循环（loop），指的是在满足条件的情况下，
迭代和循环
Hultron的博客
01-24 707
迭代和循环有什么区别？
Java学习（System类,StringBuilder类，包装类，Collection集合，Iterator接口/迭代器，增强for，泛型）
XXX_17的博客
01-17 262
2022/1/10 1/17 1.System类的常用方法 package ln.javatest.day11.demo01; /* java.lang.System类中提供了大量的静态方法，可以获取系统相关的信息或系统级操作，在System类的API文档中，常用的方法有： public static long currentTimeMillis（）:返回以毫秒为单位的当前时间 public static void arraycopy（Object src,int srcPos,Obj
Collection集合、Iterator迭代器、foreach、泛型、斗地主发牌案例
wssh1854的博客
01-30 257
集合与数组的区别；Collection集合的常用功能；使用迭代器对集合进行取元素；说出集合的使用细节；使用集合存储自定义类型；使用foreach循环遍历集合；使用泛型定义集合对象；理解泛型上下限；阐述泛型通配符的作用
集合--增强for循环、泛型
小乔与你同在
11-29 366
1 增强for循环 （1）格式：for(数据类型 变量:遍历对象（集合或数组）){ 语句 } 变量就等价于next()方法返回的结果 （2）原理：增强for循环底部原理仍然是调用了迭代器。 （3）好处及弊端：简化了迭代器代码。只能做遍历元素操作，不能够在遍历的过程中对集合元素做其它操作。 public static void main(String[] args) { // 创建对象并添加 ...
复习Collection_迭代器使用细节_泛型_综合案例
菜鸡逆袭的博客
10-03 406
day02_Collection_泛型 主要内容 Collection集合 迭代器 增强for 泛型 教学目标 能够说出集合与数组的区别 说出Collection集合的常用功能 能够使用迭代器对集合进行取元素 能够说出集合的使用细节 能够使用集合存储自定义类型 能够使用foreach循环遍历集合 能够使用泛型定义集合对象 能够理解泛型上下限 能够阐述泛型通配符的作用 第一...
关于方法的迭代和循环之间的区别
qq_31850627的博客
02-26 664
先出一道题目，一个人可以一次走一阶楼梯和两节楼梯。如果有N节楼梯，那么他有几种走法走完。 这道题我们有2种方法可以来实现。 思路：当楼梯只有一节或两节时，一节楼梯的走法自然只有一种，两节楼梯的走法有2种。而三节以上我们可以认为是一开始走了一节然后走两节或者是一开始走了两节的再走一节。 设算出台阶的走法函数为F(n)。 F(1)=1 F(2)=2 F(3)=F(1)+F(2) -… F(N)=F(N-1)+F(N-2) 而具体实现方式有两种 迭代 public Double F1(int n){ if(
迭代、递归、普通循环的联系与区别
weixin_43965999的博客
08-28 574
迭代与递归与普通循环
递归、迭代与循环
qq_42939554的博客
10-05 1602
递归、迭代与循环一、递归（以斐波那契数列递归方法为例）1.递归定义2.使用递归何时使用递归如何使用递归3.递归实例（以斐波那契数列为例）4.递归与栈5.递归与迭代6.迭代与循环递归转化为非递归（迭代） 一、递归（以斐波那契数列递归方法为例） 1.递归定义 在定义一个过程或函数时，出现直接或者间接调用自己的成分，称之为递归。在计算机科学中是指一种通过重复将问题分解为同类的子问题而解决问题的方法。简单来说，递归表现为函数调用函数本身。 在知乎看到一个比喻递归的例子，个人觉得非常形象，大家看一下： 递归最恰当的
专业术语之------迭代，循环，遍历，递归的区别
maylead的博客
09-15 1198
loop、iterate、traversal和recursion这几个词是计算机技术书中经常会出现的几个词汇。众所周知，这几个词分别翻译 为：循环、迭代、遍历和递归。乍一看，这几个词好像都与重复（repeat）有关，但有的又好像不完全是重复的意思。那么这几个词到底各是什么含义，有什么区别和联系呢？下面就试着解释一下。 　　1，循环（loop），指的是在满足条件的情况下，重复执行同一段代码。比
循环、递归、遍历、迭代四者的概念区别
热门推荐
吴小迪的博客
07-06 3万+
循环、递归、遍历、迭代介绍 循环（loop）–最基础的概念，所有重复的行为 a.循环算是最基础的概念，凡是重复执行一段代码，都可以称之为循环。大部分的递归，遍历，迭代，都是循环。 递归（recursion）–在函数内调用自身，将复杂情况逐步转化成基本情况 a.递归时重复调用函数自身实现循环。迭代时函数内某段代码实现循环，而迭代与普通循环的区别是：循环代码中参与运算的变量同时是保存结果的变量...
java普通for循环和for-each迭代循环的区别
weixin_30265103的博客
07-16 138
PO实体类User: package aA; public class User { private String name; private int many; private int id; public int getId() { return id; } public void set...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值