文件和流

最新推荐文章于 2021-08-31 09:27:01 发布
最新推荐文章于 2021-08-31 09:27:01 发布
阅读量91 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39225571/article/details/99685618
版权 

#### 第一节 File类

#####1.1 File类作用

java.io包中 (IO Input Output)
在java程序中，对磁盘文件进行描述的类。文件和目录路径名的抽象表示形式。


#####1.2 File类的常用构造方法

| 方法名                               | 描述                                       |
| --------------------------------- | ---------------------------------------- |
| File(File parent, String child)   | 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。 |
| File(String pathname)             | 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。       |
| File(String parent, String child) | 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。 |

#####1.3 File类文件属性方法

属性：

```java
static String pathSeparator：与系统有关的路径分隔符，为了方便，它被表示为一个字符串（;）。
static char pathSeparatorChar：;
static String Separator：与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串（\）。
static char SeparatorChar：\

//分号
System.out.println(File.pathSeparator);
System.out.println(File.pathSeparatorChar);
//反斜杠
System.out.println(File.separator);
System.out.println(File.separatorChar);

方法：

返回值方法名/描述
booleancanExecute() 测试应用程序是否可以执行此抽象路径名表示的文件。
booleancanRead() 测试应用程序是否可以读取此抽象路径名表示的文件。
booleancanWrite() 测试应用程序是否可以修改此抽象路径名表示的文件。
intcompareTo(File) 按字母顺序比较两个抽象路径名。
booleanexists() 测试此抽象路径名表示的文件或目录是否存在。
booleancreateNewFile() 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建个新的空文件。
booleandelete() 删除此抽象路径名表示的文件或目录。
FilegetAbsoluteFile() 返回此抽象路径名的绝对路径名形式。
StringgetAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
FilegetCanonicalFile() 返回此抽象路径名的规范形式。
StringgetCanonicalPath() 返回此抽象路径名的规范路径名字符串。
StringgetName() 返回由此抽象路径名表示的文件或目录的名称。
StringgetParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
FilegetParentFile() 返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录则返回 null。
StringgetPath() 将此抽象路径名转换为一个路径名字符串。
booleanisDirectory() 测试此抽象路径名表示的文件是否是一个目录。
booleanisFile() 测试此抽象路径名表示的文件是否是一个标准文件。
booleanisHidden() 测试此抽象路径名指定的文件是否是一个隐藏文件。
String[]list() 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
booleanmkdir() 创建此抽象路径名指定的目录。
booleanmkdirs() 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
booleanrenameTo(File dest) 重新命名此抽象路径名表示的文件。
File[]listFiles() 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

代码实现一：

		File file = new File("d:\\a.txt");//创建一个文件对象，表示d盘的a.txt文件
		System.out.println(file.canExecute());
		System.out.println(file.canWrite());
		System.out.println(file.canRead());
		System.out.println(file.isHidden());

代码实现二：

		File file = new File("d:\\a");
		File f = new File("d:\\b.txt");
		System.out.println(file.compareTo(f));
		//exists方法：判断文件抽象路径表示的文件或目录是否存在
		System.out.println(file.exists());
		//createNewFile方法：创建一个新的空文件（若存在则创建失败）
		System.out.println(f.createNewFile());
		//delete方法：只能删除文件和空文件夹，非空文件夹不能使用delete方法删除
		System.out.println(f.delete());
		System.out.println(file.delete());

代码实现三：

public class Demo {
	public static void main(String[] args) throws IOException {
		//现有d:\\a\\b\\hello.txt
		//要求：在hello.txt相同的目录下创建出一个world.txt文件
		File f1 = new File("d:\\a\\b\\hello.txt");
		System.out.println(f1.getPath());
		fun(f1);
	}
	//设计一个方法，在某个文件的相同目录下创建出一个新文件（新建文本文档.txt）
	/*
	 * 分析：
	 * 		返回值：不需要
	 * 		参数：一个File对象
	 * getParent方法
	 * createNewFile方法
	 * 构造方法
	 */
	public static void fun(File file) throws IOException {
		//获取父路径
		String parent = file.getParent();
		//创建File对象
		File f = new File(parent, "新建文本文档.txt");
		//创建新文件
		f.createNewFile();
	}
}

代码实现四：

		File file = new File("d:\\a\\hello.txt");
		System.out.println(file.exists());
		System.out.println(file.isDirectory());//判断一个File对象是否是文件夹
		System.out.println(file.isFile());//判断一个File对象是否是文件
		String[] files = file.list();//获取文件夹中所有子文件夹和文件的名称（字符串形式）
		System.out.println(files.length);
		for(String s:files) {
			System.out.println(s);
		}
		File[] fs = file.listFiles();//获取文件件中所有子文件夹和文件的抽象路径（File对象）
		System.out.println(fs.length);
		for(File f:fs) {
			System.out.println(f);
		}
		File file = new File("d:\\aa\\bb\\cc\\dd\\a.txt");
		//在创建一个文件时，需要先判断父目录是否存在，若不存在则创建父目录
		File parent = file.getParentFile();
		if(!parent.exists()) {
			System.out.println(parent.mkdirs());//创建一个新的空文件夹
		}
		System.out.println(file.createNewFile());

		//对文件重命名
		File file = new File("d:\\a.txt");
		File f = new File("a.txt");	
		File f1 = new File("hello\\hello.txt");
		System.out.println(file.renameTo(f));//将file表示文件重命名为f时，必须保证file是存在的文件
		System.out.println(f.renameTo(f1));
1.4 File类的练习

练习1：代码实现：

public class FileUsageDemo02 {

	public static void main(String[] args) {
		String string  = "C:\\Users\\Administrator\\Desktop\\HZ-J2ee1709\\Day16";
		method1(string);
      	method2(string);
	}
	
	//需求一：列出指定目录下所有子文件夹以及子文件
	public static void method1(String path) {
		File file = new File(path);
		
		//list
		//子文件或者子文件夹的名称
		String[] arr = file.list();
		
		for(String str:arr) {
			System.out.println(str);
		}
	}
	
	/**
	 * 需求二：列出指定目录下所有子文件夹以及子文件，要求格式如下：
	 * 子文件：   isFile()
	 * 。。。。
	 * 子文件夹：isDirectory()
	 * 。。。。
	 */
	public static void method2(String path) {
		File file = new File(path);
		
		//获取指定路径下所有File对象
		//listFiles()
		File[] files = file.listFiles();
		
		for(File f:files) {
			if(f.isFile()) {
				System.out.println("子文件：");
				//获取每个文件的名字
				System.out.println(f.getName());
			} else if(f.isDirectory()) {
				System.out.println("子文件夹：");
				System.out.println(f.getName());
			}
		}
	}
	
	//需求：列出指定目录下所有后缀为.java的文件
	public static void method3(String path) {
		//endsWith
		File file = new File(path);
		
		String[] arr = file.list();
		
		for(String str:arr) {
			if(str.endsWith(".java")) {
				System.out.println(str);
			}
		}
	}
}

练习2：（1）列出文件夹中所有的子文件夹和文件，包括子文件夹中文件和文件夹

​ （2）递归删除文件夹

package com.qf.day17;

import java.io.File;
import java.lang.reflect.Field;
/**
 * 1 列出文件夹中所有的子文件夹和文件，包括子文件夹中文件和文件夹
 * @author wgy
 *
 */
public class Demo3 {
	public static void main(String[] args) {
		//listFiles(new File("d:\\图片"));
		deleteDir(new File("c:\\"));
	}
	//1 列出文件夹中所有的子文件夹和文件，包括子文件夹中文件和文件夹
	public static void listFiles(File dir) {
		System.out.println(dir.getAbsolutePath());
		File[] files=dir.listFiles();
		if(files!=null&&files.length>0) {
			for (File file : files) {
				if(file.isDirectory()) {
					//递归
					listFiles(file);
				}else {
					System.out.println(file.getAbsolutePath());
				}
			}
		}
	}
	//2递归删除文件夹
	public static void deleteDir(File dir) {
		File[] files=dir.listFiles();
		if(files!=null&&files.length>0) {
			for (File file : files) {
				if(file.isDirectory()) {
					deleteDir(file);
				}else {
					//删除文件
					System.out.println(file.toString()+"-----"+file.delete());
				}
			}
		}
		//删除文件夹
		System.out.println(dir.toString()+"*********"+dir.delete());
	}
}

####第二节 IO流

#####2.1 什么是IO流（Input、Output）

	在工作中，经常会操作磁盘上的资源，这个过程中实现了数据的输入和输出操作，磁盘上的文件和内存之间进行交互，数据的交互需要有一个媒介或者管道，把这个媒介或者管道就称为IO流，也被称为输入输出流【I:Input  O:Output】
输入：从外部存储设备到内存叫输入|读取。
输出: 从内存到外部存储设备叫输出|写入。

#####2.2 流的作用和原理

	流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

#####2.3 IO流的种类

2.3.1 按照流的流向分：输入流、输出流

输入流：表示将数据读取到java程序（内存）中使用的流。

输出流：表示从java程序（内存）向外传输使用的流。

2.3.2 按照处理数据单位分：字节流、字符流

字节流：一次性传输一个字节数据，将数据以字节的形式传输。

字符流：一次性传输一个字符（utf-8编码1、2或3个字节）数据，将数据以字符的形式传输。

2.3.3 按照功能分：节点流、处理流

节点流：可以从或向一个特定的地方(节点)读写字节数据。

处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。

#####2.4 字节输入流

2.4.1 InputStream类的常用方法

InputStream是一个抽象类，不能实例化对象。
方法名描述
void close()关闭此输入流并释放与该流关联的所有系统资源。
int read()从输入流中读取数据的下一个字节。
int read(byte[] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中。
int read(byte[] b,int off, int len)将输入流中最多len个数据字节读入 byte 数组。

2.4.2 文件输入流FileInputStream

public class DemoFileInputStream {
	public static void main(String[] args) {
		//创建被操作文件：此文件必须存在，否则读取时，抛出文件找不到异常
		File file = new File("test\\hello.txt");
		//声明流，不初始化
		FileInputStream fis = null;
		try {
			//初始化流
			fis = new FileInputStream(file);
			//准备数组用来存储数据
			byte[] b = new byte[3];
			//先定义一个变量，初始值是-1
			int i = -1;
			//定义一个计数循环的变量
			int count = 0;
			//while循环读取
			while((i=fis.read(b))!=-1) {
				count++;
				for(int j=0; j<i; j++) {
					System.out.print((char)b[j]);
				}
			}
			System.out.println(count);//计数：计算循环读取的次数
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if(fis!=null) {
				try {
					fis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}	
	}
}

#####2.5 字节输出流

2.5.1 OutputStream类的常用方法

OutputStream是抽象类，不能实例化对象。
方法名描述
void close()关闭此输出流并释放与此流有关的所有系统资源。
void flush()刷新此输出流并强制写出所有缓冲的输出字节。
void write(byte[] b)将 b.length 个字节从指定的 byte 数组写入此输出流。
void write(byte[] b,int off, int len)将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
void write(int b)将指定的字节写入此输出流。

2.5.2 文件输出流FileOutputStream

public class TestFileOutputStream {
	public static void main(String[] args) {
		//向文件中写入数据
		//在工程中创建一个test文件夹
		//设计程序，向test\\hello.txt中写入hello world
		//第一步：创建被操作文件对象
		//当向一个文件中写入数据时，若文件不存在，程序会自动创建
		File file = new File("test\\hello.txt");
		FileOutputStream fos = null;
		try {
			//第二步：创建流对象
			fos = new FileOutputStream(file, true);
			//第三步：准备数据
			String str = "hello world";
			byte[] b = str.getBytes();
			System.out.println(b.length);
			//第四步：使用流写入
			fos.write(b);
		}catch(IOException e) {
			e.printStackTrace();
		} finally {
			if(fos!=null) {
				try {
					//第五步：刷新流，关闭流
					fos.flush();
					fos.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}
2.6 字符输入流

Reader类

Reader：是所有字符输入流的父类，为一个抽象类，不能实例化对象，使用它的子类FileReader类

public class FileReaderUsageDemo {
	public static void main(String[] args) {
		//1.将文件的路径转换为File对象
		File file = new File("file/input1.txt");
		Reader reader = null;
		
		try {
			//2.实例化一个FileReader的对象
			reader = new FileReader(file);
			
			//3.定义一个数组
			char[] arr = new char[8];
			
			//4.定义一个int的变量
			int hasRead = 0;
			
			//5.循环读取
			while((hasRead = reader.read(arr)) != -1) {
				String result = new String(arr, 0, hasRead);
				System.out.println(result);
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		finally {
			//避免出现空指针异常
			if(reader != null) {
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}
2.7 字符输出流

Writer类

Writer：是所有字符输出流的父类，为一个抽象类，不能实例化对象，使用它的子类FileWriter类

public class FileWriterUsageDemo {

	public static void main(String[] args) throws IOException {
		File file = new File("file/output1.txt");
		
		Writer writer = new FileWriter(file);
		
		//写入
		//注意：区别于字节流，可以直接传字符串
		writer.write("天边最美的云彩");
		
		writer.flush();//立即写入硬盘
		
		writer.close();
	}
}
扩展案例：

1使用字节流复制文件

边读边写

// 1 使用字节流复制文件
	public static void copy1() throws Exception{
		//1创建字节文件输入输出流
		InputStream is=new FileInputStream("d:\\003.jpg");
		OutputStream os=new FileOutputStream("d:\\004.jpg");
		//2读、写
		byte[] buf=new byte[1024*4];
		int len=0;
		while((len=is.read(buf))!=-1){
			//buf缓冲区,0从第一个位置写，len写的长度
			os.write(buf,0,len);
		}
		//3关闭
		is.close();
		os.close();
		System.out.println("复制完成");
	}

2使用字符流复制文件

//2使用字符流复制文件
	
	public static void copy2() throws Exception{
		//1创建字符输入输出流
		Reader reader=new FileReader("d:\\003.jpg");
		Writer writer=new FileWriter("d:\\005.jpg");
		//2读写
		char[] buf=new char[1024*4];
		int len=0;
		while((len=reader.read(buf))!=-1){
			writer.write(buf, 0, len);
		}
		//3关闭
		reader.close();
		writer.close();
		System.out.println("复制完成");
		
	}

如果复制的文件是文本文件 ，用字节流和字符流都可以

如果复制的文件是图片、音乐、电影, 用字符流复制会不会出现问题? 使用字节流

总结
1 File类，表示硬盘上的文件或文件夹
	1>创建对象，文件或文件夹不一定存在
	2>判断是否存在 exists();
	3>把文件或文件夹创建出来,  createNewFile()   mkdir()  mkdirs();
	4>删除   delete();  deleteOnExit();
	5>获取   绝对路径、规范路径、文件或文件夹名、最后修改时间
    6>判断是文件还是文件夹  isDirectory()  isFile()  isHidden 
    7>遍历文件夹中内容  list()
    8>判断文件的可执行、可读取、可写入
2>1递归显示文件夹中所有文件、2递归删除
 
3IO流 
  流---》管道
  分类: 
  	按照方向分：输入流和输出流
  	按照读取的字节个数：字节流和字符流
  	按照功能分：节点流 （负责读写数据）、处理流 （封装）
  流的使用
    字节输入流  InputStream----->FileInputStream
    字节输出流  OutputStream----->FileOutputStream
    字符输入流  Reader----->InputStreamReader---->FileReader
    字符输出流  Writer----->OutputStreamWriter--->FileWriter
how__125
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
文件与流
xx
03-28 590
文件：存储在外部介质上数据的集合。1.在C语言中一个输入输出流就是一个字节流或者二进制流。2.在C语言中文件由一连串的字节组成，中间没有分隔符，对文件的存取以字节为单位。输入输出的数据流的开始和结束仅受程序控制，而不受物理符号控制，如回车换行符。这种文件称为流式文件。 （和java中各种包的理念一样，底层是C C++，大概就是这样吧？以后有待探讨。）3.文件标识（文件名） = 文件路径 + 文件名
C#文件和流操作
07-28
使用FileStream fs = new FileStream(path, FileMode.OpenOrCreate)方法可以创建文件流，path是文件的路径，FileMode.OpenOrCreate表示如果文件不存在则创建文件，如果文件存在则打开文件。 2、读取文件流 使用fs....
文件和文件流
热门推荐
zhangjin2024的博客
08-08 2万+
文件和文件流 1. File类 Java.io.File类可以获取文件以及文件夹的一些基本的属性 常用的方法 文件名称，路径，大小，判断是否存在，删除，创建 // 创建一个文件对象(可以是文件，可以是文件夹) File file = new File("e:/java_text.txt"); // 基本属性 boolean canWriter = file.canWrite(); ...
文件及文件流
weixin_47566784的博客
07-15 1709
1、文件与流的基本概念 在Linux系统下，除了常规的文件外，目录，设备，管道等也属于文件。 根据文件的存储方式，我们可以将文件分为两类，二进制文件以及文本文件。 （1）文本文件：ASCII文件，每个字节存放一个ASCII码字符，文本文件存储量大，速度慢，便于对字符操作，以EOF结尾。 （2）二进制文件：数据按其在内存中的存储形势原样存放，存储量小，速度快，便于存放中间结果。 根据对文件的访问方式又分为带缓冲区文件和不带缓冲区文件。 （1）带缓冲：高级文件操作，将在用户空间中自动生成缓冲区（缓冲区具有快速存
Java学习笔记——文件和流
冷漠的小猿
08-14 413
IO流：文件和流 1.了解File类的作用 2.掌握File类的构造方法和常用成员方法 3.掌握流的作用和原理 4.了解流的分类 5.掌握字符流和字节流的使用 6.掌握转换流的使用 第一节 File类 1.1 File类作用 在java程序中，对磁盘文件进行描述的类。文件和目录路径名的抽象表示形式。 1.2 File类的常用构造方法 方法名 ...
C++——文件和流
01-20
本教程介绍如何从文件读取流和向文件写入流。这就需要用到 C++ 中另一个标准库 fstream，它定义了三个新的数据类型： 数据类型 描述 ofstream 该数据类型表示输出文件流，用于创建文件并向文件写入信息。 ...
C#文件和字节流的转换方法
09-03
在编程语言C#中，文件和字节流的转换是一个常见的操作。文件读写是应用程序与外部存储设备交换数据的重要手段之一。C#提供了丰富的类和方法来操作文件，其中FileStream类是用于读取和写入文件的常用类。在本文中，将...
程序设计全套11文件和流ppt课件.ppt
最新发布
07-05
【文件和流的概念】 ...通过DriveInfo、Directory、DirectoryInfo等类，可以方便地管理文件系统，而通过文本流和二进制流，可以高效地读写文件内容。理解并熟练掌握这些概念和类，对于任何C#开发者来说都是必要的。
zip4j:一个用于zip文件和流的Java库
05-01
Zip4j-一个用于zip文件/流的Java库 ... 输入流和输出流不再笨拙的样板代码。 正如你可以在下面的用法部分中看到，与zip文件的工作，现在即使是一个单一的代码行，比起。 我的意思是不破坏Java的内置zip支持。 实际上
文件与流简介（1）
xqhys的博客
12-03 481
文件的介绍 1）在Java中使用java.io.File类表示一个文件(目录) 路径(注：该类并不代表文件内容)。 2）File类关心的是磁盘上存储的文件位置和名称等，而流是指程序运行中的数据通信信道，当然流类所关心的是文件的内容。 3）如果要考虑跨平台，则可以这样书写写：”...”+File.separator+”temp”+ File.separator+”文件名”。   File类...
流与文件
11-21 288
一、I/O流概述 1. 什么是流 　　流实际上是一个数据序列。把程序与文件的交流想象成一个管道，而数据从一边到另一边，这个就是流。例如，把数据从键盘读到程序，这是输入流，把程序里的数据输出显示到屏幕，这是输出流。采用流的机制可以使数据有序地输入和输出。 2. I/O流类 　　java.io包中包含几乎所有可能永远需要在Java中执行输入和输出（I/O）类。所有这些数据流代表一个输入源和
第十三章 Java 文件与流
Bennettgxd的博客
08-31 728
第十三章 Java 文件与流
文件和流的区别
sjk1525614807的博客
04-13 3877
以下的区别有助于澄清文件和流的差异。文件是一些具有永久存储及特定顺序的字节组成的一个有序的、具有名称的集合。因此，关于文件，人们常会想到目录路径、磁盘存储、文件和目录名等方面。相反，流提供一种向后备存储写入字节和从后备存储读取字节的方式，后备存储可以为多种存储媒介之一。正如除磁盘外存在多种后备存储一样，除文件流之外也存在多种流。例如，还存在网络流、内存流和磁带流等。（以上摘自MSDN） 我的理解...
文件（file）和流（stream）的联系和区别
ghevinn欢迎您光临
01-21 1万+
文件（File）和流(Stream)是既有区别又有联系的两个概念。          文件是计算机管理数据的基本单位，同时也是应用程序保存和读取数据的一个重要场所。                  存储介质：文件是指在各种存储介质上（如硬盘、可移动磁盘、CD等）永久存储的数据的有序集合，它是进行数据读写操作的基本对象。                        特性：每个文件都有文件名
流和文件的区别
mxyhktk的博客
04-22 645
前面介绍的Linux下的文件编程所涉及的操作方式都是不带缓冲的I/O，因为每次调用相应的函数比如说read、write等对文件进行操作的时候都会调用内核的系统调用，由于每次都要通过内核对文件进行操作，所以操作效率比较低，对于流编程来说，首先对文件所映射的流进行操作，然后分阶段将相应的数据写入文件，极大地提高了相应的操作效率。Linux也提供了很多流操纵库函数，称为标准I/O库，是ISO C的组成部分。 文件的I/O函数都是针对文件描述符进行操作的，比如说当调用open或者其他函数打开一个文件，返回一个文件
Java流与文件
程序袁小黑
09-02 8146
       Java中I/O操作主要是指使用Java进行输入，输出操作。Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。 流         在JavaAPI中，可以从其中读入一个字节序列的对象称做输入流，而可以向其中写入一个字节...
"C 文件操作：数据层次、文件和流介绍
C 文件操作是程序设计基础中的重要部分，它涉及到数据层次、文件和流的概念和处理方法。在数据层次方面，我们可以从粒度的大小来进行划分。最小的粒度是比特，它表示一个位的取值，即1或0。比特通过稳定的电路来实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值