Java学习笔记——IO流

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量231 收藏
点赞数
分类专栏： Java学习 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53127728/article/details/122311705
版权

流的分类

按操作数据单位不同分为：字节流（8bit）、字符流（16bit）

按数据流的流向不同分为：输入流、输出流

按流的角色的不同分为：节点流、处理流

在这里插入图片描述

流的体系结构

抽象基类节点流（或文件流）缓冲流（处理流的一种）
InputStreamFileInputStream (read(byte[] buffer))BufferedInputStream (read(byte[] buffer))
OutputStreamFileOutputStream (write(byte[] buffer,0, len))BufferedOutputStream (write(byte[] buffer, 0, len))
ReaderFileReader (read(char[] cbuf))BufferedReader (read(char[] cbuf))
WriterFileWriter (write(char[] cbuf, 0, len))BufferedWriter (write(char[] cbuf, 0, len))

FileReader读入数据的基本操作

在这里插入图片描述在这里插入图片描述将Day09下的hello.txt文件内容读入程序中，并输出到控制台

package a01;


import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Test2 {
    public static void main(String[] args){
        FileReader fr = null;
        try {
            //1.实例化File类的对象，指明要操作的文件
            File file = new File("Day01\\hello.txt");
            System.out.println(file.getAbsoluteFile());
            //2.提供具体的流
            fr = new FileReader(file);
            //3.数据的读入
            //read()：返回读入的一个字符。如果达到文件末尾，返回-1
            int data = fr.read();
            if (data!=-1){
                System.out.println((char)data);
                data = fr.read();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流的关闭操作
            if (fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }
}

说明：

1.read()的理解，返回读入的一个字符。如果达到文件末尾，返回-1

2.异常的处理：为了保证流资源一定可以执行关闭操作，需要使用tey-catch-finally处理

3.读入的文件一定要存在，否则就会报FileNotFoundException

FileReader中使用read(char[] cbuf)读入数据

package a01;

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

public class Test3 {
    public static void main(String[] args){
        FileReader fr = null;
        try {
            //1.File类的实例化
            File file = new File("hello1.txt");
            //2.FileReader流的实例化
            fr = new FileReader(file);

            //3.读入的操作
            char[] cbuf = new char[5];
            int len;
            while((len = fr.read(cbuf))!=-1){
                //方式一：
                //错误写法：
//                for (int i = 0; i < cbuf.length; i++) {
//                    System.out.println(cbuf[i]);
//                }
                //正确写法：
                for (int i = 0; i < len; i++) {
                    System.out.println(cbuf[i]);
                }
            }

            //方式二：
            //错误写法：
//            String str = new String(cbuf);
//            System.out.print(str);
            //正确写法：
            String str = new String(cbuf,0,len);
            System.out.print(str);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源的关闭
            if (fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

FileWrite()写出数据的操作

从内存中写出数据到硬盘的文件里

package a01;


import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Test2 {
    public static void main(String[] args) throws IOException {
//1.实例化File类的对象，指明要操作的文件
        File file = new File("Day01\\hello.txt");
        System.out.println(file.getAbsoluteFile());
        //2.提供具体的流
        FileReader fr = new FileReader(file);
        //3.数据的读入
        //read()：返回读入的一个字符。如果达到文件末尾，返回-1
        int data = fr.read();
        if (data!=-1){
            System.out.println((char)data);
            data = fr.read();
        }
        //4.流的关闭操作
        fr.close();
    }
}

说明：

1.输出操作，对应的File可以不存在的，并不会报异常

​ File对应的硬盘中的文件如果不存在，在输出过程中，会自动创建此文件

​ File对应的硬盘中的文件如果存在：

​ 如果流使用的构造器是FileWriter(file,false) / FileWriter(file):对原有文件的覆盖

​ 如果流使用的构造器是FileWriter(file,true)：对原有文件的追加

使用FileReader和FileWriter实现文本文件的复制

package a01;

import java.io.*;

public class Test4 {
    public static void main(String[] args){
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //1.创建File文件实例化
            File srcFile = new File("hello1.txt");
            File descFile = new File("hello2.txt");
            //2.创建FileReader和FileWriter实例化
            fr = new FileReader(srcFile);
            fw = new FileWriter(descFile);
            //3.读入写出数据
            char[] cbuf = new char[5];
            int len;//记录每次读入到cbuf数组中的字符的个数
            while ((len=fr.read(cbuf))!=-1){
                //每次写出len个字符
                fw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
             if (fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fw!=null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}

字符流不能处理图片文件的处理

使用FileInputStream和FileOutputStream读写非文本文件

//实现对图片的复制操作
package com.yan;

import java.io.*;

public class FileInputOutputTest {
    public static void main(String[] args){

        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            File file1 = new File("Day01\\money.jpg");
            File file2 = new File("Day01\\money2.jpg");

            fis = new FileInputStream(file1);
            fos = new FileOutputStream(file2);

            byte[] buffer = new byte[5];
            int len;
            while ((len = fis.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

结论：

1.对于文本文件（.txt .java .c .cpp）使用字符流处理

2.对于非文本文件（.jpg .mp3 .mp4 .avi .doc .ppt……）使用字节流处理

使用FileInputStream和FileOutputStream复制非文本文件

package com.yan;

import java.io.*;

public class Test1 {

    public static void copyFile(String srcPath, String descPath){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            File srcFile = new File(srcPath);
            File descFile = new File(descPath);

            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(descFile);

            byte[] buffer = new byte[1024];
            int len;
            while((len = fis.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }

        }

    }

    public static void main(String[] args) {
        String srcPath = "C:\\Users\\pon18\\Desktop\\01-视频.mp4";
        String descPath = "C:\\Users\\pon18\\Desktop\\02-视频.mp4";
        copyFile(srcPath,descPath);
    }
}

缓冲流（字节型）实现非文本文件的复制

缓冲流的作用：提供流的读取、写入的速度

​ 提高读写速度的原因：内部提供了一个缓冲区

package com.yan;

import java.io.*;

public class BufferedStreamTest {
    public static void main(String[] args) {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1.造文件
            File srcFile = new File("Day01\\money.jpg");
            File descFile = new File("Day01\\money1.jpg");
            //2.造流
            //2.1造节点流
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(descFile);
            //2.2造处理流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            //3.复制操作
            byte[] buffer = new byte[10];
            int len;
            while ((len = bis.read(buffer))!=-1){
                bos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            //要求：先关闭外层的流，再关闭内层的流
            if (bos!=null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bis!=null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //说明：关闭外层流的同时，内层流也会自动的进行关闭，可以省略
//            fos.close();
//            fis.close();
        }
    }
}

缓冲流（字符型）实现文本文件的复制

package com.yan;

import java.io.*;

public class BufferedStreamTest1 {
    public static void main(String[] args){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader("Day01\\hello.txt"));
            bw = new BufferedWriter(new FileWriter("Day01\\hello1.txt"));

//            //方式一：
//            char[] cbuf = new char[10];
//            int len;
//            while((len = br.read(cbuf))!=-1){
//                bw.write(cbuf,0,len);
//            }

            //方式二：
            String data;
            while((data = br.readLine())!=null){//到末尾即为空null
                //方法一：
//                bw.write(data);//data中不包含换行符
//                bw.write(data+"\n");
                //方法二：
                bw.write(data);//data中不包含换行符
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bw!=null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}

练习

//实现图片加密操作
package com.yan;

import java.io.*;

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

        File srcFile = new File("Day01\\money.jpg");
        File descFile = new File("Day01\\moneysecret.jpg");

        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(descFile);

        byte[] buffer = new byte[10];
        int len;
        while ((len = fis.read(buffer))!=-1){
            for (int i = 0; i < len; i++) {
                buffer[i] = (byte) (buffer[i] ^ 5);
            }

            fos.write(buffer,0,len);
        }

        fos.close();
        fis.close();
    }
}

//恢复图片操作
package com.yan;

import java.io.*;

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

        File srcFile = new File("Day01\\moneysecret.jpg");
        File descFile = new File("Day01\\money3.jpg");

        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(descFile);

        byte[] buffer = new byte[10];
        int len;
        while ((len = fis.read(buffer))!=-1){
            for (int i = 0; i < len; i++) {
                buffer[i] = (byte) (buffer[i] ^ 5);
            }

            fos.write(buffer,0,len);
        }

        fos.close();
        fis.close();
    }
}

转换流

处理流之二：转换流的使用

1.转换流：属于字符流

​ InputStreamReader：将一个字节的输入流转换为字符的输出流

​ OutputStreamWriter：将一个字符的输出流转换为字节的输出流

2.作用：提供字节流和字符流之间的转换

3.解码：字节、字节数组————>字符数组、字符串

​ 编码：字符数组、字符串————>字节、字节数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KAFtRkoR-1641301446520)(C:\Users\pon18\AppData\Roaming\Typora\typora-user-images\image-20211220203743034.png)]

4.字符集

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oVaWZ0XK-1641301446521)(C:\Users\pon18\AppData\Roaming\Typora\typora-user-images\image-20211220210604912.png)]

输入流、输出流

1.1System.in：标准输入流，默认从键盘输入

​ System.out：标准输出流，默认从控制台输出

1.2

System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出的流

1.3

使用Scanner实现，调用next()返回一个字符串

使用System.in实现。System.in ——>转换流——>BufferedReader的readLine()

打印流

PrintStream和PrintWriter

提供了一系列重载的print()和println()

数据流

DataInputStream和DataOutputstream

用来读取或写出基本数据类型的变量和字符串

注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序保持一致！

joy妹妹是菜鸟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java IO流学习笔记——(1)文件字节流
12-21
java IO流学习笔记——(1) IO流总述 • 输入流：数据源到程序(InputStream、Reader读进来) • 输出流：程序到目的地(OutputStream、Writer写出去) 流分类 : • 节点流：可以直接从数据源或目的地读写数据 • 处理...
java IO流学习笔记——(2)文件字符流&字节数组流
12-21
java IO流学习笔记——(2)文件字符流&字节数组流 文件字符流FileReader&FileWriter FileReader :通过字符的方式读取文件，仅适合字符文件 FileWriter :通过字节的方式写出或追加数据到文件中，仅适合字符文件 部分...
(43)Java学习笔记——IO流 / 字符流 / 编码表
xiexiecm的博客
02-17 290
字符流=字节流+编码表 编码表 ASCII码表 ISO-8859-1 拉丁码表 gb2312  简体中文表 gbk  中文编码表升级 gb18030  GBK的取代版本 BIG-5   繁体字编码方案 Unicode  国际编码表/所有文字都用两个字节来表示，java使用的就是Unicode UFT-8  最多用三个字节来表示一个字符 字符串的编码和解码 Stri
java学习笔记——OI流部分
人工智能Study
05-18 397
IO流常用的有：字符流、字节流、缓冲流、序列化、RandomAccessFile类等，以上列出的都是开发中比较常用的。 1、字节流： 字节流包含：FileInputStream/FileOutputStream、BufferedInputStream/BufferedOutputStream 2、字符流： 字符流包含：InputStreamReader/OutputStreamWriter、Buf...
Java学习笔记——文件IO
qq_38592678的博客
05-18 1035
字符流：对应着文本文件，本质上是对字节流的封装。(帮我们完成自动查字符集表)，一个字符对应几个字节得看字符集是哪种(utf8一个中文对应三个字节，GBK一个中文对应两个字节)。​ 文件描述符表保存了文件描述符，空间是有限制的，如果一直有文件打开，但是不关闭前面没用的连接就会使得文件描述符表的可用资源越来越少，当文件描述符表用完了就会出现问题(文件描述符表可以看成是数组)。​ String使用的字符集是uft8(每个中文字符占3个字节)，如果用是char使用的是Unicode(每个中文字符占2个字节)。
Java学习笔记——网络原理1
qq_38592678的博客
05-21 1174
TCP是有连接的，而UDP是无连接的。​ TCP要想通信需要先建立连接，且需保存对方信息。​ UDP可以直接发送数据，不用保存对方信息(但是写程序的人需要保存，调用UDP api的时候要将对方的信息发送过去)。TCP是可靠传输，而UDP是不可靠传输。​ TCP传输数据有一系列保障数据的传输，如超时重传，应答机制，流量控制，序列号机制，拥塞控制，数据校验。​ UDP的不可靠传输体现在，其发送完数据后不保证数据能够到达目标地址。​ 可靠传输也是有代价的——机制更复杂，传输效率更低。
Java学习笔记————————IO流中文件创建、写入、读取、复制的相关笔记
weixin_44501770的博客
09-04 309
Java学习笔记————————IO流中文件创建、写入、读取、复制的相关笔记 本人小白，以下是B站的Java课程（强烈推荐）的学习笔记，仅作回顾之用，有误望指出。 注：效率测试部分不明显，若想比较程序执行效率，可忽略文件夹、文件创建的部分，用现成的大文件代替。 package buffered; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import ja
Java学习笔记（二十三）—— io流
Biangbangbing的博客
10-30 304
io使用场景 当想要将某些数据存储到磁盘内，以便程序关闭、再次运行的时候还可以查到这个数据，这时我们需要用io流将这些数据写出程序写入到本地文件里、或者保存到数据库等等。 iO详解 查看java API文档——java.base——java.io。发现有很多接口、类、方法调用（简单来说就是有点乱七八糟） 张下面这样↓ 所以从宏观角度简单分分类，然后分解学习： io分类 按照读取单位分： 字节流（一次性传入一个字节，8bit）（可以处理任何数据） 字符流（java一个字符16.
Java IO流学习——字节流
weixin_49561506的博客
11-21 820
Java IO流学习——字节流
Java学习笔记——Java 流(Stream)、文件(File)和IO
D77的博客
06-11 508
Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。 Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。 一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。 Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。 但本节讲述最基本的和流与 I/O 相关的功能。我们将通过一个个例子来学习这些功能。...
Java基础学习笔记22——IO流
weixin_44623055的博客
01-08 279
1、File类 1.1、File概述 File类在java.io包下，故使用时需要导包。File是一个具体的类，继承自Object类，实现了Serializable和Comparable<File>接口。 File是文件和目录路径名的抽象表示： 文件和目录是可以通过File封装成对象的； 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已，它可以是存在的，也可以是不存在的，将来是要通过具体的操作把这个路径的内容转换为具体存在的。 绝对路径和相对路径的区别： 绝对
java IO流学习笔记——(3)字节缓冲流&字符缓冲流&转换流&数据流
12-21
java IO流学习笔记——(3)字节缓冲流&字符缓冲流&转换流&数据流 目录java IO流学习笔记——(3)字节缓冲流&字符缓冲流&转换流&数据流字节缓冲流 —BufferedInputStream&BufferedOutputStream字符缓冲流—...
Collection学习笔记——每天一个Java小技巧
12-21
Collection学习笔记Collection集合概述Collection集合常用方法Collection集合的遍历(迭代器)集合的使用样例 Collection集合概述 是单例集合的顶层接口 它提供了更具体的子接口的实现，如set和list. Collection集合...
JAVA学习笔记2020/4/27——Stream流、方法引用
01-20
说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。 1.1 引言 传统集合的...
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 890
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 893
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1205
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 491
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
java 上传文件_JAVA学习笔记——fileUpload文件上传
05-17
文件上传是Web开发中常见的功能之一，Java中也提供了多种方式来实现文件上传。其中，一种常用的方式是通过Apache的commons-fileupload组件来实现文件上传。 以下是实现文件上传的步骤： 1.在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>commons-fileupload</groupId> <artifactId>commons-fileupload</artifactId> <version>1.3.3</version> </dependency> ``` 2.在前端页面中添加文件上传表单： ```html <form method="post" enctype="multipart/form-data" action="upload"> <input type="file" name="file"> <input type="submit" value="Upload"> </form> ``` 3.在后台Java代码中处理上传文件： ```java // 创建一个DiskFileItemFactory对象，用于解析上传的文件 DiskFileItemFactory factory = new DiskFileItemFactory(); // 设置缓冲区大小，如果上传的文件大于缓冲区大小，则先将文件保存到临时文件中，再进行处理 factory.setSizeThreshold(1024 * 1024); // 创建一个ServletFileUpload对象，用于解析上传的文件 ServletFileUpload upload = new ServletFileUpload(factory); // 设置上传文件的大小限制，这里设置为10MB upload.setFileSizeMax(10 * 1024 * 1024); // 解析上传的文件，得到一个FileItem的List集合 List<FileItem> items = upload.parseRequest(request); // 遍历FileItem的List集合，处理上传的文件 for (FileItem item : items) { // 判断当前FileItem是否为上传的文件 if (!item.isFormField()) { // 获取上传文件的文件名 String fileName = item.getName(); // 创建一个File对象，用于保存上传的文件 File file = new File("D:/uploads/" + fileName); // 将上传的文件保存到指定的目录中 item.write(file); } } ``` 以上代码中，首先创建了一个DiskFileItemFactory对象，用于解析上传的文件。然后设置了缓冲区大小和上传文件的大小限制。接着创建一个ServletFileUpload对象，用于解析上传的文件。最后遍历FileItem的List集合，判断当前FileItem是否为上传的文件，如果是，则获取文件名，创建一个File对象，将上传的文件保存到指定的目录中。 4.文件上传完成后，可以给用户一个提示信息，例如： ```java response.getWriter().write("File uploaded successfully!"); ``` 以上就是使用Apache的commons-fileupload组件实现文件上传的步骤。需要注意的是，文件上传可能会带来安全隐患，因此在处理上传的文件时，需要进行严格的校验和过滤。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值