【疯狂Java讲义】Java学习记录（IO流）

最新推荐文章于 2024-05-20 11:15:42 发布
最新推荐文章于 2024-05-20 11:15:42 发布
阅读量1k 收藏 2
点赞数 1
分类专栏： 疯狂Java 文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/have_to_be/article/details/132534699
版权

IO流

IO：Input / Output

完成输入 / 输出

应用程序运行时——数据在内存中                        ←→                把数据写入硬盘（磁带）

                                内存中的数据不可持久保存

输入：从外部存储器（硬盘、磁带、U盘）把数据读入内存中。

输出：从内存中把数据写入外部存储器（硬盘、磁带、U盘）中，这样就可以保证，即使程序退出了，数据依然不会丢失。

File —— 代表磁盘上的文件或目录

listRoot：列出磁盘上所有的根目录

exists：判断是否存在

mkdir：创建目录

listFiles（）：列出当前目录下所有的文件和子目录

listFiles（FileFilter filter）：列出当前目录下符合指定条件的文件和子目录

listFiles（FilenameFilter filter）

列出某个磁盘所有的文件——递归

import java.io.File;

public class ListE {

	public static void main(String[] args) {
		// 创建一个File，它代表了E盘
		File e = new File("e:/Program Files");
		
		List(e);
	}
	
	public static void List(File dir) {
		System.out.println(dir + "目录下包含的文件和子目录有：");
		// 该方法返回当前目录所包含的所有文件和子目录
		File[] files = dir.listFiles();
		
		for (File file : files) {
			System.out.println("	" + file);
			// 如果file是目录，继续列出该目录下所有文件
			if (file.isDirectory()) {
				List(file);
			}
		}
	}
}

 列出某个磁盘所有的.txt文件——递归

import java.io.*;

public class FileFilterTest {

	public static void main(String[] args) {
		File e = new File("e:/");
		
		// 返回当前目录所包含的所有*.txt文件，此时就需要对文件进行过滤
		File[] files = e.listFiles(new FileFilter() {
			// pathname就代表正在处理的文件，如果该方法返回true，意味着该文件就被保留，否则该方法将会被过滤掉
			@Override
			// 没有比IOExcepiton更小的，所以只能用try catch
			public boolean accept(File pathname) {
				// 说明文件名以.txt结尾
				try {
					if (pathname.getCanonicalPath().endsWith("txt")) {
						return true;
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
				return false;
			}
		});
		
		for (File file : files) {
			System.out.println(file);
		}
	}
}

File的特征：只能访问磁盘上的文件和目录，它无法访问文件内容。

如果要访问文件的内容，必须使用IO流。

流的分类

1、按流的方向来分（从程序所在内存的角度来看）

（1）输入流

把外部输入读入当前程序所在内存

（2）输出流

把当前程序所在内存的数据输出到外部

2、按流处理的数据来分

（1）字节流

处理数据单位是字节（8bit），适应性广、功能强大

（2）字符流

处理的数据单元是字符。通常来说它主要用于处理文本文件

在处理文本文件时，比字节流方便

3、按流的角色来分

（1）节点流

直接和一个IO的物理节点（磁盘上的文件、网络）关联

（2）包装流（处理流 / 过滤流）

以节点为基础，包装之后得到的流

都继承了FilterXxx等基类

流的概念模型

输入流中的数据单元放入应用程序；应用程序中的数据单元放入输出流。

缓冲流

外部存储器的速度比内存的速度慢，外部存储器的读写与内存的读写并不同步

——通过缓冲就可以解决这种不同步

反正你把流用完了，

- 别忘记调用flush方法（把缓冲中的内容刷入实际的节点）

             调用close()也可——系统会在关闭之前，自动刷缓冲

IO流一共涉及40多个类

字节流字符流
节点流InputStreamOutputStreamReaderWriter抽象
FileInputStreamFileOutputStreamFileReaderFileWriter访问文件
ByteArrayInputStreamByteArrayOutputStreamCharArrayReaderCharArrayWriter数组
PipedInputStreamPipedOutputStreamPipedReaderPipedWriter访问管道
StringReaderStringWriter访问字符串
缓冲流BufferedInputStreamBufferedOutputStreamBufferedReaderBufferedWriter缓冲
FilterInputStreamFilterOutputStreamFilterReaderFilterWriter抽象
PrintStreamPrintWriter打印
InputStreamReaderOutputStreamWriter转换
DataInputStreamDataOutputStream特殊

所有以InputStream结尾的都是字节输入流

所有以OutputStream结尾的都是字节输出流

所有以Reader结尾的都是字符输入流

所有以Writer结尾的都是字符输出流

1、FileInputStream 

import java.io.*;
public class FileInputStreamTest {
	public static void main(String[] args) throws IOException {
		// 创建输入流，相当于得到一根有水的水管
		FileInputStream fis = new FileInputStream("D:\\Program Files\\eclipse-java-2023-06-R-win32-x86_64\\workplace\\day\\src\\day13\\FileInputStreamTest.java");
		
		// System.out.print((char)fis.read());// 该方法每次只读一个字节
		
		/*
		 * 为了把fis中水滴全部“取出”内存，有两个做法：
		 * 1、用大桶
		 * 2、用循环
		 */
		byte[] buff = new byte[64]; // 我的水桶可以装64个“水滴”
		int hasRead = -1;
		//hasRead = fis.read(buff);// 用“桶”从fis（水管）中取水
		while((hasRead = fis.read(buff)) > 0) {
			// 上一次读取了几个字节，此处就输出几个字节
			System.out.println(new String(buff, 0 ,hasRead));
		}
	}
}

运行结果： 

 2、FileOutputStream

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamTest {
	public static void main(String[] args) {
		FileOutputStream fos = null;
		try {
			// 得到输出流，相当于得到一个没有水滴的水管
			fos = new FileOutputStream("abc.txt");
			fos.write(97); // 每次输出"一个字节“
			fos.write(98);
			fos.write(99);
			fos.write(100);
			fos.write(101);
			
			fos.write("自由、民主的普世价值观～".getBytes());
		} catch (IOException ex) {
			ex.printStackTrace();
		} finally {
			try {
				fos.close();
			} catch (Exception ex) {
				ex.printStackTrace();
			}
		}

运行结果： 

复制文本文件

import java.io.*;
public class CopyTest {
	public static void main(String[] args) {
		// JDK 7提供了自动关闭资源的try语句
		try (
			// 创建输入流，得到一个有水滴的水管
			FileInputStream fis = new FileInputStream("D:\\Program Files\\eclipse-java-2023-06-R-win32-x86_64\\workplace\\day\\src\\day13\\CopyTest.java");
			// 创建输出流，得到一个空水管
			FileOutputStream fos = new FileOutputStream("D:\\Program Files\\eclipse-java-2023-06-R-win32-x86_64\\workplace\\day\\src\\day13\\test.txt"); 
		)
		{
			int hasRead = -1;
			byte[] buff = new byte[128];
			
			// 从fis里读取水滴，放入buff中
			while((hasRead = fis.read(buff)) > 0) {
				// 将buff中水滴写入fos，hasRead用于控制：读了多少，就写多少
				fos.write(buff, 0, hasRead);
			}
			
		} catch (IOException ex) {
			ex.printStackTrace();
		}
	}
}

运行结果： 

节点流直接与IO节点关联

——IO节点有很多：键盘、网络、文件、磁带……

过滤流：建立在节点流的基础之上

        过滤流的好处：

        ——消除底层节点之间的差异

        ——使用过滤流的方法执行IO更加便捷

                FileOutputStream →PrintStream

                              FileWriter→PrintWriter

                         如果已经知道要读的内容是字符内容，就可按如下方式转换：

                         InputStream→InputStreamReader→BufferedReader

1、 FileOutputStream →PrintStream

import java.io.*;

public class PrintStreamTest {
	public static void main(String[] args) {
		try (
			// 创建节点流，节点流使用不方便
			FileOutputStream fos = new FileOutputStream("D:\\Program Files\\eclipse-java-2023-06-R-win32-x86_64\\workplace\\day\\src\\day13\\my.txt"); 
			// 把节点流包装成过滤流：消除节点流的差异，而且PrintStream的方法更加方便
			PrintStream ps = new PrintStream(fos);		
		)
		{
			ps.println("我想");
			ps.println("我想早");
			ps.println("我想早点");
		} catch (Exception ex) {
			ex.printStackTrace();
		} 
	}
}

运行结果： 

3、DataInputStream与DataOutputStream

它们是两个特殊的流——它们是过滤流（建立在已有IO的基础之上）

——它们只要增加一些特定的方法来读取特定的数据。

import java.io.*;
public class DataOutputStreamTest {
	public static void main(String[] args) {
		try (
			// 创建节点流——与磁盘上的文件关联
			FileOutputStream fos = new FileOutputStream("price.txt");
			
			// 创建过滤流，过滤流建立在节点流的基础上
			DataOutputStream dos = new DataOutputStream(fos);
		)
		{
			dos.writeDouble(3.4);
			dos.writeDouble(5.23);
			dos.writeDouble(4.34);
			dos.writeDouble(5.12);
		} catch (Exception ex) {
			ex.printStackTrace();
		}	
	}
}

运行结果：

import java.io.*;
public class DataInputStreamTest {
	public static void main(String[] args) {
		try (
			// 先创建节点流，与指定物理节点（文件）建立读写
			FileInputStream fis = new FileInputStream("price.txt");
			
			// 以节点流来创建过滤流
			DataInputStream dis = new DataInputStream(fis);
		)
		{
			System.out.println(dis.readDouble());
			System.out.println(dis.readDouble());
			System.out.println(dis.readDouble());
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

运行结果：

重定向标准输入输出

System.in——标准输入。通常代表键盘。

System.out——标准输出。通常代表屏幕。

System.setOut() ——可以将标准输出重定向另一个输出流。

import java.io.*;
public class SetOutTest {
	public static void main(String[] args) throws Exception{
		// 可以将标准输出重定向到指定的输出流
		System.setOut(new PrintStream("out.txt"));
		
		System.out.println("ABC");
		System.out.println("ABC");
		System.out.println("ABC");
		System.out.println("ABC");
	}
}

运行结果：输出的内容重定向到out.txt文本文件中 

System.setIn() ——可以将标准输出重定向另一个输入流。

import java.io.*;
public class RedirectKeyIn {
	public static void main(String[] args) throws Exception {
		// 将标准输入重定向到RedirectKeyIn.java
		System.setIn(new FileInputStream("RedirectKeyIn.java"));
		
		//System.in，它是一个节点流，一般关联着物理键盘
		//直接用System.In(InputStream——节点、字节、输入流）可以读取键盘输入
		//缺点是：太繁琐、而且效率相当低下
		//System.out.println(System.in.read());
		
		InputStreamReader reader = new InputStreamReader(System.in);
		
		BufferedReader br = new BufferedReader(reader);
		
		String line = null;
		// 控制BufferedReader每次读取一行
		while ((line = br.readLine()) != null) {
			System.out.println(line);
		}
	}
}

运行结果：

Java虚拟机读取其他进程的数据 

Java如何启动其他进程：Runtime实例.exec()

该方法的返回值是一个Process对象

Process——代表一个进程。

                    进程就是运行中的应用程序。

import java.io.*;
public class ReadFromProcess {
	public static void main(String[] args) throws Exception{
		
		Runtime runtime = Runtime.getRuntime();
		
		// 启动javac应用程序，返回该应用程序对应的进程
//		Process proc = runtime.exec("javac.exe -encoding UTF8 -d . ReadFromProcess.java");
		Process proc = runtime.exec("javac.exe -encoding UTF8 -d . ReadFromProcess");
		
		// 要得到javac应用程序输出的内容，此处应该用输入流？还是输出流？
		// 对于javac来说，是输出；但对于我们应用程序来说，用输入流
		InputStreamReader reader = new InputStreamReader(proc.getErrorStream());
		BufferedReader br = new BufferedReader(reader);
		
		String line = null;
		
		StringBuilder sb = new StringBuilder();
		
		// 控制BufferedReader每次读取一行
		while ((line = br.readLine()) != null) {
			//System.out.println(line);
			sb.append(line);
		}
		
		// 如果有错误输出
		if (sb.toString().length() > 0) {
			System.out.println("编译出错，错误信息如下----");
			// 输出错误提示
			System.out.println(sb);
		} else {
			System.out.println("成功完成----");
		}
	}
}

上面为“编译出错”的代码，下面为“成功完成”的代码 

RandomAccessFile——随意（任意）访问文件

Random——想访问文件的哪个点，就访问文件的哪个点（任意）

RandomAccessFile实现了Closeable接口，所以可以使用自动关闭资源的try语句。

特征

1、既可读、又可写、还可追加。相当于InputStream与OutputStream合体。

      RandomAccessFile它不会覆盖原有的文件内容。

2、只能访问文件！这就是它的局限性。

import java.io.*;
public class RandomAccessFileTest {
	public static void main(String[] args) {
		try (
			// 使用RadomAccessFile创建一个只读的输入流
			RandomAccessFile raf = new RandomAccessFile("RandomAccessFileTest.java", "r");
		)
		{
			byte[] buff = new byte[1024];
			int hasRead = -1;
			while ((hasRead = raf.read(buff)) > 0) {
				System.out.println(new String(buff, 0, hasRead));
			}
			
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

创建RandomAccessFile，需要指定读（r）、写（rw）模式

体现它的“random【任意】”性的方法

seek(long pos)——用于把记录指针移动到任意位置，想访问哪个点就访问哪个点。

一开始，它的记录指针位于文件的开始位置。

使用RandomAccessFile来追加文件内容

1、把记录指针移动到最后

2、执行输出即可

import java.io.RandomAccessFile;

public class AppendTest {
	public static void main(String[] args) {
		try (
				// 使用RadomAccessFile创建一个只读的输入流
				RandomAccessFile raf = new RandomAccessFile("AppendTest.java", "rw");
			)
			{
				// 把记录指针移动到文件的最后
				raf.seek(raf.length());
				raf.write("//做人好累".getBytes());	
			} catch (Exception ex) {
				ex.printStackTrace();
			}
	}
}

使用RandomAccessFile来插入文件内容

1、把记录指针移动到指定位置

2、从当前位置到文件结尾的内容，先读取，并保存

3、输出要插入的内容

序列化

Java对象（内存）->二进制流

目的

1、在有些时候，需要把对象存储到外部存储器中持久化保存。

2、在有些时候，需要把对象通过网络传输。

可序列化的对象

Java要求序列化的类实现下面任意两个接口

1、Serializable：接口只是一个标记性的接口，实现该接口无需实现任何方法

2、Externalizable：实现该接口要实现方法。

序列化的IO流

  ObjectInputStream——负责从二进制流“恢复”对象。readObject

ObjectOutputStream——负责把对象保存到二进制流中。writeObject

import java.io.*;
class Apple implements Serializable{
	private String name;
	private String color;
	private double weight;
	
	public Apple() {
		super();
	}

	public Apple(String name, String color, double weight) {
		super();
		this.name = name;
		this.color = color;
		this.weight = weight;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getColor() {
		return color;
	}
	
	public void setColor(String color) {
		this.color = color;
	}
	
	public double getWeight() {
		return weight;
	}
	
	public void setWeight(double weight) {
		this.weight = weight;
	}
	
	public String toString() {
		return "Apple[name=" 
				+ name +",color=" + color
				+ ",weight=" + weight + "]";
	}
}

public class WriteObject {
	public static void main(String[] args) {
		Apple ap = new Apple("红富士", "红色", 3.4);
		System.out.println(ap);
		
		// 当程序结束时，虚拟机退出，内存中的Apple对象就被销毁了
		try (
			ObjectOutputStream oos = new ObjectOutputStream(
					new FileOutputStream("app.bin"));
		) 
		{
			oos.writeObject(ap); //把ap对象写入app.bin文件中
		}
		catch (Exception ex) {
			// TODO: handle exception
		}
	}
}

import java.io.*;
public class ReadObject {
	public static void main(String[] args) {
		try (
			ObjectInputStream ois = new ObjectInputStream(
					new FileInputStream("app.bin"));
		)
		{
			Apple ap = (Apple)ois.readObject();
			System.out.println(ap);
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

序列化机制

总结

Java传统IO的基本体系

字节输入流字节输出流字符输入流字符输出流
访问文件InputStreamOutputStreamReaderWriter
访问数组FileXxx
访问管道ByteArrayXxxCharArrayXxx
访问字符串StringXxx
过滤流FilterInputStreamFilterOutputStreamFilterReaderFilterWriter
打印流PrintStreamPrintWriter
转换流InputStreamReaderOutputStreamWriter
特殊流DataInputStreamDataOutputStream
ObjectInputStreamObjectOutputStream

RandomAccessFile

1、它只能访问文件。相当于DataInputStream和DataOutputStream组合

2、任意，由seek(int pos)。

have_to_be
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
疯狂Java讲义 第3版 PDF电子书下载 带书签目录 完整版.rar
07-09
本书深入介绍了Java编程的相关方面，全书内容覆盖了Java的基本语法结构、Java的面向对象特征、Java集合框架体系、Java泛型、异常处理、JavaGUI编程、JDBC数据库编程、Java注释、Java的IO流体系、Java多线程编程、...
疯狂Java讲义第五版读书笔记
weixin_50527711的博客
05-17 815
疯狂Java讲义第五版读书笔记 文章目录疯狂Java讲义第五版读书笔记第一章：Java语言概述与开发环境1.1、Java程序运行机制1.2、Java第一个程序1.3、Java命名规范1.3.1、包命名1.3.2、类命名、接口命名、抽象命名1.3.3、方法命名、变量命名第二章：面向对象2.1、程序设计的三种结构2.1.1、顺序结构2.1.2、选择结构2.1.3、循环结构2.2、面向对象的设计简介2.2.1、简要描述：2.2.2、 类的简单定义2.2.3、面向对象与面向过程2.2.4、面向对象三大基本特征2.
【社区图书馆】疯狂 Java 讲义：但凡种种，不一而足
我在山城重庆，我希望能为这片软件沙漠地带贡献自己的一滴水，Stay tuned!
06-16 1070
疯狂Java讲义（第6版）（上下册）》是由著名IT畅销书作家李刚所著的关于Java语言的权威书籍。本书的新版本在原有基础上增加了更多实例和案例，使得读者更容易理解和掌握该编程语言。此书主要面向想要学习Java编程的初、中级程序员以及对编程有兴趣的人群。该书在国内外广受好评，是Java学习必备之书。这一段真的是太官方了，一般你随便看一个书籍介绍，基本都会来上这么一段风格的文章，不管书怎样，先氛围搞起来的意思。
《疯狂Java讲义》（第5版） 李刚
热门推荐
墨雨的博客
05-12 3万+
第1章 Java语言概述与开发环境、 1.1 Java语言的发展简史 JDK1.0 : Sun在1996年年初发布了JDK 1.0，该版本包括两部分：运行环境（即JRE）和开发环境（即JDK）。运行环境包括核心API、集成API、用户界面API、发布技术、Java虚拟机（JVM）5个部分；开发环境包括编译Java程序的编译器（即javac命令）。 JDK1.1 ： Sun在1997年2月18日发布了JDK 1.1，该版本增加了JIT（即时编译）编译器。 JDK 1.2 : 1998年12月Su
疯狂java讲义第二章课后习题答案
yaoguaiba579567的博客
11-17 458
疯狂java讲义这一章并没有配套练习题，我在这里设置几题。
疯狂JAVA讲义
10-17
学生提问：老师，我想学习Java编程，到底是学习Eclipse好呢，还是学习JBuilder好呢？ 21 1.9 本章小结 22 本章练习 22 第2章 理解面向对象 23 2.1 面向对象 24 2.1.1 结构化程序设计简介 24 2.1.2 程序的三种...
疯狂Java讲义代码
04-02
《疯狂Java讲义》深入介绍了Java编程的相关方面，全书内容覆盖了Java的基本语法结构、Java的面向对象特征、Java集合框架体系、Java泛型、异常处理、Java GUI编程、JDBC数据库编程、Java注释、Java的IO流体系、Java多...
Java进阶IO流讲义大全.docx
09-09
Java进阶IO流讲义大全.docx
疯狂Java讲义 第3版 完整版（Part3）
01-11
本书深入介绍了Java编程的相关方面，全书内容覆盖了Java的基本语法结构、Java的面向对象特征、Java集合框架体系、Java泛型、异常处理、Java GUI编程、JDBC数据库编程、Java注释、Java的IO流体系、Java多线程编程、...
FME学习之旅---day27
summer_corner的博客
05-17 191
我们付出一些成本，时间的或者其他，最终总能收获一些什么。
使用多实例学习进行乳腺癌组织病理学图像分类和定位
qq_47896523的博客
05-16 1082
乳腺癌是女性最主要的死亡原因，病理学家根据病理切片中观察到的各种视觉特征（例如细胞核的形态特征、细胞核的微观和宏观结构等）做出决定。计算机辅助诊断（CAD）系统可以帮助病理学家自动做出决策。卷积神经网络是最广泛使用的深度学习框架，用于学习图像类别之间的复杂判别特征。多年来，VGG16 [3] 和 ResNet18 [4] 等各种 CNN 架构在海量 ImageNet 数据集上产生了出色的结果。CNN 被用于医学图像以产生最先进的结果。为图像中存在的所有类别提供了定位信息。
Page对象的学习
2301_77523055的博客
05-14 1000
ASP.NET允许开发者创建自定义控件和用户控件来扩展页面的功能。自定义控件是从现有的ASP.NET控件派生出来的新控件，而用户控件则是将多个控件组合成一个可重用的单元。这些控件可以像其他ASP.NET控件一样在页面上使用，并通过Page对象进行交互。Page_Init主要用于在控件加载之前进行初始化设置和添加事件处理程序。Page_Load主要用于处理页面回发和加载数据，以及执行其他需要在页面加载时完成的逻辑。由于Page_Init在Page_Load之前触发，因此在Page_Init。
学习kong官方文档
好好学习日记
05-17 270
当然，我会用更简洁的方式重新解释这两个概念：Helm和Kubectl是Kubernetes生态系统中常用的两个工具，它们各自有不同的用途：
在学习uni-app过程中使用的css样式记录
最新发布
qq_34080064的博客
05-20 554
​在学习uni-app过程中，记录下使用的css样式，持续更新。
推荐系统学习笔记（一）
weixin_44880995的博客
05-15 143
同类策略（精排中的两种模型）天然互斥，并且（两条召回通道）效果会相互影响，避免干扰。反转：有的指标立刻影响，有的需要长期观测-------尽快推全也可以长期观测。10%作为holdout桶，实验使用剩余的90%，做diff（需要归一化）不同策略（添加召回通道，优化粗排模型）通常不会干扰，可以作为正交的两层。保留10%，完全不受实验影响，可以考察整个部门对业务指标的贡献。同层互斥----避免一个用户被两个实验影响。不同层正交----每层独立随机分配用户。推全：新层，与其他层正交，90%用户。
RustGUI学习（iced/iced_aw）之扩展小部件（十九）：如何使用context_menu部件来创建右击菜单？
用沸腾的热血，支付我们的人生吧！
05-15 65
本专栏是学习Rust的GUI库iced的合集，将介绍iced涉及的各个小部件分别介绍，最后会汇总为一个总的程序。iced是RustGUI中比较强大的一个，目前处于发展中（即版本可能会改变），本专栏基于版本0.12.1.
DB类的学习
2301_77523055的博客
05-15 364
"不返回结果集" 意味着执行 SQL 语句后，你不会得到一个可以逐行读取的数据集。相反，你可能会得到一个表示受影响的行数的整数，或者只是一个表示命令是否成功执行的确认。
docker学习和常用命令
OutRoading的博客
05-14 181
镜像仓库datahub。
java疯狂讲义 第三版
08-31
总之，《Java疯狂讲义》第三版是一本经典的Java编程入门教材，适合初学者系统学习和掌握Java编程语言。无论是对于想要从零开始学习编程的初学者，还是对于有一定编程基础的人来说，这本书都是一份宝贵的学习资料。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值