JavaSE进阶561-581 IO流(一)流的四大家族

最新推荐文章于 2022-09-25 15:08:53 发布
最新推荐文章于 2022-09-25 15:08:53 发布
阅读量210 收藏
点赞数
分类专栏： 锦到说Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43568982/article/details/109923247
版权

开始时间2020-11-22

IO流

1.Io流,什么是Io?
I: Input
o : output
通过Io可以完成硬盘文件的读和写。
这在其他语言中也经常有，参考一下自己之前写的Python的文件读写
以及VBA的文件读写
2.Io流的分类?

按照流的方向进行分类:
以内存作为参照物，往内存中去，叫做输入(Input)。或者叫做读(Read) .
从内存中出来，叫做输出(output)。或者叫做写(write).

另一种方式是按照读取数据方式不同进行分类:
有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制这种流是万能的，什么类型的文件都可以读取。包括:文本文件，图片，声音文件，视频等
有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取
普通文本文件而存在的，这种流不能读取:图片、声音、视频等文件。只能读取纯文本文件，连word文件都无法读取。

假设文件file1.txt，采用字符流的话是这样读的:
a中国bc张三fe
第一次读: 'a’字符('a’字符在windows系统中占用1个字节。)第二次读:'中字符（'中’字符在windows系统中占用2个字节。)

假设文件file1.txt，采用字节流的话是这样读的:
a中国bc张三fe
第一次读:一个字节，正好读到a
第二次读:一个字节,正好读到’中’字符的一半。
第三次读:一个字节，正好读到’中’字符的另外一半。

char在Java中是两个字节，但是在Windows中占用一个字节

Java中所有的流都在Java.io.*下
主要研究：
new流文件
调用流对象是读还是写
主要有四大家族：

  • InputStream
  • OutputStream
  • BufferedReader
  • BufferedWriter

类名以Stream的都是字节流
以Reader/Writer结尾的为字符流
这四种都是抽象类
所有流都实现了Java.io.Closeable接口，都是可关闭的，都有close()方法
用完都要关，这和其他语言也是一样的。
所有输出流都实现了
Java.io.flushable接口，都是可刷新的，都有flush()方法
刷新的作用就是把未输出的数据强行输出完（清空管道）
常用的流：

  • 文件流：
  • java.io.FileInputstream
  • java.io.Fileoutputstream
  • java.io.FileReader
  • java.io.Filewriter
  • 转换流（将字节流转为字符流）：
  • java .io.InputstreanReader
  • java.io.Outputstreamwriter
  • 缓冲流
  • java.io.BufferedReader
  • java.io.Bufferedwriter
  • java.io.BufferedInputstream
  • java.io.Bufferedoutputstream
  • 数据流
  • java.io.DataInputstream
  • java.io.Dataoutputstream
  • 标准输出流
  • java.io.Printwriter
  • java.io.Printstream
  • 对象专属流
  • java.io.objectInputstream
  • java.io.objectoutputstream

读取示例FileInputStream

package BUPT20201122;

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

/*
 Java.io.FileInputStream
 */
public class IOStreamTest01 {
    public static void main(String[] args) throws FileNotFoundException {
        //创建输入流对象
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream("E:\\编程学习\\Java学习\\Java代码学习\\Java代码.txt");
            int readDate = fileInputStream.read();
            int readDate2 = fileInputStream.read();
            //返回值是读取到的字节本身
            System.out.println(readDate);
            //往后面移动了一位
            System.out.println(readDate2);
            //读到最后会返回-1
            int readDate3;
            while ((readDate3 = fileInputStream.read()) != -1) {
                System.out.println(readDate3);
            }

            //这里也有异常，需要抛一下
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream != null) {
                //关闭流的前提是流不为空，流是null没必要关闭，避免空指针异常
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}

上述代码每次只读了一个字符，这样效率低，改为用数组读，一次多个字符

package BUPT20201122;

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

/*
int read(byte[] b);
一次最多读取b.length个字节
减少硬盘和内存的交互，提高程序的执行效率
 */
public class IOStreamTest02 {
    public static void main(String[] args) throws FileNotFoundException {
        //创建输入流对象
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("20201109/src/BUPT20201122/Java");
            //IDEA工程Project目录的根就是默认当前路径
            byte[] bytes = new byte[15];
            //返回的是字节读的数量，不是字节本身
            int readCount = fis.read(bytes);
            //如果把这一块输出，那么会接着读，一直读到末尾，
            //第一次返回整个byte数组的数量
            //第二次就返回剩下没读完的一口气读完
            //第三次就返回-1
            //但是如果要给他转为String进行输出，那么第一次会读进去的15个都输出
            //但第二次是把读到的4个覆盖数组中的前四个元素//
            //后面的还是之前那15个里面的后11个
            //这并不是我们期待的，应该是读多少个就转多少个
            //因此要传一个起始位置和偏移量
            System.out.println(readCount);
            System.out.println(new String(bytes));
            System.out.println(new String(bytes, 0, fis.read(bytes)));
            System.out.println(fis.read(bytes));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                //关闭流的前提是流不为空，流是null没必要关闭，避免空指针异常
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

这样还是不太完美，改为循环来完成

package BUPT20201122;

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

public class IOStreamTest02 {
    public static void main(String[] args) throws FileNotFoundException {
        //创建输入流对象
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("20201109/src/BUPT20201122/Java");
            byte[] bytes = new byte[15];
            int readCount = 0;
            //读多少转多少
            while ((readCount = fis.read(bytes)) != -1) {
                //注意这里不要换行，读到换行符自己会换行的
                System.out.print(new String(bytes, 0, readCount));
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                //关闭流的前提是流不为空，流是null没必要关闭，避免空指针异常
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

两种常用的方法 skip和available

package BUPT20201122;

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

public class FileInputStreamTest01 {
    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream("20201109/src/BUPT20201122/Java");
            //返回剩下没有读到的字节数量
            /*
            System.out.println(fileInputStream.available());
            //有多少要读，直接一步到位，不用写循环，这种方式不太适合大文件
            byte[] bytes = new byte[fileInputStream.available()];
            int readCount = fileInputStream.read(bytes);
            System.out.println(new String(bytes));
             */

            //skip方法，跳过几个字节不读取
            fileInputStream.skip(3);
            System.out.println(fileInputStream.read());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream != null) {
                //关闭流的前提是流不为空，流是null没必要关闭，避免空指针异常
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileOutputStream

package BUPT20201122;

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

public class FileOutputStreamTest01 {
    public static void main(String[] args) throws FileNotFoundException {
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream("Jindaohei.txt", true);
            //写完之后一定要记得刷新
            byte[] bytes = {97, 101, 110, 113};
            //写入了文件里，没有文件就自动新建，有的话就清空再写
            // 但如果在FileOutputStream中append参数为true，则表示追加
            fileOutputStream.write(bytes);
            fileOutputStream.write(bytes, 0, 2);
            String s = "这是一段字符串";
            //转一下类型
            byte[] bytes1 = s.getBytes();
            fileOutputStream.write(bytes1);
            fileOutputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

        }


    }
}

文件的复制

package BUPT20201129;

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

/*
使用FileInputStream和FileOutputStream完成文件的拷贝
一边读，一边写，使用字节流，什么类型文件都能拷
 */
public class Copy01Test {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            //创建输入流对象
            fileInputStream = new FileInputStream("E:\\研一\\4_20201019_光纤的损耗、色散、光的调制.mp4");
            //创建输出流对象
            fileOutputStream = new FileOutputStream("D:\\4_20201019_光纤的损耗、色散、光的调制.mp4");
            //一边读，一边写，一次拷贝1MB
            byte[] bytes = new byte[1024 * 1024];
            int readCount = 0;
            //读多少写多少
            while ((readCount = fileInputStream.read(bytes)) != -1) {
                fileOutputStream.write(bytes, 0, readCount);
            }
            //记得刷新
            fileOutputStream.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //分开用try，不然可能影响到另一个的关闭
            try {
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileReader

package BUPT20201129;

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

/*
FileReader读取文本的字符输入流

 */
public class FileReaderTest {
    public static void main(String[] args) {
        FileReader fileReader = null;
        try {
            fileReader = new FileReader("Java代码.txt");
            //一次读四个char
            char[] chars = new char[4];
            int readCount = 0;
            while ((readCount = fileReader.read(chars)) != -1) {
                System.out.print(new String(chars, 0, readCount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

FileWriter

package BUPT20201129;

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

/*
FileWriter文件字符输出流，只能输出普通文本
 */
public class FileWriterTest {
    public static void main(String[] args) {
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter("Java代码.txt", true);
            char[] chars = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
            fileWriter.write(chars);
            fileWriter.write(chars, 2, 3);
            fileWriter.write("你好");
            fileWriter.write("\n这里换行了");
            fileWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileWriter != null)
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
}

FileReader和FileWriter完成复制粘贴

package BUPT20201129;

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

/*
FileRead/FileWriter执行拷贝普通文本文件
 */
public class Copy02 {
    public static void main(String[] args) {
        FileReader in = null;
        FileWriter out = null;
        try {
            in = new FileReader("Java代码.txt");
            out = new FileWriter("Java代码2.txt");
            //一个char两个bit，这里就是一兆
            char[] chars = new char[1024 * 512];
            int readCount = 0;

            while ((readCount = in.read(chars)) != -1) {
                out.write(chars, 0, readCount);
            }
            out.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

带缓冲区的流

BufferedReader

package BUPT20201130;

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

public class BufferedReaderTest {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("F:\\编程学习\\Java学习\\学习啊.txt");
        //传参直接传的是reader，但reader是一个抽象类，FileReader是他的子类
        //当一个流的参数为流时，被传进来的流称为节点流，外部负责包装的叫包装流(处理流)
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        //读取一行
        String FirstLine = bufferedReader.readLine();
        System.out.println(FirstLine);
        //关闭只需要关包装流就行
        String s = null;
        //读的一行不包括换行符
        while ((s = bufferedReader.readLine()) != null) {
            System.out.println(s);
        }
        bufferedReader.close();
    }
}

节点流和包装流

package BUPT20201130;

import java.io.*;

public class BufferedReadTest02 {
    public static void main(String[] args) throws IOException {
        //字节流
        FileInputStream fileInputStream = new FileInputStream("F:\\编程学习\\Java学习\\学习啊.txt");
        //字节流转为字符流
        InputStreamReader reader = new InputStreamReader(fileInputStream);
        //一次只能传一个字符流
        BufferedReader bufferedReader = new BufferedReader(reader);

        String line = null;
        while ((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
        }
        bufferedReader.close();
    }
}


package BUPT20201130;

import java.io.*;

/*
BufferedWriter：带有缓冲的字符输出流
OutPutStreamWriter：转换流
 */
public class BufferedWriterTest01 {
    public static void main(String[] args) throws IOException {
        //写一个新的文本文件
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("F:\\编程学习\\Java学习\\学习啊2.txt"));
        //字节变字符，再传参
        BufferedWriter bufferedWriter1 = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("F:\\编程学习\\Java学习\\学习啊3.txt")));
        bufferedWriter.write("hello Java\n");
        bufferedWriter.write("This is a Java Program");
        bufferedWriter1.write("hello Java\n");
        bufferedWriter1.write("This is a Java Programming");
        bufferedWriter1.flush();
        bufferedWriter1.close();
        bufferedWriter.flush();
        bufferedWriter.close();
    }


}

结束时间：2020-11-30

高开低走。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
猿创征文｜Java中的IO流大家族 （两万字详解）
YOU__FEI的博客
09-11 2595
IO流有多种分类方式:一种方式是按照流的方向进行分类:以内存作为参照物，往内存中去，叫做输入(Input)。或者叫做读(Read)。从内存中出来，叫做输出(Output)。或者叫做写(Write) 另一种方式是按照读取数据方式不同进行分类: 有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制，这种流是万能的，什么类型的文件都可以读取。包括:文本文件，图片，声音文件，视频。 假设文件file1.txt，采用字节流的话是这样读的: a中国bc张三fe 第一次读:一个字节
JavaSE进阶-06-IO流1
08-03
`File` 类是 Java IO 包中的一个重要类，用于表示文件和目录路径名的抽象表示。它可以用来创建、删除、重命名文件，以及获取文件的相关信息。 总结： Java 中的流体系结构非常丰富，提供了多种类型的流来适应不同的...
JAVA_IO流四大家族(1)
寻梦&之璐
03-04 3461
文章目录IO流，什么是IO?IO流的分类：JAVA中主要研究：四个家族首领java.io包下需要掌握的流有16个： IO流，什么是IO? I：Input O：Output 通过IO可以完成硬盘文件的读写 IO流的分类： 一种方式是按照流的方向进行分类： 以内存为参照物， 往内存中去，叫做输入，或者叫做读， 从内存中出来，叫做输出，或者叫做写 另一种方式是按照读写数据方式不同进行分类： 有的流是按照字节的方式读取数据，一次读取一个字节byte，等同于一次读取8个二进制位，这种流是万能的，什么类型的文件都能读取
Java IO流的“四大家族”
qq_63691275的博客
09-25 2688
IO流的“四大家族” 字节流：java.io.InputStream (读操作使用流） java.io.OutStream（写操作使用流） 字符流：java.io.Reader（读取器） java.io,Writer （写入器）
IO流的四大家族
m0_45421674的博客
11-17 157
IO 流这块有四大家族 字节流 字节输入流：InputStream 字节输出流：OutputStream 字符流 字符输入流：Reader 字符输出流：Witer 四大家族的流的首领是抽象类，只要是以Stream结尾的都是字节流，以Reader/Witer结尾的都是字符流 ...
Java IO流大家族（总结）
liu_xin_xin的博客
06-27 543
1.IO流的分类 1.1 通过流分类:输入流，输出流 输入流：从接收器输入到java程序。 输出流：输出流接受输出字节并将这些字节发送到某个接收器，也就是从java程序输出到接收器。 1.2 通过数据单位不同分分类：字符流，字节流 在java版本中是先有字节流，再有字符流，1字符 = 2字节 字节流：每次传输一个字节，一个中文汉字是两个字节，会出现乱码。 字符流：每次传输两个字节，一般传输中文 1.3 抽...
JAVASE 进阶篇-web资料整理
最新发布
03-29
JAVASE 进阶篇——web资料整理
JavaSE专题-IO流重点总结(必读).doc
06-03
Java SE专题中的IO流是Java编程中非常重要的一个部分，主要用于数据的输入和输出操作。在Java中，异常处理是程序稳定性和健壮性的重要保障。对于IO流操作，异常处理通常采用`try-catch-finally`结构。当在`try`块中...
JavaSE基础篇 -- IO流的详细操作
07-28
本资源内详尽描述了Java基础的IO操作，包括基本的文件读取、写入、复制、分割、合并等动作，详情另可参见我的博客http://blog.csdn.net/zhongkelee/article/details/47061013
JAVA_IO流四大家族（2）
寻梦&之璐
03-04 7641
文章目录FileReader实现代码查看一下读取出来的每个字符输出：FileWriter直接写入字符串：FileReader和FileWriter实现普通文本文件拷贝执行前：执行后：BufferedReader第一种（直接塞入字符流，不需转换）简介构造方法代码常识普及注意点：第二种（塞入一个字节流，经过转换成为字符流）细看构造函数转换问题解决转换问题实现代码转换代码合并注意BufferedWriter第一种（直接塞入字符流，不需转换）第二种（塞入一个字节流，经过转换成为字符流）DataOutputStrea
IO流四种基本抽象的关系图
weixin_45575129的博客
10-07 302
IO流四种基本抽象的关系图：
Java IO流史上最全详细汇总，确定不来瞅瞅吗！！(内容稍长，建议亲这边收藏慢慢看哦。)
我这么骄傲的一个人。
07-20 790
目录前言一、IO流概述二、IO流的分类：Java IO流四大家族：四大家族的首领常用方法：java.io包下重要的流有16个：三、重要IO流详解文件流：FileInputStream(文件字节输入流)FileOutputStream(文件字节输出流)FileReader(文件字符输入流)FileWriter(文件字符输出流)缓冲流：BufferedReader（缓冲字符输入流）BufferedWriter（缓冲字符输出流）标准输出流：PrintStream（标准字节输出流）对象流：序列化与反序列化四、Fil
Java中的流
qq_44248502的博客
06-21 84
IO流 1、IO流的四大家族 InputStream：字节输入流 OutputSteram：字节输出流 Wirter：字符输出流 Reader：字符输入流 2、所有的流在使用的时候都需要进行关闭，调用close()方法 3、所有有关于输出流的写操作时，都要调用flush()方法进行刷新 4、重点掌握以下流 FileInputStream：文件字节输入流 读操作 FileOutputStream：文件字节输出流 写操作 FileReader：文件字符输入流 读操作 FileWriter：文件字符输出流
IO流
qq_48967079的博客
08-13 211
IO流 1.IO流基本概念 1.IO流概述 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 2:IO流分类 1:按照数据流向 站在内存角度 输入流 读入数据 输出流 写出数据 2:按照数据类型 字节流 可以读写任何类型的文件 比如音频 视频 文本文件 字符流 只能读写文本文件 2.IO流中的四大家族 InputStream OutputStream Reader Writer 3.如何实现文本复制(FileInputStream,FileOutputSt
IO流知识点总结
forever_ss的博客
03-15 374
流根据方向分可分为：输入流、输出流，输入输出是相对于内存而言。 根据读取类型的方向可分为：字节流，字符流。 字节流：适合读取图片，视频，音乐等二进制文件（都以stream结尾） 字符流：适合读取存文本文件（都包含Read 或 write） 四大家族（InputStream,OutputStream,Reader,Write）继承关系图 应用程序中把把输入放入文件中，相当于把一缸水倒入另一缸
java IO流——四大抽象类
MADE_哒哒
02-21 6777
IO所谓的四大抽象类就是：                                             InputStream、OutputStream、Reader、Writer    InputStream:字节输入流的父类，数据单位为字节。                                                      常用方法：int rea...
IO流的学习总结
weixin_43517271的博客
10-03 211
1.IO流的分类 1.按照流的方向： 以内存为参照物： 输入流：指将外部文件中的数据读入到程序(内存)中的流输入流 输出流：指将程序中的数据写出到外部文件中的流输出流 2.按照读取方式的不同 字节流：一次读一个字节byte，等同于一次读取八个进制位，是万能的流，什么文件都可以读取 字符流：按照字符的方式读取，一次读一个字符，只可以读取纯文本文件，word也不能读取 2.IO流的四大家族 java.io.InputStream字节输入流 java.io.OutputStream字节输出流 java.i
IO流分类
极客神殿
10-03 197
15.1 IO了解 15.1.1 IO的分类 根据输入输出方向分为: 输出流(写) 输入流(读) 根据文件类型: 字节流(音频,视频,图片:一次读取一个字节) 字符流(文本:一次读取一个字符) 15.1.2 IO流四大家族： 四大家族的首领: java.io.InputStream 字节输入流 java.io.OutputStream 字节输出流 java.io.Reader 字符输入流 java.io.Writer 字符输出流 所有的流都实现了:java.io.Closeab

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值