稳稳当当学java之文件和IO二(19）

最新推荐文章于 2024-07-21 22:27:18 发布
最新推荐文章于 2024-07-21 22:27:18 发布
阅读量155 收藏
点赞数
分类专栏： 笔记 大数据 文章标签： java stream eclipse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42405054/article/details/108377242
版权

第二十一章 文件和IO二

1.作业回顾

1，编写程序，在E盘创建一个目录test，再创建一个子目录abc，在abc中创建一个文件test.txt，使用输出流将往test.txt中写一个字符串，然后再使用输入流，将test.txt中的文本读到程序中。

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Day20HomeWork {
	public static void main(String[] args) {
		
		FileWriter fw = null;
		
		try {
			fw = new FileWriter("C:/test/abc/test.txt");
			fw.write("我爱你中国！");
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				fw.flush();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {	
				fw.close();
			} catch (IOException e) {
				e.printStackTrace();
			}	
		}
		
		FileReader fr = null;
		try {
			fr = new FileReader("C:/test/abc/test.txt");
			int c = 0;//保存读到的字符
			while(-1 != (c = ( fr.read() ))) 
				System.out.println((char)c);
			
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {	
				fr.close();
			} catch (IOException e) {
				e.printStackTrace();
			}	
		}		
	}			
}

2，编写程序，在控制台输入源文件路径和目标文件路径，实现任意文件的复制。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class Day20HomeWork2 {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		System.out.println("请输入源文件路径");
		String src = s.nextLine();
		System.out.println("请输入目标文件路径");
		String dest = s.nextLine();
		
		File srcFile = new File(src);
		File destFile = new File(dest);
		if (!srcFile.exists()) {
			System.out.println("源文件不存在");
		}else {
			FileInputStream fis = null;
			FileOutputStream fos = null;
			try {
				fis = new FileInputStream(srcFile);
				fos = new FileOutputStream(destFile);
				
				byte[] bs = new byte[256];
				int len = 0;
				
				while(-1 != ( len = fis.read()) ) {
					fos.write(bs, 0, len);
				}
				
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			} finally {
				try {
					fis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				try {
					fos.flush();
				} catch (IOException e) {
					e.printStackTrace();
				}
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}		
	}
}

2.节点流和过滤流

2.1节点流和过滤流介绍

直接和数据源（文件，内存块，网络）相连接的流是节点流，否则就是过滤流。

过滤流相当于 在节点流上加了一个流。

节点流和过滤流示意图：
在这里插入图片描述

节点流:

FileReader：以字符读文件

FileWriter：以字符写文件

FileInputStream：以字节读文件

FileOutputStream： 以字节写文件

CharArrayReader：以字符读字符数组

CharArrayWriter：以字符写字符数组

StringReader：以字符读字符串

StringWriter：以字符写字符串

ByteArrayInputStream：以字节读字节数组

ByteArrayOutputStream：以字节写字节数组

过滤流：

BufferedReader：以字符读缓冲区

BufferedWriter：以字符写缓冲区

BufferedInputStream：以字节读缓冲区

BufferedOutputStream：以字节写缓冲区

InputStreamReader：以字节输入流转换为字符输入流

OutputStreamWriter：以字符输出流转换为字节输出流

ObjectInputStream：以字节读对象

ObjectOutputStream：以字节写对象

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Day2103 {
	public static void main(String[] args) {
		FileReader fr = null;
		BufferedReader br = null;
		
		try {
			fr = new FileReader("C:/test/abc/test.txt");
			//将fr包装成一个缓冲过滤流
			//缓冲过滤流内部有一个缓冲区，可以提高IO效率
			//装饰者模式
			br = new BufferedReader(fr);
			
			int c = 0;
			while(-1 != ( c = br.read() )) {
				System.out.print((char)c);//中国你好
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//只需要关闭最外层的流
			//外层流关闭时会关闭内层流
			try {
				br.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;

public class Day2104 {
	public static void main(String[] args) {
		BufferedWriter bw = null;

		try {
			bw = new BufferedWriter(new FileWriter("C:/test/abc/test.txt"));
			bw.write("我爱你中国");

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				bw.flush();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				bw.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

3.以指定编码读写文件

import java.nio.charset.Charset;

public class Day2105 {
	public static void main(String[] args) {
		//获取默认字符集
		Charset charset = Charset.defaultCharset();
		System.out.println(charset);//UTF-8
	}
}

3.1使用GBK读取文件

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;

public class Day2106 {
	public static void main(String[] args) {
		FileInputStream fis = null;
		//过滤流，可以包装一个字节流，获得一个字符流，采用指定的编码方式进行转换
		InputStreamReader isr = null;
		BufferedReader br = null;
		
		try {
			fis = new FileInputStream("C:/test/abc/test.txt");
			
			//将字节流以GBK编码转换为字符流
			isr = new InputStreamReader(fis, "GBK");
			
			br = new BufferedReader(isr);
			
			String str = null;
			while(null != (str = br.readLine())) {
				System.out.println(str);
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				br.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

3.2使用UTF-8写入文件

import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class Day2107 {
	public static void main(String[] args) {
		FileOutputStream fos = null;
		OutputStreamWriter osw = null;
		BufferedWriter bw = null;
		
		try {
			fos = new FileOutputStream("C:/test/abc/test.txt");
			osw = new OutputStreamWriter(fos, "UTF-8");
			bw = new BufferedWriter(osw);
			
			bw.write("哆啦A梦");
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				bw.flush();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				bw.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}	
	}
}

4.对象的序列化和反序列化一

对象的序列化是将对象保存到外部存储（文件，数据库，网络）。

对象的反序列化是将外部存储（文件，数据库，网络）转换为对象。

为了将对象进行序列化和反序列化，必须实现Serializable接口。Serializable接口是一个标志接口，并没有方法。

4.1将对象保存在外部存储

import java.io.Serializable;
//为了进行序列化和反序列化，必须实现Serializable接口
public class Student implements Serializable{
	private String name;
	private int age;
	
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Day2108 {
	public static void main(String[] args) {
		Student s1 = new Student("张三", 20);
		FileOutputStream fos = null;
		ObjectOutputStream oos = null;
		
		try {
			fos = new FileOutputStream("C:/test/abc/Student.ser");
			//过滤流，将一个对象写到输出流中
			oos = new ObjectOutputStream(fos);
			
			//将对象s1写到输出流中
			oos.writeObject(s1);
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				oos.flush();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				oos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}	
	}
}

4.2将外部存储转换为对象

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Day2109 {
	public static void main(String[] args) {
		FileInputStream fis = null;
		ObjectInputStream ois = null;
		
		try {
			fis = new FileInputStream("C:/test/abc/Student.ser");
			//过滤流，可以从输入流中取读对象
			ois = new ObjectInputStream(fis);
			
			//读取到的对象实际是Student类型的对象，因此可以进行强制类型转换
			Student s = (Student) ois.readObject();
			System.out.println(s.getName());//张三
			System.out.println(s.getAge());	//20
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}finally {
			try {
				ois.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

5.对象的序列化和反序列化二

5.1 transient关键字

如果不想序列化某个字段，可以使用transient关键字

import java.io.Serializable;
//为了进行序列化和反序列化，必须实现Serializable接口
public class Student implements Serializable{
	private String name;
	//transient表示不对此字段进行序列化和反序列化
	//瞬时——不必持久化
	private transient int age;
	
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
		//反序列化不会调用构造器
		System.out.println("Student构造器");
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}

5.2 序列化链

序列化时，如果一个对象的字段也是对象，那么这个字段也会序列化。

注意：所有需要序列化的对象都必须实现Serializable接口。

import java.io.Serializable;
//为了进行序列化和反序列化，必须实现Serializable接口
public class Student implements Serializable{
	private String name;
	//transient表示不对此字段进行序列化和反序列化
	//瞬时——不必持久化
	private transient int age;
	
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
		//反序列化不会调用构造器
		System.out.println("Student构造器");
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}

	public void setTeacher(Teacher t1) {
	}
}

import java.io.Serializable;

public class Teacher implements Serializable {
	private String name;
	private int age;
	private String school;
	
	public Teacher(String name, int age, String school) {
		super();
		this.name = name;
		this.age = age;
		this.school = school;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getSchool() {
		return school;
	}
	public void setSchool(String school) {
		this.school = school;
	}
	
	@Override
	public String toString() {
		return "Teacher [name=" + name + ", age=" + age + ", school=" + school + "]";
	}
}

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Day2108 {
	public static void main(String[] args) {
		Student s1 = new Student("张三", 20);
		Teacher t1 = new Teacher("张三丰", 200, "清华");
		s1.setTeacher(t1);
		
		FileOutputStream fos = null;
		ObjectOutputStream oos = null;
		
		try {
			fos = new FileOutputStream("C:/test/abc/Student.ser");
			//过滤流，将一个对象写到输出流中
			oos = new ObjectOutputStream(fos);
			
			//将对象s1写到输出流中
			oos.writeObject(s1);
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				oos.flush();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				oos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}	
	}
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Day2109 {
	public static void main(String[] args) {
		FileInputStream fis = null;
		ObjectInputStream ois = null;
		
		try {
			fis = new FileInputStream("C:/test/abc/Student.ser");
			//过滤流，可以从输入流中取读对象
			ois = new ObjectInputStream(fis);
			
			//读取到的对象实际是Student类型的对象，因此可以进行强制类型转换
			Student s = (Student) ois.readObject();
			System.out.println(s.getName());//张三
			System.out.println(s.getAge());	//20
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}finally {
			try {
				ois.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

6.Properties文件的使用

java.util.Properties类代表一个java配置文件。

java配置文件以.properties结尾，可以将配置参数。

如数据库连接地址放入到配置文件中，而不使用硬编码。

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class Day2110 {
	public static void main(String[] args) {
		//props代表了一个配置文件
		Properties props = new Properties();
		
		//将配置文件的信息加载到props对象中
		//Day2110.class是一个类对象
		//java中的每一个类一旦加载到jvm中，就会产生一个类对象
		//类对象描述了类的信息（有什么方法，有什么属性）
		//类对象有一个方法getResourceAsStream可以从classpath路径下加载文件
		//java从classpath下加载类
		//每个类只被加载一次，每个类只有一个类对象
		
		InputStream is = null;
		
		//将流中的数据加载到props对象中
		is = Day2110.class.getResourceAsStream("/day21/db.properties");
		
		try {
			props.load(is);
			//props.getProperty方法通过key得到value
			System.out.println(props.getProperty("username"));//name
			System.out.println(props.getProperty("password"));//1234
			
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				is.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}	
	}
}

7.练习

以指定的编码读取文件内容，并将读到的内容以指定的编码写文件，两种编码都配置到properties文件中。

十年之伴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
稳稳当当学java之Collection和List(16)
weixin_42405054的博客
08-27 159
第十八章 Collection和List 1.作业回顾 //写一个TestException类，在main方法中接受两个命令行参数， //将他们转换成整数，并用第二个数除以第一个数，打印结果。 //测试一下情况，某个参数不是数字(异常1)，第二个参数为0.(异常2) public class Day17HomeWork { public static void main(String[] args) { System.out.println(args[0]);//1 System.out.prin
稳稳当当学java之抽象类和接口(11)
weixin_42405054的博客
06-09 718
第十三章 抽象类和接口 1.作业回顾 1，编写一个Person类，包括属性（name、age），有参构造器、方法say(返回自我介绍的字符串）。 2.编写一个Student类，继承Person类，增加sno、score属性，以及有参构造器，在子类中调用父类的构造器。 3.编写一个方法showInfo(返回自我介绍的字符串）。 ////1.编写一个Person类，包括属性（name、age），有参构造器、方法say(返回自我介绍的字符串）。 public class Person { //属性（name、
稳稳当当学java之文件和IO一(18)
weixin_42405054的博客
09-01 175
第二十章 文件和IO一 1.作业回顾 1，编写程序，在main方法中接受5个整数，创建TreeSet类型的集合，将5个整数添加到集合中，使用foreach遍历该集合。提供一个比较器，然后对于集合中的整数进行从大到小的顺序进行排序。然后使用Iterator进行迭代。 import java.util.Comparator; import java.util.Scanner; import java.util.TreeSet; public class Day19HomeWork { public stat
稳稳当当学java之枚举和异常(15)
weixin_42405054的博客
08-23 223
第十七章 枚举和异常 1.作业回顾 //1，写一个方法判断字符串是否对称。对称的字符串。"abcdefgfedcba" public class Day16HomeWork { public static boolean f1(String str) { char[] arrs = str.toCharArray(); for (int i = 0; i < arrs.length / 2; i++) { if(arrs[i] != arrs[arrs.length - 1 - i
稳稳当当学java之java程序设计基础二(3)
weixin_42405054的博客
05-25 129
java程序设计基础二 1.作业回顾 public class Day051 { public static void main(String[] args) { //(1)16MB有多少字节？ //(2)16869000字节是多少MB？ // 1MB = 1024KB = 1024*1024B System.out.println(16 * 1024 * 1024); //16777216 System.out.println(16869000 / (1024 * 1024)); /
稳稳当当学java之java编程入门(1)
weixin_42405054的博客
05-23 248
java编程入门 一.程序设计介绍 程序设计又称为编程，就是开发软件，软件也成为程序。软件包含了指令。计算机不像人类，它总是被动的执行指令。 软件开发人员使用编程语言（如java）开发软件。 编程语言分为三种：机器语言，汇编语言，高级语言。 机器语言是低级语言，是一套指令集，它是计算机能够理解并执行的。指令都是以二进制代码形式存在。如0101010001 使用机器语言做两个数相加：110111001011101 计算机能理解并执行二进制指令，但是对于软件开发人员来说，编写二进制指令非常困难，因此创建了汇编语
稳稳当当学java之Set、泛型和Map(17)
weixin_42405054的博客
08-31 195
19第十九章 Set、泛型和Map 1. 作业回顾 1.从键盘随机输入10个整数，保存到List中，并按照倒序排序，从大到小的顺序显示出来。 import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; import java.util.Scanner; public class Day18HomeWork { public static void
稳稳当当学java之循环(5)
weixin_42405054的博客
05-28 327
第七章 循环 1.作业回顾 1，男大当婚，女大当嫁。如果女方家长要嫁女儿，当然要提出一定的条件。高：180cm以上；富：财富1千万以 上；帅：是。如果这三个条件同时满足，则：输出我一定要嫁给他， 如果三个条件中有为真的情况，则：比上 不足，比下有余，嫁吧 如果三个条件都不满足，则：不嫁。 import java.util.Scanner; public class Day071 { public static void main(String[] args) { /*3，男大当婚，女大当嫁。如果女方
稳稳当当学java之常用类(13)
weixin_42405054的博客
08-20 251
第十五章 常用类 1.作业回顾 编写一个比较器AreaComparator比较实现了Areable接口的任意图形的面积，Circle，Rectangle等等。 编写一个测试类AreaComparatorTest来测试任意图形面积的比较结果。 public interface Areable { double getArea(); } class Rectangle implements Areable{ private double x; private double y; public Re
稳稳当当学java之枚举和异常(15).md
08-23
本人的笔记，关于java基础中常用类的内容 包括 1.作业回顾 2.枚举 3.异常的基本概念 3.1 异常的传播 3.2 使用finally执行代码 4.异常体系 5.自定义异常 5.1 使用运行时异常 5.2 使用受检查异常 6.练习
稳稳当当学java之数组(7)
06-01
本人的笔记，关于Java基础中数组的内容 包括 1.作业回顾 2.数组的概念 3.创建，初始化，和访问数组 4.遍历数组 5.基本数据类型和引用数据类型的区别 6.使用Arrays类 7练习
稳稳当当学java之继承(10)
06-05
本人的笔记，关于java基础中继承的内容 包括 1.作业回顾 2.成员变量的初始值 3.对象初始化 4.继承 5.子类对象的实例化过程 6.继承的规则一 7.练习
稳稳当当学java之java程序设计基础二(2).md
05-29
本人的笔记，关于java程序设计基础二里的内容 包括 1.作业回顾 2.二进制，bit和字节 3.八种基本数据类型 4.数据类型的转换 5.算数运算符 6.自增自减运算符 7.比较运算符 8.逻辑运算符 9.三目运算符 10.练习
Java-Lambda
最新发布
lizhiwei21的博客
07-21 173
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 492
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1140
JVM-垃圾回收与内存分配
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1169
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1065
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

十年之伴

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

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

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

打赏作者

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

抵扣说明：

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

余额充值