Java——IO

最新推荐文章于 2024-07-26 12:28:02 发布
最新推荐文章于 2024-07-26 12:28:02 发布
阅读量66 收藏
点赞数
文章标签： java servlet junit
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51733711/article/details/126613702
版权

File类

File类 在程序中抽象的表示计算机中的文件或目录。 一个File类对象可以表示文件和路径， 可以对文件的属性进行操作，但不能直接对文件进行读写操作。

路径有两种：

绝对路径，完整的路径 D:\File.txt

相对路径，不是全路径,是两个文件的相对同一个父级的路径 File.txt

import java.io.File;
import java.io.IOException;
import java.util.Date;
​
public class Demo1 {
 
    public static void main(String[] args) {
        File f1=new File("D:\\File.txt");//File类的构造方法
String s="D:\\";
    new File(s,"File1.txt");
    new File(s,"File2.txt");
    new File(s,"File3.txt");
 
    File f2=new File("D:\\Files");
    if (!f2.exists()) {
        f2.mkdir();//创建一级目录(文件夹)
    }
    f2.delete();//删除目录时，目录要为空
    File f3=new File("D:\\File1\\File2\\File3");
    if (!f3.exists()) {
        f3.mkdirs();//创建多级目录
    }
    f3.delete();
    if (!f1.exists()){//判断文件是否存在
        try {
            f1.createNewFile();//新建一个文件
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("路径不正确");
        }
    }
    System.out.println(f1.canRead());//判断文件是否可读
    System.out.println(f1.canWrite());//判断文件是否可写
    System.out.println(f1.getAbsoluteFile());//获取文件的绝对地址
    System.out.println(f1.getParent());//返回路径名的父
    System.out.println(f1.length());//获取文件的长度（字节数，以字节为单位）
    System.out.println(new Date(f1.lastModified()));//获取文件的最后修改时间
    System.out.println(f1.delete());//删除文件
    System.out.println(f1.isFile());//判断是否为路径
    System.out.println(f1.isDirectory());//判断是否为目录
}
}

对目录遍历，获得所有子目录和文件

  
  import java.io.File;
import java.io.FileFilter;
​
public class Demo3 {
    
    public static void main(String[] args) {
        //对目录里的文件进行遍历,获得某个目录中的所有子目录或文件的文件名,以String返回
        File f1=new File("C:/JAVA 非凡");
        String[] strings=f1.list();
        for (String s:strings){
            System.out.println(s);
        }
    //对目录里的文件进行遍历,获得某个目录中的所有子目录或文件,以File对象返回
    File f2=new File("C:/JAVA 非凡");
    File [] files=f2.listFiles();
    for (File s:files) {
        System.out.println(s);
    }
 
    //设置条件来选择要操作的对象,返回File对象
    File f3 = new File("C:/JAVA 非凡");
    File[]  files1=f3.listFiles(new MyFileFilter());
    for (File s:files1){
        System.out.println(s);
    }
}
}


import java.io.File;
import java.io.FilenameFilter;
​
public class MyFileFilter implements FilenameFilter {
@Override
public boolean accept(File dir, String name) {
    return name.endsWith("java");
}
}

输入及输出的概念

输入输出，将电脑的硬盘上的数据往程序读为输入，把程序中的数据往程序外读为输出。

IO流中的流意思是读写文件的操作类。

IO输入流和输出流，读写文件的操作，根据操作单位不同可分为：

1.字节流以字节为单位，读取时，每次读一个字节

InputStream 字节流输出

OutputStream 字节流输入

2.字符流 以子符为单位，读取时，每次读一个字符，只适合读文本文件

Reader read 字符流输出

Writer writer 字符流输入

import java.io.*;
​
public class Demo2 {
  
    public static void main(String[] args) throws IOException {
        File file=new File("D:/File.txt");
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件已存在");
        }
        FileInputStream in=new FileInputStream(file);
        FileOutputStream out=new FileOutputStream("D:/File2.txt");
        //字节流输出
        int n=0;
        while ((n=in.read())!=-1){
            System.out.println(n);
        }
        in.close();//关闭流的通道，释放对文件的占用
        //字节流输入
        int t=0;
        while ((t=in.read())!=-1){
            out.write(t);
        }
        out.close();//关闭流的通道，释放对文件的占用
    }
}

输入输出节点字节流

字节流的输入输出使用InputStream和OutputStream两种方法。

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


public class Demo4 {
  
    public static void main(String[] args) throws IOException {
        FileInputStream in=null;
        FileOutputStream out=null;
try {
        in =new FileInputStream("D:\\File.txt");
        out =new FileOutputStream("D:\\File1.txt");
        int n=0;
        while ((n=in.read())!=-1){
            //in.read();//读取时以int字节形式读取，一次读取一个字节，当文件读完时返回-1
            out.write(n);//写入时，一次向目标写入一个字节
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
        System.out.println(e.getMessage());//日志记录
    }finally {
        if (in!=null)
            in.close();//关闭流的通道，释放对文件的占用
        if (out!=null)
            out.close();//关闭流的通道，释放对文件的占用
    }
 
    byte[] bytes=new byte[10];


import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
​
public class Demo5 {
    public static void main(String[] args) throws IOException {
        FileInputStream in=null;
        FileOutputStream out=null;
​
```
    try {
        in =new FileInputStream("D:\\File.txt");
        out =new FileOutputStream("D:\\File1.txt");
        //这每次读一个字节，时间长
```
​
//            int n=0;
//            while ((n=in.read())!=-1){
//                out.write(n);//写入时，一次向目标写入一个字节
//            }
            //这根据定义的byte数组长度，每次读byte.length个字节
            //当最后一次剩余字节不足以将byte数组放满，则剩多少放多少
            byte[] bytes=new byte[5];
            int size=0;
            while ((size=in.read(bytes))!=-1){
                System.out.println("这次byte中放入字节数为："+size);
                //in.read();//读取时以int字节形式读取，一次读取一个字节，当文件读完时返回-1
                out.write(bytes,0,size);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println(e.getMessage());//日志记录
        }finally {
            if (in!=null)
                in.close();//关闭流的通道，释放对文件的占用
            if (out!=null)
                out.close();//关闭流的通道，释放对文件的占用
        }


}
​
}

节点流与处理流

根据封装的类型，流可分为字节流和处理流。

节点流 流对象是直接对数据进行操作。 例如：构造方法（文件）

处理流(包装流) 流对象中包装的是另一个流，提供一些额外的数据处理。 例如：ObjectInputStream(InputStream in);

节点流中的常用类：

字节输入流 FileInputStream

字节输出流 FileOutputStream

字符输入流 FileReader

字符输出流 FileWriter

import java.io.*;

public class Demo7 {
  
public static void main(String[] args) throws IOException {
    FileInputStream in=new FileInputStream("D:\\Users\\Desktop\\2022-7-11_java第八章IO\\练习\\feige.exe");
    FileOutputStream out= new FileOutputStream("D:\\Users\\Desktop\\2022-7-11_java第八章IO\\练习\\feige.txt");
    BufferedInputStream bin = new BufferedInputStream(in);//缓存大小为DEFAULT_BUFFER_SIZE = 8192
    BufferedOutputStream bout =new BufferedOutputStream(out);
 
    int name=0;
    while ((name=bin.read())!=-1){//将数据读入底层的数组中（缓存区中），待读满缓存区中的8192个再输出
        bout.write(name);//并不是每次write都向磁盘去写数据，而是等缓存区数组满后再向磁盘输出
    }
    bin.close();
    bout.flush();//操作完成后，将缓存区刷新清空
    in.close();
    out.close();
}
}

处理流中的常用类：

缓冲字节输出流 BufferedOutputStream

缓冲字节输入流 BufferedInputStream

缓冲字符输入流 BufferedReader

缓冲字符输出流 BufferedWriter

缓冲的输入流和输出流：

将数据读入底层的数组中（缓存区中，缓存大小为DEFAULT_BUFFER_SIZE = 8192），待读满缓存区中的8192个再输出；并不是每次write都向磁盘去写数据，而是等缓存区数组满后再向磁盘输出。

  import java.io.*;

  public class Demo6 {
       
    public static void main(String[] args) throws IOException {
        FileInputStream in=new FileInputStream("D:\\Users\\Desktop\\2022-7-11_java第八章IO\\练习\\feige.exe");
        FileOutputStream out= new FileOutputStream("D:\\Users\\Desktop\\2022-7-11_java第八章IO\\练习\\feige.txt");
        BufferedInputStream bin = new BufferedInputStream(in);//缓存大小为DEFAULT_BUFFER_SIZE = 8192
        //BufferedInputStream bin = new BufferedInputStream(in，1024);可改变缓存大小
        BufferedOutputStream bout =new BufferedOutputStream(out);
   byte[] bytes=new byte[1024*1024];//当自定义数组大于缓存区数组长度时，缓存区数组会失效
    int name=0;
    while ((name=bin.read(bytes))!=-1){//将1024个数据读入byte数组中，再读入底层的数组中（缓存区中），待读满缓存区中的8192个再输出
        System.out.println(bytes);
        bout.write(name);
    }
    bin.close();
    bout.flush();//操作完成后，将缓存区刷新清空
    in.close();
    out.close();
}

}

输入输出节点字符流

字符流

字符输入流的基类：Reader

子类：FileReader extends InputStreamReader（转换流，将读到的字节按编码表(charsset)转换为字符）

字符输出流的基类：Writer extends OutputStream

子类：FileWriter extends InputStreamWriter（转换流，将读到的字符按编码表(charsset)转换为字节写出）

汉字的输入输出问题

在uft-8编码表中，一个汉字等于三个字节，底层存储的单位是字节，通过转换流，将读到的字节按编码表(charsset)转换为字符。

import java.io.*;

public class Demo8 {
   
public static void main(String[] args) throws IOException {
    FileReader fileReader=new FileReader("D:\\Users\\Desktop\\2022-7-11_java第八章IO\\练习\\File1.txt");
    FileWriter fileWriter=new FileWriter("D:\\Users\\Desktop\\2022-7-11_java第八章IO\\练习\\File2.txt");
    //        int name;
//        while ((name= fileReader.read())!=-1){
//            fileWriter.write(name);
//        }


    char[] chars=new char[5];
    int name;
    while ((name= fileReader.read(chars))!=-1){
        fileWriter.write(chars,0,name);
    }
    fileReader.close();
    fileWriter.close();
}
}

字符流缓冲输入：BufferedReader

字符流缓冲输出：BufferedWriter

 import java.io.*;

public class Demo9 {
       
    public static void main(String[] args) throws IOException {
   FileReader fileReader=new FileReader("D:\\Users\\Desktop\\2022-7-11_java第八章IO\\练习\\File1.txt");
    FileWriter fileWriter=new FileWriter("D:\\Users\\Desktop\\2022-7-11_java第八章IO\\练习\\File2.txt");
    //FileWriter fileWriter=new FileWriter(fileName,true);写入数据时，可以保留之前的数据，追加内容
    BufferedReader bufferedReader=new BufferedReader(fileReader);
    BufferedWriter bufferedWriter=new BufferedWriter(fileWriter);
    //        int name;
//        while ((name= fileReader.read())!=-1){
//            fileWriter.write(name);
//        }

//        char[] chars=new char[5];
//        int name;
//        while ((name= bufferedReader.read(chars))!=-1){
//            //bufferedWriter.write(chars);
//            bufferedWriter.write(chars,0,name);
//        }
 int name;
    String line;
    while ((line=bufferedReader.readLine())!=null){//readLine（）一次可以读取一行数据
        bufferedWriter.write(line);
        bufferedWriter.newLine();//插入换行符
    }
 
    bufferedReader.close();
    bufferedWriter.close();
    fileReader.close();
    fileWriter.close();
}
}

Print流

Print流（打印流）：只做输出操作，单位的从程序向目标输出数据，没有输入操作。按打印的数据类型分可分为字节打印流和字符打印流。

PrintWriter：字符打印流print方法可以打印各种数据类型的数据。

   import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class Demo10 {
    
    public static void main(String[] args) throws FileNotFoundException {
        PrintWriter printWriter=new PrintWriter("D:\\Users\\Desktop\\2022-7-12_java第八章IO\\练习\\test.html");
   printWriter.print("<h1>Hello world<h1>");
    printWriter.print("<h1>Hello world<h1>");
    printWriter.print("<h1>Hello world<h1>");
    printWriter.print("<h1>Hello world<h1>");
    printWriter.close();
}
}

对象输入输出流

在编码过程中，对象被存储在内存中，程序终止运行时，内存数据会被刷新清空，有时需要保存对象中的数据，需要使用流对象，将对象数据输出到文件中，做到对象数据的持久化（长久保存）。

对象输入输出流,都属于处理流:

ObjectInputStream（反序列化） ObjectOutputStream（序列化）

这过程也称为对象序列化和反序列化。

   import java.io.*;
import java.util.Date;

public class Demo11 {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //对象序列化，对象序列化后有它自己特定的格式
        FileOutputStream fileOutputStream=new FileOutputStream("D:\\Users\\Desktop\\2022-7-12_java第八章IO\\练习\\temp\\test.txt");
        ObjectOutputStream objectOutputStream=new ObjectOutputStream(fileOutputStream);
        Date date=new Date();
        String s="ABCdef";
        objectOutputStream.writeObject(date);
        objectOutputStream.writeObject(s);
   objectOutputStream.flush();
    objectOutputStream.close();
 
    //对象反序列化，会新创建对象
    FileInputStream fileInputStream=new FileInputStream("D:\\Users\\Desktop\\2022-7-12_java第八章IO\\练习\\temp\\test.txt");
    ObjectInputStream objectInputStream=new ObjectInputStream(fileInputStream);
    Date date1=(Date) objectInputStream.readObject();
    String s1=(String)objectInputStream.readObject();
    System.out.println(date1);
    System.out.println(s1);
    objectInputStream.close();
}
}

Serializable序列化接口

Serializable 序列化接口：如果需要将某一对象进行序列化，那么此类必须实现Serializable接口 实现后，会生成一个版本号，如果不显示的定义版本号，会自定默认生成。

对象序列化，对象序列化后有它自己特定的格式；对象反序列化，会新创建对象。

自动生成版本号会有一个问题，每次当类改变了，版本号会重新生成 所以但一个类需要经常序列化和反序列化时，建议显式定义版本号。

序列化版本号，版本号的显式定义后，类信息发生改变后不会重新生成。

transient关键字：transient定义的属性，在序列化时不会保存到文件中。

import java.io.Serializable;

public class Animal implements Serializable {
   
​    //序列化版本号，版本号的显式定义后，类信息发生改变后不会重新生成
​    private static final long serialVersionUID = -5869686875672962881L;
​    //transient定义的属性，在序列化时不会保存到文件中
​    private transient int age;
​    private String name;
public Animal(int age, String name) {
    this.age = age;
    this.name = name;
}
 
public int getAge() {
    return age;
}
 
public void setAge(int age) {
    this.age = age;
}
 
public String getName() {
    return name;
}
 
public void setName(String name) {
    this.name = name;
}
 
@Override
public String toString() {
    return "Animal{" +
            "age=" + age +
            ", name='" + name + '\'' +
            '}';
}
}




    import java.io.*;
import java.util.Date;

public class AnimalTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //对象序列化，对象序列化后有它自己特定的格式
        FileOutputStream fileOutputStream=new FileOutputStream("D:\\Users\\Desktop\\2022-7-12_java第八章IO\\练习\\temp\\test.txt");
        ObjectOutputStream objectOutputStream=new ObjectOutputStream(fileOutputStream);
        Animal animal1=new Animal(5,"旺财");
        objectOutputStream.writeObject(animal1);
    objectOutputStream.flush();
    objectOutputStream.close();
 
    //对象反序列化，会新创建对象
    FileInputStream fileInputStream=new FileInputStream("D:\\Users\\Desktop\\2022-7-12_java第八章IO\\练习\\temp\\test.txt");
    ObjectInputStream objectInputStream=new ObjectInputStream(fileInputStream);
    Animal animal2=(Animal) objectInputStream.readObject();
    System.out.println(animal2);
    objectInputStream.close();
}
}

未来是会发光的️
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
java 读写同时_java对同一个文件进行读写操作方法
weixin_36224054的博客
02-12 3303
同一个文件是不可以进行同时的读写的，因为我们写入文件会覆盖原文件的，如果这样，对于同一文件来来说，文件发生覆盖，无法进行下次读取当然，对于两个不同的文件，可以一边读一边写的操作题目：一个文本中存储26个无序字母，要求对字母排序后重新写入该文件中分析:可以在内存中用一定的形式存储读入的文件内容，然后进行写入，分开操作。1.用集合存储读入的文件public static void fileRevise...
Java——IO流小结
smile4548656的博客
04-22 128
Java——IO流小结一、字节流二、字符流三、字节流复制文件的常用方式四、字符流复制文件的常用方式 一、字节流 字节流 字节输入流InputStream FileInputStream BufferedInputStream 字节输出流OutputStream FileOutputStream BufferedOutputStream 二、字符流 字符流 字符输入流Reader InputStreamReader——FileReader BufferedReader 字符输出
【JAVA】IO流
m0_56492261的博客
07-12 506
今天学习IO流的相关知识。 File类 在程序中抽象的表示计算机中的文件或目录。 一个File类对象可以表示文件和路径， 可以对文件的属性进行操作，但不能直接对文件进行读写操作。路径有两种：绝对路径，完整的路径 D:\File.txt相对路径，不是全路径,是两个文件的相对同一个父级的路径 File.txt 对目录遍历，获得所有子目录和文件 输入输出，将电脑的硬盘上的数据往程序读为输入，把程序中的数据往程序外读为输出。IO流中的流意思是读写文件的操作类。IO输入流和输出流，读写文件的操作，根据操作单位
java 文件同步读写的几种方式
aa112901a的博客
12-13 5343
方案1：利用RandomAccessFile的文件操作选项s，s即表示同步锁方式写 ? 1 RandomAccessFile file = new RandomAccessFile(file, "rws"); 方案2：利用FileChannel的文件锁 ?
Java 如何对文件进行多个Object对象流的读写操作
web开发
11-19 409
思路：把已经序列化的对象存入容器（如LinkedList&lt;?&gt;）中，然后用ObjectInputStream和ObjectOutputStream对这个实例化的LinkedList&lt;?&gt;对象进行读写。 测试主程序： /** * @Title: FileRW.java * @Package com.file * @Description: 文件、文件夹的创...
JAVA——IO相关知识
爱学习的鱼的博客
07-26 93
java——IO流
qq_25271459的博客
06-06 608
IO流 字符流 字节流 转换流
Java——IO流
qq_62443736的博客
12-09 327
1.什么是IO流？ 1.1 IO流的概念 IO流是用于操作计算机硬盘和内存中的文件数据。 1.2 IO流的分类 IO流分为字节流和字符流。 用一张体系图可能更直观一些，上图：
java——IO流技术.pdf
04-03
### Java IO流技术详解 #### 一、IO流概述 在Java编程中，**IO流**(Input/Output Stream)主要用于实现数据的输入与输出操作。无论是文件读写、网络通信还是程序间的交互，几乎所有的数据交换都依赖于IO流。 #####...
java基础——IO流及File-RandomAccessFile对象.docx
01-02
java基础——IO流及File-RandomAccessFile对象.docx
浅谈java IO流——四大抽象类
08-26
java IO流——四大抽象类 java IO流是java语言中用于输入输出操作的基本类库，IO流是Java程序中最基本也最重要的一部分，java IO流主要可以分为两大类：字节流和字符流。在java中，四大抽象类是IO流的基础，它们...
JavaIO文件复制优化-JavaIO优化详解（下载可用）
05-30
JavaIO文件复制优化——JavaIO优化详解（下载可用）。个人经导师指导并认可通过的98分大作业设计项目，适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。...
JAVA IO API使用详解
09-04
2. 字节流与字符流：Java的IO系统基于两种基本流类型——字节流（Byte Stream）和字符流（Character Stream）。字节流以字节（8位）为单位处理数据，适用于处理任何类型的二进制数据，如图片、音频文件等。字符流则...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1249
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
golang 接口
m0_70982551的博客
07-24 796
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 264
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 472
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 2390
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1371
Java实现拼图小游戏
Java全栈IO知识深度解析
“Java 全栈知识点问题汇总（4）PDF文档主要涵盖了Java IO相关的知识，特别是从数据传输方式和操作对象角度对IO流进行了详细解释，并介绍了Java IO中使用的设计模式——装饰者模式。” 在Java全栈开发中，IO（Input...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

未来是会发光的️

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值