Java IO流

最新推荐文章于 2023-05-20 21:35:34 发布
最新推荐文章于 2023-05-20 21:35:34 发布
阅读量289 收藏 1
点赞数 1
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010184528/article/details/105232870
版权

目录

 

File

FileOutputStream

FileInputStream

单字节文件复制的实现（效率低）

批量字节文件复制的实现（效率高）

IO流中的序列化和反序列化

存储序列化对象到文件

深入理解ObjectInputStream和FileOutputStream，ObjectInputStream和FileInputStream

不被序列化的成员

序列化版本

字符流OutputStreamWriter和InputStreamReader

BufferedReader和BufferedWriter

File

Java文件类以抽象的方式代表文件名和目录路径名。该类主要用于文件和目录的创建、文件的查找和文件的删除等。

File对象代表磁盘中实际存在的文件和目录。

File中常用的几个方法：

public class Test {

	public static void main(String[] args) throws IOException {
		fileTest();
		
//		createFile();
	}

	private static void createFile() throws IOException {
		
		String pathString="/Users/sujianda/Desktop/";
		//创建文件 
		File dirFile=new File(pathString,"aa");
		dirFile.createNewFile();
		
		//创建文件夹
		File dirFile2=new File("/Users/sujianda/Desktop/bb");
		dirFile2.mkdir();
		
		//创建文件夹 多层
		File dirFile3=new File("/Users/sujianda/Desktop/cc/dd/ee");
		dirFile3.mkdirs();
		
	}

	private static void fileTest() {
		//测试file类型数据的方法
		
		String pathString="/Users/sujianda/Desktop/kotlin.docx";
		
		File file=new File(pathString);

		String []nameStrings=file.list();//获取目录下所有文件名
		File[]files=file.listFiles();//获取目录下所有文件
		
		System.out.println("文件名字："+file.getName());
		System.out.println("文件父目录："+file.getParent());
		System.out.println("文件完整路径："+file.getAbsolutePath());
		System.out.println("文件是否存在："+file.exists());
		System.out.println("是否是文件："+file.isFile());
		System.out.println("是否是文件夹："+file.isDirectory());
		System.out.println("文件字节量："+file.length());
		System.out.println("文件最后修改时间："+file.lastModified());
		
		Date date=new Date(file.lastModified());
        SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS" );
        String str = sdf.format(date);
        System.out.println("文件最后修改时间: "+str);

	}
}

FileOutputStream

FileInputStream

字节输出流FileOutputStream和字节输入流FileInputStream，分别继承OutputStream和InputStream，都是以字节的形式进行读写

public class Test4 {

	public static void main(String[] args) throws IOException {
		
		String pathString="/Users/sujianda/Desktop/test";
		
		write(pathString);//写字节数据到文件
		read(pathString);//从文件读取字节
		read2(pathString);//从文件读取字节
	}

	private static void write(String pathString)throws IOException  {
		//写字节到文件
		//文件不存在则创建，存在则覆盖，文件夹不存在则报错
		
		FileOutputStream outputStream=new FileOutputStream(pathString);
		
		outputStream.write(97);
		
		byte a[]= {101,102,103,104,105,106,107,108,109,127};
		outputStream.write(a,0,10);
		
		outputStream.close();//释放资源
	}
	
	private static void read(String pathString) throws IOException {
		FileInputStream inputStream=new FileInputStream(pathString);
		int i;
		//-1表示读取完毕
		while((i=inputStream.read())!=-1) {
			System.out.println(i);
		}
		
		inputStream.close();
	}

	private static void read2(String pathString) throws IOException {
		FileInputStream inputStream=new FileInputStream(pathString);
		
		byte[] a=new byte[1024];
		System.out.println("字节数组长度"+a.length);
		int j;
		while((j=inputStream.read(a))!=-1) {
			inputStream.read(a, 0, j);
		}
		System.out.println("字节数组内容"+Arrays.toString(a));
		
		inputStream.close();
	}
}

这里有两个方法需要解释一下：

  • read（）//单个字节读取，读取结束之后，返回-1
  • read（byte[]）//按照数组长度进行读取，读取一批数据，存到数组中，并且返回这一批字节的数量，读取结束之后，返回-1

用上面的代码进行举例：

	private static void read2(String pathString) throws IOException {
		FileInputStream inputStream=new FileInputStream(pathString);
		
		byte[] a=new byte[5];
		System.out.println("字节数组长度"+a.length);
		int j;//用来保存每一批读取的数量
		while((j=inputStream.read(a))!=-1) {
			System.out.println(j+"个："+Arrays.toString(a));
		}
		System.out.println("字节数组内容"+Arrays.toString(a));
		
		inputStream.close();
	}

执行结果：由此可见j表示每次读取数量，直到最后一次

101
102
103
104
105
106
107
108
109
127
字节数组长度5
5个：[97, 101, 102, 103, 104]
5个：[105, 106, 107, 108, 109]
1个：[127, 106, 107, 108, 109]
字节数组内容[127, 106, 107, 108, 109]

如果把数组长度设置大于或者等于字节总数的话：


	private static void read2(String pathString) throws IOException {
		FileInputStream inputStream=new FileInputStream(pathString);
		
		byte[] a=new byte[11];
		System.out.println("字节数组长度"+a.length);
		int j;//用来保存每一批读取的数量
		while((j=inputStream.read(a))!=-1) {
			System.out.println(j+"个："+Arrays.toString(a));
		}
		System.out.println("字节数组内容"+Arrays.toString(a));
		
		inputStream.close();
	}

执行结果：

97
101
102
103
104
105
106
107
108
109
127
字节数组长度11
11个：[97, 101, 102, 103, 104, 105, 106, 107, 108, 109, 127]
字节数组内容[97, 101, 102, 103, 104, 105, 106, 107, 108, 109, 127]

总结：如果数组长度小于文件的总字节数，按照数组长度进行循环读取，并进行覆盖之前的数据；

单字节文件复制的实现（效率低）

		System.out.println("请输入原始文件");
		String s1=new Scanner(System.in).next();
		File fromFile=new File(s1);
		if(!fromFile.isFile()) {
			System.out.println("请输入正确文件");
			return;
		}
		
		System.out.println("请输入目标文件");
		String s2=new Scanner(System.in).next();
		File toFile=new File(s2);
		if(!toFile.isFile()) {
			System.out.println("请指定具体文件");
			return;
		}
		
		try {
			copy(fromFile,toFile);//但字节文件复制
			System.out.println("复制完成");
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println("操作失败");
			e.printStackTrace();
		}
		
	}

	private static void copy(File fromFile,File toFile)throws IOException  {
		//但字节文件复制，效率低
		FileInputStream fileInputStream=new FileInputStream(fromFile);//原始文件是输入流
		FileOutputStream fileOutputStream=new FileOutputStream(toFile);//输出流到目标文件

		int n;
		while((n=fileInputStream.read())!=-1) {
			fileOutputStream.write(n);
		}
		
		fileInputStream.close();
		fileOutputStream.close();
	}

批量字节文件复制的实现（效率高）

	public static void main(String[] args) throws IOException {

		System.out.println("请输入原始文件");
		String s1=new Scanner(System.in).next();
		File fromFile=new File(s1);
		if(!fromFile.isFile()) {
			System.out.println("请输入正确文件");
			return;
		}
		
		System.out.println("请输入目标文件");
		String s2=new Scanner(System.in).next();
		File toFile=new File(s2);
		if(toFile.isDirectory()) {
			System.out.println("请指定具体文件");
			return;
		}
		
		try {
			copy(fromFile,toFile);//但字节文件复制
			System.out.println("完成");
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println("失败");
			e.printStackTrace();
		}
		
	}

	private static void copy(File fromFile,File toFile)throws IOException  {
		//批量字节文件复制，效率高
		FileInputStream fileInputStream=new FileInputStream(fromFile);//原始文件是输入流
		FileOutputStream fileOutputStream=new FileOutputStream(toFile);//输出流到目标文件

		int n;
		byte[]fileByte=new byte[8192];//数组8192个长度是最优数
		
		while((n=fileInputStream.read(fileByte))!=-1) {
			fileOutputStream.write(fileByte,0,n);
		}
		
		fileInputStream.close();
		fileOutputStream.close();
	}

IO流中的序列化和反序列化

在java中，要实现对象的序列化，必须实现Serializable，它是一个空接口（标识接口），只需继承实现；

  • 一个model类只有Serializable接口，才能对其实现序列化
  • 序列化是将对象状态转换为可保持或传输的格式（按照一定的格式，转化成一串字节序列）的过程；
  • 反序列化是把字节序列恢复为对象的过程称为对象；
  • 通过序列化和反序列化，可以实现对象的传递，存储和传输读取数据；
  • 对象的输入流用ObjectInputStream，对象到输出流用ObjectOutputStream

存储序列化对象到文件

深入理解ObjectInputStream和FileOutputStream，ObjectInputStream和FileInputStream

  • 首先对对象进行序列化
public class StudentModel implements Serializable{

	private String name;
	private String gender;
	private int age;
	private int number;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getNumber() {
		return number;
	}
	public void setNumber(int number) {
		this.number = number;
	}
	
	@Override
	public String toString() {
		return "名字是："+getName()
		+"  学号是："+getNumber()
		+"  性别是："+getGender()
		+"  年龄是："+getAge();
	}
  • 然后创建文件输出流FileOutputStream outputStream = new FileOutputStream("/Users/sujianda/Desktop/student.txt");
  • 然后创建对象输出流ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);

注：这里需要仔细主要流程

public class Test7 {

	public static void main(String[] args) {

		// 创建文件
		create();

		// 输出对象到文件中
		outToFile();

		// 读取文件内容到控制台
		readFile();
	}

	private static void create() {
		File file = new File("/Users/sujianda/Desktop/student.txt");
		try {
			file.createNewFile();

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private static void outToFile() {
		StudentModel studentModel = new StudentModel();
		studentModel.setName("苏苏");
		studentModel.setGender("女");
		studentModel.setAge(23);
		studentModel.setNumber(120331);

		try {
			// 创建文件输出流，到目标文件
			FileOutputStream outputStream = new FileOutputStream("/Users/sujianda/Desktop/student.txt");

			// 创建对象输出流，
			ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);

			// 把Student对象通过对象输出流写到文件
			objectOutputStream.writeObject(studentModel);
			objectOutputStream.close();

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private static void readFile() {
		try {
			ObjectInputStream fInputStream = new ObjectInputStream(
					new FileInputStream("/Users/sujianda/Desktop/student.txt"));
			StudentModel s1 = (StudentModel) fInputStream.readObject();
			System.out.println(s1.toString());
			fInputStream.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

执行输出结果：

  • 文件输出流new FileInputStream("/Users/sujianda/Desktop/student.txt")获取文件地址；
  • 对象输出流ObjectInputStream反序列化读取数据赋值给对象；

ObjectInputStream fInputStream = new ObjectInputStream(

new FileInputStream("/Users/sujianda/Desktop/student.txt"));

StudentModel s1 = (StudentModel) fInputStream.readObject();

不被序列化的成员

  • 静态成员 static不会序列化
  • 变量修饰符transient修饰的成员（只在程序运行期间，在内存中临时存在），不随对象一起序列化

假如上面StudentModel中的成员变量这样修饰

	private transient String name;
	private static String gender;
	private static int age;
	private int number;

在另一个Test8中执行输出

public class Test8 {

	public static void main(String[] args) {
		// 读取文件内容到控制台
		readFile();
	}

	private static void readFile() {
		try {
			ObjectInputStream fInputStream = new ObjectInputStream(
					new FileInputStream("/Users/sujianda/Desktop/student.txt"));
			StudentModel s1 = (StudentModel) fInputStream.readObject();
			System.out.println(s1.toString());
			fInputStream.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

执行结果是：

序列化版本

  • 为了保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性
  • 如果自己不定义，默认会根据类的定义信息，计算产生添加一个ID值，如下 Add generated serial version ID，它会随着类中数据的变化而变化，也可以自己加，自己修改

举个例子 原始版本是1L，通过运行上面的test7，进行赋值；

public class StudentModel implements Serializable{

	/**
	 * 原始版本
	 */
	private static final long serialVersionUID = 1L;
	
	private String name;
	private String gender;
	private int age;
	private int number;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getNumber() {
		return number;
	}
	public void setNumber(int number) {
		this.number = number;
	}
	
	@Override
	public String toString() {
		return "名字是："+getName()
		+"  学号是："+getNumber()
		+"  性别是："+getGender()
		+"  年龄是："+getAge();
	}
	
}

然后手动修改版本成2L，运行Test8，此时就会报错，两边版本不一致，无法恢复数据；

字符流OutputStreamWriter和InputStreamReader

  • 分别继承于Writer和Reader类（抽象父类）
  • 方法1 write（int c）;  int是4个字节，末尾2个字节是char类型字符数据，只处理末尾两个字节的输出；
  • 方法2 write（char [],from,length）;输出从from开始的length长度的字符数；
  • 方法3 write（String s）；输出字符串的全部字节
  • InputStreamReader 读取其他编码转换成java 的Unicode编码；
  • 把java 的Unicode编码转换成其他编码进行输出；

举例，实现按照规定编码格式，把数据进行文件写入，并从文件读取到控制台

//利用字符流进行编码转换,输出到文件上
public class Test9 {
	public static void main(String[] args) {
		String s="AaBbCc我是大帅哥123456";
		
		toGBK(s);//GBK编码格式写入
		toUTF8(s);//UTF-8编码格式写入
		
		readFromGBK();//读取
		System.out.println();
		readFromUTF8();
	}

	private static void toGBK(String s) {
		try {
			File file=new File("/Users/sujianda/Desktop/test_GBK");
			FileOutputStream out = new FileOutputStream(file);
			OutputStreamWriter outputStreamWriter=new OutputStreamWriter(out,"GBK");
			outputStreamWriter.write(s);
			outputStreamWriter.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	private static void toUTF8(String s) {

		try {
			File file=new File("/Users/sujianda/Desktop/test_utf8");
			FileOutputStream out = new FileOutputStream(file);
			OutputStreamWriter outputStreamWriter=new OutputStreamWriter(out,"UTF-8");
			outputStreamWriter.write(s);
			outputStreamWriter.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	private static void readFromUTF8() {
		try {
			FileInputStream in=new FileInputStream("/Users/sujianda/Desktop/test_utf8");
			
			InputStreamReader inputStreamReader=new InputStreamReader(in,"UTF-8");
			
			int n;
			while((n=inputStreamReader.read())!=-1) {
				System.out.print(n+"  ");
			}
			
			inputStreamReader.close();
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private static void readFromGBK() {
		try {
			FileInputStream in=new FileInputStream("/Users/sujianda/Desktop/test_GBK");
			
			InputStreamReader inputStreamReader=new InputStreamReader(in,"GBK");
			
			int n;
			while((n=inputStreamReader.read())!=-1) {
				System.out.print(n+"  ");
			}
			
			inputStreamReader.close();
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

BufferedReader和BufferedWriter

  • 为了提高字符流读写的效率，引入了缓冲机制，进行字符批量的读写，提高了单个字符读写的效率。BufferedReader用于加快读取字符的速度，BufferedWriter用于加快写入的速度

    BufferedReader和BufferedWriter类各拥有8192个字符的缓冲区。当BufferedReader在读取文本文件时，会先尽量从文件中读入字符数据并放满缓冲区，而之后若使用read()方法，会先从缓冲区中进行读取。如果缓冲区数据不足，才会再从文件中读取，使用BufferedWriter时，写入的数据并不会先输出到目的地，而是先存储至缓冲区中。如果缓冲区中的数据满了，才会一次对目的地进行写出。

    BufferedReader
    BufferedReader是为了提供读的效率而设计的一个包装类，它可以包装字符流。可以从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

  • reader.readLine()方法返回的一行字符中不包含换行符,所以输出的时候要自己加上换行符

小小苏的小小苏
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
JAVA I/O流
爱学习的小段的博客
05-08 506
I/O流概述 字节流 字符流 File类 RandomAccessFile类 NIO NIO.2
一文详解JAVA的字节流，BufferedReader和BufferedWriter
最新发布
2301_77899321的博客
01-15 1446
Java的字节流是一种用于处理二进制数据的输入输出流。在Java中，字节流以字节为单位进行读取和写入操作。字节流分为输入字节流和输出字节流。
Bufferedreader与Bufferedwriter的基本使用
天青色 等烟雨的博客
01-16 629
Bufferedreader与Bufferedwriter的基本使用BufferedreaderBufferedwriter import java.io.*; public class IOTest { public static void main(String[] args) { //高效缓冲输入流 BufferedReader reader = null; try { //传入的是reader的子类
节点流和处理流 字符处理流BufferedReader、BufferedWriter，字节处理流-BufferedInputStream和BufferedOutputStream (代码均正确且可运行
weixin_73936404的博客
05-20 930
节点流和处理流 对象处理流-ObjectInputStream和ObjectOutputStream字符处理流BufferedReader、BufferedWriter，字节处理流-BufferedInputStream和BufferedOutputStream (代码均正确且可运行）
Java学习笔记之BufferedReader与BufferedWriter
pecuyu
07-13 6567
为了提高字符流读写的效率，引入了缓冲机制，进行字符批量的读写，提高了单个字符读写的效率。BufferedReader用于加快读取字符的速度，BufferedWriter用于加快写入的速度
java IO流详细笔记
07-12
Java IO流详解
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
javaIO流javaIO流javaIO流
07-02
Java IO流是Java平台中用于处理输入输出操作的核心机制，它允许程序与各种数据源（如文件、设备、网络）进行交互。Java IO流体系结构是基于“流”的概念，流是一组有序的数据序列，可以是字节流或字符流。Java IO库...
java IO流文件的读写具体实例
09-04
Java IO流是Java平台中用于处理输入输出的重要机制，它允许程序与各种数据源和目的地进行交互，包括文件、网络连接、系统硬件等。在Java中，IO流分为四个主要类别，分别是字节流（处理二进制数据）、字符流（处理...
Java IO流 文件传输基础
09-02
Java IO流是Java平台中用于处理输入输出的重要机制，它涉及到数据从源到目标的传输。文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，...
BufferedReader 和BufferedWriter 实例
07-26
NULL 博文链接：https://lisanlai.iteye.com/blog/673253
java 使用BufferedReader、BufferedWriter实现文本文件的复制；
景上 的博客
11-24 4078
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class BufferedReader
BufferedReader&BufferedWriter
Gao__xi的博客
03-16 405
BufferedReader&BufferedWriter package com.gao.xi; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundExc...
BufferedReader和BufferedWriter
weixin_44332466的博客
05-09 310
BufferedReader和BufferedWriter （有一个需要注意地地方）： 读不会修改文件，所以同一个文件可以声明多个reader来读， 但是写会修改文件，所以在对一个file绑定了writer之后，不能再读了，也不能再声明其它writer到这个file，所以可以说writer是独占的，如果你调试一下 可以发现，在声明writer之后，file所指定的文件内容会变成空， 所以你将BufferedWriter writer = new BufferedWriter(new FileWrite
IO中的BufferedWriter和BufferedReader以及读取时出现乱码的问题
weixin_43353498的博客
04-08 482
IO中的BufferedWriter和BufferedReader以及读取时出现乱码的问题 BufferedWriter作用: 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 其有哪些方法: close() : 关闭此流，但要先刷新它。 flush() : 刷新该流的缓冲。 newLine() : 写入一个行分隔符。 write(char[]...
BufferedReader和BufferedWriter的区别 及用法
脾气古怪的兔子的专栏
07-13 2743
BufferedReader和BufferedWriter大致来说就是一个属于读取字符串一个属于写入字符串。  java.io.BufferedReader和java.io.BufferedWriter类各拥有8192字符的缓冲区 当BufferedReader进行读取字符串时
IO流之BufferedWriter和BufferedReader原理研究
瘦子没有夏天
06-10 1476
BufferedWriter和BufferedReader的定义 BufferedWriter “缓存字符输出流”，内置一个缓存字符数组，每次写入前都会先检查缓存数组，是否已满，满了把缓存数组写入。否则将内容放到缓存数组中去。 newLine()方法 “换行方法” BufferedReader “缓存字符输入流”，内置一个缓存字符数组，每次读取都会先去缓冲数组中读取，如果已读完，则会在家流...
BufferedWriter 和 BufferedReader 的基本用法
HeatDeath的博客
03-08 5425
http://blog.csdn.net/liuhenghui5201/article/details/8279557“>BufferedWriter 和 BufferedReader 的基本用法，附演示程序。以及一个复制文本文件的程序 BufferedWriter 和 BufferedReader 为带有默认缓冲的字符输出输入...
javaio流电子书整理面试必考io流帮助你入职阿里腾讯
03-12
"Java IO流是Java编程中用于处理输入输出操作的重要概念，涉及数据的持久化、存储介质和各种应用场景。本电子书主要讲解了IO流的基础知识，包括流的概念、分类、IO流体系，以及InputStream和OutputStream的使用。书...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小小苏的小小苏

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

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

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

打赏作者

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

抵扣说明：

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

余额充值