IO流基本知识

已于 2023-09-04 15:11:17 修改
阅读量41 收藏
点赞数
文章标签： java idea
于 2023-09-04 15:08:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58591155/article/details/132669849
版权

查看博客等级权益前置知识：字符集

/**
 * 目标：掌握如何使用Java代码完成对字符的编码和解码。
 */
public class Test {
    public static void main(String[] args) throws Exception {
        // 1、编码
        String data = "a我b";
        byte[] bytes = data.getBytes(); // 默认是按照平台字符集（UTF-8）进行编码的。
        System.out.println(Arrays.toString(bytes));

        // 按照指定字符集进行编码。
        byte[] bytes1 = data.getBytes("GBK");
        System.out.println(Arrays.toString(bytes1));

        // 2、解码
        String s1 = new String(bytes); // 按照平台默认编码（UTF-8）解码
        System.out.println(s1);

        String s2 = new String(bytes1, "GBK");
        System.out.println(s2);
    }
}

IO流

IO流总体来看就有四大流
  • 字节输入流 : 以内存为基准，来自磁盘文件/网络中的数据以字节的形式读入到内存中去的流
  • 字节输出流 : 以内存为基准，把内存中的数据以字节写出到磁盘文件或者网络中去的流。
  • 字符输入流 : 以内存为基准，来自磁盘文件/网络中的数据以字符的形式读入到内存中去的流。
  • 字节输出流 : 以内存为基准，把内存中的数据以字符写出到磁盘文件或者网络介质中去的流。

IO流-字节流

IO流的作用：就是可以对文件或者网络中的数据进行读、写的操作。

  • 把数据从磁盘、网络中读取到程序中来，用到的是输入流。
  • 把程序中的数据写入磁盘、网络中，用到的是输出流。
  • 简单记：输入流（读数据）、输出流（写数据）


使用FileInputStream读取文件中的字节数据，步骤如下

第一步：创建FileInputStream文件字节输入流管道，与源文件接通。

第二步：调用read()方法开始读取文件的字节数据。

第三步：调用close()方法释放资源

/**
 * 目标：掌握文件字节输入流，每次读取一个字节。
 */
public class FileInputStreamTest1 {
    public static void main(String[] args) throws Exception {
        // 1、创建文件字节输入流管道，与源文件接通。
        InputStream is = new FileInputStream(("file-io-app\\src\\itheima01.txt"));

        // 2、开始读取文件的字节数据。
        // public int read():每次读取一个字节返回，如果没有数据了，返回-1.
        int b; // 用于记住读取的字节。
        while ((b = is.read()) != -1){
            System.out.print((char) b);
        }
        
        //3、流使用完毕之后，必须关闭！释放系统资源！
        is.close();
    }
}

  • FileInputStream（文件字节输入流）

作用：以内存为基准，可以把磁盘文件中的数据以字节的形式读入到内存中去。

/**
 * 目标：掌握使用FileInputStream每次读取多个字节。
 */
public class FileInputStreamTest2 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个字节输入流对象代表字节输入流管道与源文件接通。
        InputStream is = new FileInputStream("file-io-app\\src\\itheima02.txt");

        // 2、开始读取文件中的字节数据：每次读取多个字节。
        //  public int read(byte b[]) throws IOException
        //  每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1.

        // 3、使用循环改造。
        byte[] buffer = new byte[3];
        int len; // 记住每次读取了多少个字节。  abc 66
        while ((len = is.read(buffer)) != -1){
            // 注意：读取多少，倒出多少。
            String rs = new String(buffer, 0 , len);
            System.out.print(rs);
        }
        // 性能得到了明显的提升！！
        // 这种方案也不能避免读取汉字输出乱码的问题！！

        is.close(); // 关闭流
    }
}

  • FileInputStream（文件字节输入流）

作用：以内存为基准，可以把磁盘文件中的数据以字节的形式读入到内存中去。

释放资源的方式

try-catch-finally

try{

....

....

}catch(Exception){

e.printStackTrace();

}finally{

//关流·写在这里

}

  • finally代码区的特点：无论try中的程序是正常执行了，还是出现了异常，最后都一定会执行finally区，除非JVM终止。
  • 作用：一般用于在程序执行完成后进行资源的释放操作（专业级做法）。

try-with-resource

try(定义资源1;定义资源2;…）{

可能出现异常的代码;

}

catch(异常类名 变量名){

异常的处理代码;

}

示例：

public class Demo {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("JavaSE_09\\src\\kun.png");
             FileOutputStream fos = new FileOutputStream("JavaSE_09\\src\\kun2.png");
            ) {
            byte[] bytes = fis.readAllBytes();
            fos.write(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}
  • 特点：该资源使用完毕后，会自动调用其close()方法，完成对资源的释放！

IO流-字符流

字符流的含义

  1. 字符流是指以字符为单位进行输入输出的数据流。在计算机中，字符流可以是从文件或网络连接中读取字符数据，也可以将字符数据写入文件或发送到网络连接中。
  2. 字符流通常用于处理文本数据，如读取或写入文本文件、网络通信中传输文本消息等。相比于字节流，字符流提供了更方便的操作字符串和字符的方法，能够直接读取和写入 Unicode 字符。

文件字符输入流-读字符数据进来

  • 示例：
/**
 * 目标：掌握文件字符输入流。
 */
public class FileReaderTest1 {
    public static void main(String[] args)  {
        try (
                // 1、创建一个文件字符输入流管道与源文件接通
                Reader fr = new FileReader("io-app2\\src\\itheima01.txt");
                ){
            // 2、一个字符一个字符的读（性能较差）
//            int c; // 记住每次读取的字符编号。
//            while ((c = fr.read()) != -1){
//                System.out.print((char) c);
//            }
            // 每次读取一个字符的形式，性能肯定是比较差的。

            // 3、每次读取多个字符。（性能是比较不错的！）
            char[] buffer = new char[3];
            int len; // 记住每次读取了多少个字符。
            while ((len = fr.read(buffer)) != -1){
                // 读取多少倒出多少
                System.out.print(new String(buffer, 0, len));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

文件字符输出流-写字符数据出去

  • 字符输出流的特点：底层是有缓冲区的，字符输出流写出数据后，必须刷新流，或者关闭流，写出去的数据才能生效。

示例：

/**
 * 目标：掌握文件字符输出流：写字符数据出去
 */
public class FileWriterTest2 {
    public static void main(String[] args) {
        try (
                // 0、创建一个文件字符输出流管道与目标文件接通。
                // 覆盖管道
                // Writer fw = new FileWriter("io-app2/src/itheima02out.txt");
                // 追加数据的管道
                Writer fw = new FileWriter("io-app2/src/itheima02out.txt", true);
                ){
            // 1、public void write(int c):写一个字符出去
            fw.write('a');
            fw.write(97);
            //fw.write('磊'); // 写一个字符出去
            fw.write("\r\n"); // 换行

            // 2、public void write(String c)写一个字符串出去
            fw.write("我爱你中国abc");
            fw.write("\r\n");

            // 3、public void write(String c ,int pos ,int len):写字符串的一部分出去
            fw.write("我爱你中国abc", 0, 5);
            fw.write("\r\n");

            // 4、public void write(char[] buffer):写一个字符数组出去
            char[] buffer = {'黑', '马', 'a', 'b', 'c'};
            fw.write(buffer);
            fw.write("\r\n");

            // 5、public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
            fw.write(buffer, 0, 2);
            fw.write("\r\n");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

综合案列：

package com.itheima.demo02;

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

public class Demo03 {
    public static void main(String[] args) {
        try (
                // 1.创建字符输入流，读取c.txt
                FileReader fr = new FileReader("JavaSE_10/file/c.txt");
                // 2.创建字符输出流，写到d.txt
                FileWriter fw = new FileWriter("JavaSE_10/file/d.txt")) {
            // 3/创建一个字符数组，用于存储读取到的字符
            char[] chars = new char[1024 * 8];
            // 4.定义一个整数，用于记录读取的长度
            int len;
            // 5.使用循环读取数组，同时，把读取到的数据写入到d.txt
            while ((len = fr.read(chars)) != -1) {
                fw.write(chars, 0, len);
            }


        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

IO流-缓冲流

字节缓冲流

  • 字节缓冲流的作用：提高字流的读写数据的性能。
  • 原理：字节缓冲输入流自带了8KB缓冲池；字节缓冲输出流也自带了8KB缓冲池。

public class BufferedInputStreamTest1 {
    public static void main(String[] args) {
        try (
                InputStream is = new FileInputStream("io-app2/src/itheima01.txt");
                // 1、定义一个字节缓冲输入流包装原始的字节输入流
                InputStream bis = new BufferedInputStream(is);

                OutputStream os = new FileOutputStream("io-app2/src/itheima01_bak.txt");
                // 2、定义一个字节缓冲输出流包装原始的字节输出流
                OutputStream bos = new BufferedOutputStream(os);
        ){

            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer, 0, len);
            }
            System.out.println("复制完成！！");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字符缓冲流

  • 它的原理和字节缓冲流是类似的，它底层也会有一个8KB的数组，但是这里是字符数组。字符缓冲流也不能单独使用，它需要依赖于原始字符流一起使用。

  • 字符缓冲输出流新增的功能：换行

public class BufferedReaderTest2 {
    public static void main(String[] args)  {
        try (
                Reader fr = new FileReader("io-app2\\src\\itheima04.txt");
                // 创建一个字符缓冲输入流包装原始的字符输入流
                BufferedReader br = new BufferedReader(fr);
        ){
//            char[] buffer = new char[3];
//            int len;
//            while ((len = br.read(buffer)) != -1){
//                System.out.print(new String(buffer, 0, len));
//            }
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());

            String line; // 记住每次读取的一行数据
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class BufferedWriterTest3 {
    public static void main(String[] args) {
        try (
                Writer fw = new FileWriter("io-app2/src/itheima05out.txt", true);
                // 创建一个字符缓冲输出流管道包装原始的字符输出流
                BufferedWriter bw = new BufferedWriter(fw);
        ){

            bw.write('a');
            bw.write(97);
            bw.write('磊');
            bw.newLine();

            bw.write("我爱你中国abc");
            bw.newLine();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

原始流、缓冲流的性能分析[重点]

  • 数组越大性能越高，低级流和缓冲流性能相当
  • 总结一下：缓冲流的性能不一定比低级流高，其实低级流自己加一个数组，性能其实是不差。

  • 建议使用字节缓冲输入流、字节缓冲输出流，结合字节数组的方式，目前来看是性能最优的组合。

IO流-转换流

字符输入转换流

InputStreamReader（字符输入转换流）
  • 解决不同编码时，字符流读取文本内容乱码的问题。
  • 解决思路：先获取文件的原始字节流，再将其按真实的字符集编码转成字符输入流，这样字符输入流中的字符就不乱码了。

public class InputStreamReaderTest2 {
    public static void main(String[] args) {
        try (
                // 1、得到文件的原始字节流（GBK的字节流形式）
                InputStream is = new FileInputStream("io-app2/src/itheima06.txt");
                // 2、把原始的字节输入流按照指定的字符集编码转换成字符输入流
                Reader isr = new InputStreamReader(is, "GBK");
                // 3、把字符输入流包装成缓冲字符输入流
                BufferedReader br = new BufferedReader(isr);
                ){
            String line;
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }


        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字符输出转换流

OutputStreamWriter字符输出转换流
  • 作用：可以控制写出去的字符使用什么字符集编码。
  • 解决思路：获取字节输出流，再按照指定的字符集编码将其转换成字符输出流，以后写出去的字符就会用该字符集编码了。

public class OutputStreamWriterTest3 {
    public static void main(String[] args) {
        // 指定写出去的字符编码。
        try (
                // 1、创建一个文件字节输出流
                OutputStream os = new FileOutputStream("io-app2/src/itheima07out.txt");
                // 2、把原始的字节输出流，按照指定的字符集编码转换成字符输出转换流。
                Writer osw = new OutputStreamWriter(os, "GBK");
                // 3、把字符输出流包装成缓冲字符输出流
                BufferedWriter bw = new BufferedWriter(osw);
                ){
            bw.write("我是中国人abc");
            bw.write("我爱你中国123");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

IO流-打印流

PrintStream/PrintWriter（打印流）
  • 作用：打印流可以实现更方便、更高效的打印数据出去，能实现打印啥出去就是啥出去。

public class PrintTest1 {
    public static void main(String[] args) {
        try (
                // 1、创建一个打印流管道
//                PrintStream ps =
//                        new PrintStream("io-app2/src/itheima08.txt", Charset.forName("GBK"));
//                PrintStream ps =
//                        new PrintStream("io-app2/src/itheima08.txt");
                PrintWriter ps =
                        new PrintWriter(new FileOutputStream("io-app2/src/itheima08.txt", true));
                ){
                ps.print(97);	//文件中显示的就是:97
                ps.print('a'); //文件中显示的就是:a
                ps.println("我爱你中国abc");	//文件中显示的就是:我爱你中国abc
                ps.println(true);//文件中显示的就是:true
                ps.println(99.5);//文件中显示的就是99.5

                ps.write(97); //文件中显示a，发现和前面println方法的区别了吗？

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

PrintStream和PrintWriter的区别
  • 打印数据的功能上是一模一样的：都是使用方便，性能高效（核心优势）
  • PrintStream继承自字节输出流OutputStream，因此支持写字节数据的方法。
  • PrintWriter继承自字符输出流Writer，因此支持写字符数据出去。

IO流-数据流

DataOutputStream(数据输出流)

  • 允许把数据和其类型一并写出去

public class DataOutputStreamTest1 {
    public static void main(String[] args) {
        try (
                // 1、创建一个数据输出流包装低级的字节输出流
                DataOutputStream dos =
                        new DataOutputStream(new FileOutputStream("io-app2/src/itheima10out.txt"));
                ){
            dos.writeInt(97);
            dos.writeDouble(99.5);
            dos.writeBoolean(true);
            dos.writeUTF("黑马程序员666！");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

DataInputStream(数据输入流)

  • 用于读取数据输出流写出去的数据

public class DataInputStreamTest2 {
    public static void main(String[] args) {
        try (
                DataInputStream dis =
                        new DataInputStream(new FileInputStream("io-app2/src/itheima10out.txt"));
                ){
            int i = dis.readInt();
            System.out.println(i);

            double d = dis.readDouble();
            System.out.println(d);

            boolean b = dis.readBoolean();
            System.out.println(b);

            String rs = dis.readUTF();
            System.out.println(rs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

IO流-序列化流(对象流)

ObjectOutputStream(对象字节输出流)

  • 可以把Java对象进行序列化：把Java对象存入到文件中去。

  • 第一步：先准备一个User类，必须让其实现Serializable接口。
// 注意：对象如果需要序列化，必须实现序列化接口。
public class User implements Serializable {
    private String loginName;
    private String userName;
    private int age;
    // transient 这个成员变量将不参与序列化。
    private transient String passWord;

    public User() {
    }

    public User(String loginName, String userName, int age, String passWord) {
        this.loginName = loginName;
        this.userName = userName;
        this.age = age;
        this.passWord = passWord;
    }

    @Override
    public String toString() {
        return "User{" +
                "loginName='" + loginName + '\'' +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                ", passWord='" + passWord + '\'' +
                '}';
    }
}
  • 第二步：再创建ObjectOutputStream流对象，调用writeObject方法对象到文件。
public class Test1ObjectOutputStream {
    public static void main(String[] args) {
        try (
                // 2、创建一个对象字节输出流包装原始的字节 输出流。
                ObjectOutputStream oos =
                        new ObjectOutputStream(new FileOutputStream("io-app2/src/itheima11out.txt"));
                ){
            // 1、创建一个Java对象。
            User u = new User("admin", "张三", 32, "666888xyz");

            // 3、序列化对象到文件中去
            oos.writeObject(u);
            System.out.println("序列化对象成功！！");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//**注意：写到文件中的对象，是不能用记事本打开看的。因为对象本身就不是文本数据，打开是乱码**

ObjectInputStream(对象字节输入流)

  • 可以把Java对象进行反序列化：把存储在文件中的Java对象读入到内存中来。

public class Test2ObjectInputStream {
    public static void main(String[] args) {
        try (
            // 1、创建一个对象字节输入流管道，包装 低级的字节输入流与源文件接通
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("io-app2/src/itheima11out.txt"));
        ){
            User u = (User) ois.readObject();
            System.out.println(u);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
Aurora丶EX
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
JavaIO流知识点总结
ojemmm的博客
10-14 1645
知识点 package IO流原理与概念; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.ByteArrayInputStream; import...
Java IO流 文件传输基础
09-02
在Java中，IO流提供了多种类来处理文件操作，如`FileInputStream`和`FileOutputStream`用于基本的字节流操作，`FileReader`和`FileWriter`用于字符流操作。这些类允许开发者读取或写入文件，同时可以配合缓冲区(`...
io流基本知识
lgb1997的博客
08-02 174
io流继承于Object包下， java.io.File(文件)实现了Serializable，Comparable接口 只能通过字节单位进行读取 文件的常用构造方法： 没有无参构造方法，每一个file对象都必须标识一个文件或者文件夹。 （1）File(String pathname) 通过给定的路径名字符串转换为抽象路径名来创建新的File实例。 （2）File(File parent, Str...
Java IO 流基本知识
m0_71308238的博客
11-10 196
简略的讲述一些关于IO流的分类及用法
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
IO流的基本知识
qq_41743601的博客
12-18 406
IO流 文章目录IO流文件的创建目录操作流和文件的关系字节输入流节点流和数据流对象处理流争对对象进行序列化和反序列化的操作注意事项标准输入输出流转换流转换流的代码示例PrintStream流PrintWriter流使用IDEA快速查看类的依赖关系Properties类 文件的创建 目录操作 流和文件的关系 字节输入流 节点流和数据流 对象处理流 争对对象进行序列化和反序列化的操作 package com.stream; import java.io.*; import java.lan
文件IO流的基本知识
一无是处的博客
01-24 354
IO流的基本知识
JavaIO流的基本使用方法
m0_65818274的博客
02-04 211
IO的基本讲解
IO流知识
qq_40093255的博客
08-21 614
IO流知识 ByteArrayOutputStream 与ByteArrayInputStream流关闭问题(内存流) ByteArrayOutPutStream和ByteArrayInputStream内部封装了缓冲区（内存流），他们是内存读写流,不同于指向磁盘的流，不涉及底层资源的使用，并且底层用的是byte数组并不是调用了磁盘，这个字节数组是它成员变量，当数组不再使用变成垃圾的时候Java的垃圾回收机制会将它回收，关闭流是为了防止底层资源的泄露（内存），并且他自己的close方法并没有实现，如下所示：
Java的IO流基础知识
weixin_73956119的博客
04-07 434
本文仅作为自学时的笔记参考。
java基础之IO流
06-18
### Java IO流基础知识点 #### 一、IO流概述 - **定义**：在Java中，IO流（Input/Output Streams）是用来处理输入输出的基本工具。流是一种有序的数据集合，通常涉及从源到目的地的数据传输过程。源可以是文件、...
IO流自用模板
12-17
以上就是IO流的基本知识和应用模板，理解并熟练掌握这些内容，能够有效地进行数据的输入输出操作，解决各种场景下的文件处理问题。在实际开发中，还需要根据具体需求灵活运用，比如错误处理、多线程并发读写等。
IO流pdf宝典
07-21
### JAVA IO流概念及其应用详解 ...通过对以上知识点的学习，我们可以了解到JAVA IO流在处理文件和其他设备上的数据时的强大功能。掌握好这些基本概念和技巧，能够帮助开发者更好地处理各种数据操作需求。
JAVASE，IO流部分模块导图
01-13
对于初学者，理解这些接口和类之间的关系至关重要，可以帮助清晰地构建IO流的知识体系。而对有经验的开发者来说，这些导图和知识点可以作为快速查阅和回顾的参考工具，特别是在需要使用IO流功能但对具体实现细节记忆...
C++ - 函数重载
jiaowenjie的专栏
08-06 318
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
Spring事务
c1tenj2的博客
08-07 429
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
反射和注解
supercool7的博客
08-08 229
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
Java：继承，this，super
最新发布
m0_75257168的博客
08-10 209
可以同名，但参数列表不能相同（有参无参构造）
Java IO流详解：从入门到精通
"这是一本关于Java IO流的优秀学习资料，适合对IO理解困难的读者，涵盖了IO流的基础概念、分类以及四大抽象类，并详细介绍了InputStream、OutputStream、Writer和Reader的基本方法，还涉及到节点流的使用，特别是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值