Java_17泛型与常见数据结构

最新推荐文章于 2022-09-21 22:00:00 发布
最新推荐文章于 2022-09-21 22:00:00 发布
阅读量291 收藏
点赞数
分类专栏： JAVA 文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43801116/article/details/107546569
版权

一、集合的体系结构

1、集合体系图

在这里插入图片描述
在最顶层的父接口Collection中一定定义了所有子类集合的共同属性和方法,因此我们首先需要学习Collection中共性方法,然后再去针对每个子类集合学习它的特有方法

import java.util.ArrayList;

/*
 *  ArrayList
 *  集合的体系结构：
 *  	由于不同的数据结构（数据的组织，存储方式），所以Java为我们提供了不同的集合，
 *  	但是不同的集合他们的功能都是相似，不断的向上提取，将共性抽取出来，这就是集合体系结构形成的原因
 *  
 *  体系结构：
 *  		怎么学习?最顶层开始学习，因为最顶层包含了所有的共性
 *  		怎么使用？使用最底层，因为最底层就是具体的实现
 *  
 *  Collection
 *  List
 *  ArrayList
 */
public class CollectionDemo {
	public static void main(String[] args) {		
		//创建集合对象
		ArrayList al = new ArrayList();
		//添加元素
		al.add("hello");
		al.add("world");
		al.add("java");
		//遍历集合
		for(int x = 0;x < al.size();x++) {
			System.out.println(al.get(x));
		}
		
	}
}

2、Collection中的常用功能

boolean add(Object e): 向集合中添加元素
void clear():清空集合中所有元素
boolean contains(Object o):判断集合中是否包含某个元素
boolean isEmpty():判断集合中的元素是否为空
boolean remove(Object o):根据元素的内容来删除某个元素
int size():获取集合的长度
Object[] toArray():能够将集合转换成数组并把集合中的元素存储到数组中

import java.util.ArrayList;
import java.util.Collection;

/*
 * 	Collection 	
 * 			boolean add(E e)  
 * 			void clear()  
 * 			boolean contains(Object o)  
 * 			boolean isEmpty() 
 * 			boolean remove(Object o) 
 * 			int size() 
 * 			Object[] toArray() 
 *			Iterator<E> iterator()  
 
 * 		
 */
public class CollectionDemo2 {
	public static void main(String[] args) {		
		//创建集合对象
		//Collection c = new Collection();//Collection是接口，不能实例化
		Collection c = new ArrayList();//多态，父类引用指向子类对象  
		
		//boolean add(E e)  
		System.out.println(c.add("hello"));//永远可以添加成功，因为ArrayList他允许重复
		System.out.println(c.add("world"));
		
		//void clear()：清空集合
		//c.clear();
		
		//boolean contains(Object o)  :判断集合中是否包含指定元素
		//System.out.println(c.contains("java"));
		
		//boolean isEmpty() :是否为空
		//System.out.println(c.isEmpty());
		
		
		//boolean remove(Object o) :删除元素
		//System.out.println(c.remove("java"));
		
		//int size() :返回集合中的元素个数
		//System.out.println(c.size());
		
		//Object[] toArray()  :将集合转换成一个Object类型的数组
		Object[] objs = c.toArray();
		for (int i = 0; i < objs.length; i++) {
			System.out.println(objs[i]);
		}
		System.out.println(c);
	}
}

3、迭代器

java中提供了很多个集合，它们在存储元素时，采用的存储方式不同。我们要取出这些集合中的元素，可通过一种通用的获取方式来完成。
Collection集合元素的通用获取方式：

在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出
来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全
部取出。这种取出方式专业术语称为迭代。

集合中把这种取元素的方式描述在Iterator接口中。Iterator接口的常用方法如下
hasNext（）方法：判断集合中是否有元素可以迭代
next（）方法：用来返回迭代的下一个元素，并把指针向后移动一位。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
 * 集合的遍历方式：
 * 		1.toArray(),可以把集合转换成数组，然后遍历数组即可
 * 		2.iterator(),可以返回一个迭代器对象，我们可以通过迭代器对象来迭代集合
 * 
 * Iterator：可以用于遍历集合
 * 	E next()  :返回下一个元素
 *  boolean hasNext()  ：判断是否有元素可以获取
 * 
 *  注意：Exception in thread "main" java.util.NoSuchElementException
 *  	使用next方法获取下一个元素，如果没有元素可以获取，则出现NoSuchElementException
	
 */
public class IteratorDemo {
	public static void main(String[] args) {
		//method();
		//创建集合对象
		Collection c = new ArrayList();
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//获取迭代器对象
		Iterator it = c.iterator();
		
		//Object next()  :返回下一个元素
		//boolean hasNext()  ：判断是否有元素可以获取
		
		/*if(it.hasNext())
			System.out.println(it.next());
		if(it.hasNext())
			System.out.println(it.next());
		if(it.hasNext())
			System.out.println(it.next());
		if(it.hasNext())
			System.out.println(it.next());*/
		
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}

	private static void method() {
		//创建集合对象
		Collection c = new ArrayList();
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		//获取数组
		Object[] objs = c.toArray();
		//遍历数组
		for (int i = 0; i < objs.length; i++) {
			System.out.println(objs[i]);
		}
	}

	

}

4、并发修改异常

并发修改异常产生原因:

  当使用迭代器遍历集合的时候,使用了集合中的 增加/删除 方法,导致并发修改异常

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/*
 * 需求：判断集合中是否包含元素java，如果有则添加元素android
 * Exception in thread "main" java.util.ConcurrentModificationException:并发修改异常
 * 迭代器是依赖于集合的，相当于集合的一个副本，当迭代器在操作的时候，如果发现和集合不一样，则抛出异常
 * 
 * 解决方案:
 * 		你就别使用迭代器
 * 		在使用迭代器进行遍历的时候使用迭代器来进行修改
 */
public class IteratorDemo3 {
	public static void main(String[] args) {
		//method();
		
		//创建集合对象
		//Collection c = new ArrayList();
		List c = new ArrayList();
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//我们可以通过遍历来获取集合中的每一个元素，然后进行比较即可
		/*Iterator it = c.iterator();
		while(it.hasNext()) {
			String s = (String)it.next();
			if(s.equals("java")) {
				c.add("android");
			}
		}*/
		
		ListIterator lit = c.listIterator();
		while(lit.hasNext()) {
			String s = (String)lit.next();
			if(s.equals("java")) {
				lit.add("android");
			}
		}
		
		System.out.println(c);
	}

	private static void method() {
		//创建集合对象
		Collection c = new ArrayList();
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		//判断集合中是否包含元素java
		if(c.contains("java")) {
			c.add("android");
		}
		System.out.println(c);
	}

}

并发修改异常解决方案:

   A:不使用迭代器遍历集合,就可以在遍历的时候使用集合的方法进行增加或删除
   B:依然使用迭代器遍历,那么就需要使用Iterator的子接口ListIterator来实现向集合中添加

二、增强for&泛型

1、泛型

泛型的引入

   我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那
   么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且
   进行相应的操作，这时必须采用**类型转换**

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
 * 使用集合存储自定义对象并遍历
 * 由于集合可以存储任意类型的对象，当我们存储了不同类型的对象，就有可能在转换的时候出现类型转换异常，
 * 所以java为了解决这个问题，给我们提供了一种机制，叫做泛型
 * * 			
 */
public class GenericDemo {
	public static void main(String[] args) {
		//创建集合对象
		Collection  c = new ArrayList();
		//创建元素对象
		Student s = new Student("zhangsan",18);
		Student s2 = new Student("lisi",19);
		//添加元素对象
		c.add(s);
		c.add(s2);
		//遍历集合对象
		Iterator  it = c.iterator();
		while(it.hasNext()) {
			 String str = (String)it.next();
			 System.out.println(str);
			
	 
		}
	}
}

class Student {
	String name;
	int age;
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
}

以上代码会发生强制转换异常,原因就是String str = (String)it.next() ,存入集合的是Student,而强转为String,String与Student之间没有任何子父关系不能强转,未使用泛型前有可能发生强制转换异常的问题

泛型的使用

当类上定义<>的时候就可以使用泛型,例如ArrayList类的定义:
class ArrayList,那么我们在创建ArrayList对象的时候就可以指定<>中E的类型
ArrayList al=new ArrayList(),那么String就把E替换掉了

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
 * 使用集合存储自定义对象并遍历
 * 由于集合可以存储任意类型的对象，当我们存储了不同类型的对象，就有可能在转换的时候出现类型转换异常，
 * 所以java为了解决这个问题，给我们提供了一种机制，叫做泛型
 * 
 * 泛型：是一种广泛的类型，把明确数据类型的工作提前到了编译时期，借鉴了数组的特点
 * 泛型好处：
 * 			避免了类型转换的问题
 * 			可以减少黄色警告线
 * 			可以简化我们代码的书写
 * 
 * 什么时候可以使用泛型？
 * 		问API，当我们看到<E>，就可以使用泛型了
 * 			
 */
public class GenericDemo {
	public static void main(String[] args) {
		//创建集合对象
		Collection<Student> c = new ArrayList<Student>();
		//创建元素对象
		Student s = new Student("zhangsan",18);
		Student s2 = new Student("lisi",19);
		//添加元素对象
		c.add(s);
		c.add(s2);
		//遍历集合对象
		
		Iterator<Student> it = c.iterator();
		while(it.hasNext()) {
			//String str = (String)it.next();
			//System.out.println(str);
			
			Student stu = it.next();
			System.out.println(stu.name);
		}
	}
}

class Student {
	String name;
	int age;
	
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
}

增强for

增强for循环是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
格式：

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

它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

import java.util.ArrayList;
import java.util.Collection;

/*
 * foreach:增强for循环，一般用于遍历集合或者数组
 * 格式：
 * 		for(元素的类型 变量 : 集合或者数组对象) {
 * 			可以直接使用变量;
 * 		}
	注意：在增强for循环中不能修改集合，否则会出现并发修改异常。
	
	public interface Iterable<T>
	实现这个接口允许对象成为 "foreach" 语句的目标。

 */
public class ForEachDemo {
	public static void main(String[] args) {
		 //创建集合对象
		Collection<String> c = new ArrayList<String>();
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//增强for循环遍历集合
		/*for(Object obj : c) {
			System.out.println(obj);
		}*/
		
		
		/*for(String s : c) {
			System.out.println(s.toUpperCase());
		}*/
		
		for (String string : c) {
			c.add("android");
			System.out.println(string);
		}
	}
}

三、 常见的数据结构

1、数组

数组的特点：

数组的长度一旦定义则不可改变
数组中的元素都有整数索引
数组只能存储同一类型的元素
数组即可以存储基本数据类型，也可存储引用数据类型

如何获取数组元素

可以通过索引获取，arr[x];

想要在一个元素a后面添加一个新的元素b，该如何操作

首先创建一个新的数组，长度是原先数组长度+1
遍历原先的数组，并且插入到新的数组当中
当碰到元素a时，在元素a后面添加新的元素b
最后把剩余的元素添加到元素b后面即可

数组，采用该结构的集合，对元素的存取有如下的特点：

查找元素快：通过索引，可以快速访问指定位置的元素
增删元素慢 ,每次添加元素需要移动大量元素或着创建新的数组

2、链表

由链子链接起来的一堆结点
结点：

地址值，值，下一个结点地址值

链表，采用该结构的集合，对元素的存取有如下的特点：

A:多个节点之间，通过地址进行连接。
B:查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素
C:增删元素快：
增加元素：只需要修改连接下个元素的地址即可。
删除元素：只需要修改连接下个元素的地址即可

如何获取结点a？

只能遍历链表，一个一个查看

要在结点a后面添加一个新的结点b

把结点a的下一个结点地址值改为新结点b的地址值
把新结点b的下一个结点地址值改为原先链表中结点a的下一个元素的地址值

3、栈&队列

A:堆栈，采用该结构的集合，对元素的存取有如下的特点：

先进后出（即，存进去的元素，要在它后面的元素依次取出后，才能取
出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的
子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。

B:队列，采用该结构的集合，对元素的存取有如下的特点：

先进先出（即，存进去的元素，要在后前面的元素依次取出后，才能取
出该元素）。例如，安检。排成一列，每个人依次检查，只有前面的人全
部检查完毕后，才能排到当前的人进行检查。

在这里插入图片描述

4、List的子体系

List的子体系的特点：

A:有序的（存储和读取的顺序是一致的） 
B:有整数索引 
C:允许重复的

List的特有功能

void add(int index, E element) :将元素添加到index索引位置上
E get(int index) :根据index索引获取元素
E remove(int index) :根据index索引删除元素
E set(int index, E element):将index索引位置的的元素设置为element

import java.util.ArrayList;
import java.util.List;
/*
 * List:
 * 		有序的（存储和读取的顺序是一致的）
 * 		有整数索引
 * 		允许重复的
 * 
 * List的特有功能：
 * 			void add(int index, E element)  
 * 			E get(int index)  
 * 			E remove(int index)  
 *  		E set(int index, E element)
 *  
 *   增删改查
 

 *   
 */
public class ListDemo {
	public static void main(String[] args) {
		//创建的列表对象
		List list = new ArrayList();
		
		//void add(int index, E element)  : 在指定索引位置添加指定元素
		list.add(0, "hello");
		list.add(0, "world");
		list.add(1, "java");
		//[world,java,hello]
		//E get(int index)  :根据索引返回元素
		
		/*for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}*/
		
		//E remove(int index)  : 删除指定元素并返回
		
		//System.out.println(list.remove(5));
		
		//E set(int index, E element) : 将指定索引位置的元素替换为指定元素，并将原先的元素返回
		System.out.println(list.set(0, "android"));
		
		System.out.println(list);
	}
}

查找元素索引以及判断元素是否存在

import java.util.ArrayList;
import java.util.List;

/*
 * 需求：定义一个方法，返回指定列表中指定元素的索引位置
 * 
 * 判断元素是否存在
 * 
 */
public class ListTest {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("hello");
		list.add("world");
		list.add("java");
		
		//int index = index(list,"php");
		//System.out.println(index);
		
		//boolean flag = contains(list, "php");
		//System.out.println(flag);
		
		boolean flag = list.contains("php");
		System.out.println(flag);
	}
	
	public static int index(List list,Object other) {
		for(int x = 0;x < list.size();x++) {
			//获取列表中的元素
			Object obj = list.get(x);
			//使用列表中的元素和指定的元素进行比较
			if(obj.equals(other)) {
				return x;
			}
		}
		//查找不到指定的元素
		return -1;
	}
	
	public static boolean contains(List list,Object other) {
		//获取指定元素在指定列表中的索引位置
		int index = index(list,other);
		//如果索引位置大于等于0，则认为元素存在，否则不存在
		if(index >= 0) {
			return true;
		}
		else {
			return false;
		}
	}
	
	
	
}
mango_bobo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-加入泛型的线性表、栈、队列
05-04
对之前实现的JWList和JWArray加入泛型支持，最基本的都加入了对float、double、char、int类型的支持，支持自定义类型
数据结构 泛型
m0_58157267的博客
02-24 194
泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数 化。 泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译 器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。 泛型语法：（有两种） 1. class 泛型类名称<类型形参列表> { // 这里可以使用类型参数 } class ClassName<T1, T2, ..., Tn> { } 2. class 泛型类名称<类型形参列表>..
数据结构、泛型
weixin_44079478的博客
03-25 231
一. 数据结构 数据结构 : 数据用什么样的方式组合在一起。 1.1 常见数据结构 数据存储的常用结构有：栈、队列、数组、链表和红黑树。 1.1.1 栈 stack,又称堆栈，它是运算受限的线性表，其限制是仅允许在标的一端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。 特点: 1.先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。 例如，子弹压进弹夹...
数据结构算法——泛型
WXH0722的博客
07-23 210
泛型 泛型：和类型不相关 只关注算法的实现 一套算法可以处理任意的类型 Object 实现一个通用的顺序结构： 两点不好： 1.方法的返回值必须做类型的强转 2.类型强转时，没有类型的检查机制 泛型的优点： 1.类型检查 2.不用类型的强转 1.泛型编程的类型擦除机制是什么？ 编译器编译代码的过程中，用用户指定的具体类型，检查方法中所有的泛型参数，看类型是否匹配，如果不匹配，编译报错；如果匹配，最...
数据结构之初识泛型
Pigeon~的博客
07-25 151
泛型的分类 泛型：泛型类和泛型方法 泛型类的简单定义 尖括号<>是泛型的标志； T 是类型变量名，变量名一般大写； T 在定义时是形参，代表的是MyArrayList最终传入的数据类型。 public class MyArrayList<T> { //<T>只是一个占位符，表示当前类是一个泛型类 public T[] arr; public int size; } 泛型的意义： 可以自动进行类型的检查； 可以自动进行类型的转换 注意： 不能new泛型类型
JDataStructures:Java中使用泛型的本地数据结构
05-17
JDataStructures是使用Java泛型的本地数据结构库。 当我在大学学习数据结构时，泛型不存在。 当泛型最终可用时，我涉足了一些个人项目，但没有深入探讨。 使用泛型重新访问常见的数据结构是一种有趣的审查和学习方法...
Java基础知识点总结.docx
04-03
数据结构 273 Array方法类汇总 304 Java数组与集合小结 305 递归 309 对象的序列化 310 Java两种线程类：Thread和Runnable 315 Java锁小结 321 java.util.concurrent.locks包下常用的类 326 NIO（New IO） 327 ...
Java后端面试问题整理.docx
07-16
• 熟悉常用集合数据结构(数组、Hashmap、ConcurrentHashMap、HashTable、ArrayList、Vetor、LinkedList、HashSet、TreeSet、LinkedHashSet),了解AVL、RBtree、B/B+树、跳表 • 熟悉常见异常分类以及处理，熟悉反射...
java基础案例与开发详解案例源码全
04-04
1.3 Java平台的体系结构7 1.3.1 JavaSE标准版8 1.3.2 JavaEE企业版10 1.3.3 JavaME微型版11 1.4 JavaSE环境安装和配置12 1.4.1 什么是JDK12 1.4.2 JDK安装目录和实用命令工具介绍12 1.4.3 设置环境变量13 1.4.4 验证...
JAVA上百实例源码以及开源项目
01-03
　Java数据压缩与传输实例，可以学习一下实例化套按字、得到文件输入流、压缩输入流、文件输出流、实例化缓冲区、写入数据到文件、关闭输入流、关闭套接字关闭输出流、输出错误信息等Java编程小技巧。 Java数组倒置...
数据结构和算法-->泛型
weixin_33698043的博客
09-13 141
2019独角兽企业重金招聘Python工程师标准>>> ...
《数据结构与算法》之泛型——简单的泛型类和接口
漫步莱茵河畔的博客
10-21 213
当指定一个泛型类时，类的声明则包含一个或多个类型参数，这些参数被放在类名后面的一对尖括号内。例： public class Cell&lt;AnyType&gt; { private AnyType value; public AnyType read(){ return value; } public void write(AnyType x){ value=x;...
泛型—数据结构
m0_61963422的博客
09-21 198
泛型
java泛型数据结构详解_Java基础_泛型、数据结构
weixin_30465829的博客
02-27 159
泛型通配符：当使用泛型类或者泛型接口，传递的数据中，泛型的类型不确定，可以通过通配符>表示。一旦程序中使用泛型通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用通配符的基本使用：泛型的通配符：不知道使用什么类型来接收的时候，此时可以使用？ 问号代表未知的通配符此时只能接收数据，不能往该集合当中存储数据public static voidmain(String[]...
基本泛型数据结构
weixin_30722589的博客
10-13 65
数据结构： 计算机程序的灵魂 数据结构选取的好坏直接决定了算法效率的高低和实现的复杂程度 数据结构的组织与访问特性，决定了算法的选取与实现 List<T> 用数组保存数据 -数据项查找复杂度为O(n) -下标查找复杂度为O(1) 当数据空间不够时，扩大1陪空间 将数据从原有缓冲区复制到新的缓冲区中 带来O（n)的数据复制开销 最坏可能带来sizeof(T)*(...
C泛型__数据结构
WUDAIJUN的博客
11-01 1539
这里通过用C实现一个通用类型的栈结构来加深对数据结构和C指针的一些理解  同时也为一些C通用类型库函数(如排序)的实现提供一些思路 先写一个int 版本的栈用于比较: typedef struct { int* elem; int logicalLen; int allocLen; }stack; void StackNew(stack* s) { s
【数据结构】——泛型
weixin_62678196的博客
07-10 145
了解泛型
《数据结构与算法》之泛型——使用接口类型表示泛型
漫步莱茵河畔的博客
10-21 408
如：考虑再由一些项组成的数组中找出最大项的问题。基本的代码是类型无关的，但是它需要一种能力来比较任意两个对象。因此，不能直接找出Object的数组中的最大元素——我们需要更多的信息。最简单的方法就是找出Comparable的数组中的最大元。要确定顺序，可以使用compareTo方法，它对所有的Comparable都必然是现成可用的。 1、只有实现Comparable接口的那些对象才能够作为Com...
【Java】数据结构之泛型
博客
08-25 241
泛型的引入背景： 为了能够写一个类/方法就能同时支持多种不同类型的对象 所谓的泛型，其实就是从语法层面上对 Object 进行了一个简单的包装，编译过程帮我们自动加上一些编译器的类型检查，自动帮我们完成一些类型转换工作 举个例子： 定义一个泛型类 package com.Test0825; /** * Create with IntelliJ IDEA * Description: * User:Zyt * Date:2020-08-25 */ public class SeqL.
java泛型与常见数据结构
最新发布
12-05
Java泛型可以应用于各种数据结构，例如ArrayList、LinkedList、HashMap等。使用泛型可以使代码更加简洁、可读性更高、类型安全性更好。例如，使用泛型可以避免在运行时出现类型转换错误，从而提高代码的可靠性。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值