javaIO流部分总结

最新推荐文章于 2021-11-12 21:18:38 发布
最新推荐文章于 2021-11-12 21:18:38 发布
阅读量781 收藏 3
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vv494049661/article/details/52097165
版权

一、 流的分类

• 按数据流动方向

– 输入流：只能从中读取字节数据，而不能向其写出数据

– 输出流：只能向其写入字节数据，而不能从中读取数据

• 按照流所处理的数据类型

– 字节流：用于处理字节数据。

– 字符流：用于处理Unicode字符数据。

• 按照流所处理的源

– 节点流:从/向一个特定的IO设备读/写数据的流。（低级流）

– 处理流:对已存在的流进行连接和封装的流。（高级流）

二、 缓冲流

• 缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓

冲的功能，提高了读写的效率，同时增加了一些新的方法。

• J2SDK提供了四种缓存流：

– BufferedReader

– BufferedWriter

– BufferedInputStream s

– BufferedOutputStream

• 缓冲输入流支持其父类的mark()和reset()方法：

– mark()用于“标记”当前位置，就像加入了一个书签，可以使用reset()方法返回这个标记重新读取数据。

• BufferedReader提供了readLine()方法用于读取一行字符串（以\r或\n分隔）。

• BufferedWriter提供了newLine()用于写入一个行分隔符。

• 对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush()方法将会使内存中的数据立刻写出。

三、 类层次

3.1、InputStream类层次

3.2、OutputStream类层次

3.3、Reader类层次

3.4、Writer类层次

四、 常用的字符流与字节流的转化

说明：

  1. 字节流用于读写诸如图像数据之类的原始字节流。

  2. 字符流用于读写诸如文件数据之类的字符流。

  3. 低级流能和外设交流。

  4. 高级流能提高效率。

  5. InputStreamReader 是字节流通向字符流的桥梁。

  6. OutputStreamWriter是字符流通向字节流的桥梁。

代码：

一，读取文件：    


import java.io.InputStream;

/**
 * 文件的读取
 * 1、建立联系   File对象
    2、选择流     文件输入流  InputStream FileInputStream
    3、操作  : byte[] car =new byte[1024];  +read+读取大小
              输出
    4、释放资源 :关闭
 * @author Administrator
 *
 */
public class Demo01 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //1、建立联系   File对象
        File src =new File("e:/xp/test/a.txt");
        //2、选择流
        InputStream is =null; //提升作用域
        try {
            is =new FileInputStream(src);
            //3、操作 不断读取 缓冲数组
            byte[] car =new byte[1024];
            int len =0; //接收 实际读取大小
            //循环读取
            StringBuilder sb =new StringBuilder();
            while(-1!=(len=is.read(car))){
                //输出  字节数组转成字符串
                String info =new String(car,0,len);
                sb.append(info);
            }
            System.out.println(sb.toString());


        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件不存在");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("读取文件失败");
        }finally{
            try {
                //4、释放资源
                if (null != is) {
                    is.close();
                }
            } catch (Exception e2) {
                System.out.println("关闭文件输入流失败");
            }
        }
    }

}


二，写出文件：

/**
 * 写出文件
1、建立联系   File对象  目的地
2、选择流     文件输出流  OutputStream FileOutputStream
3、操作  :  write() +flush
4、释放资源 :关闭
 * @author Administrator
 *
 */
public class Demo02 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //1、建立联系   File对象  目的地
        File dest =new File("e:/xp/test/test.txt");
        //2、选择流   文件输出流  OutputStream FileOutputStream
        OutputStream os =null;
        //以追加形式 写出文件 必须为true 否则为覆盖
        try {
            os =new FileOutputStream(dest,true);
            //3、操作
            String str="bjsxt is very good \r\n";
            //字符串转字节数组
            byte[] data =str.getBytes();
            os.write(data,0,data.length);

            os.flush(); //强制刷新出去
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件未找到");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件写出失败");
        }finally{
            //4、释放资源 :关闭
            try {
                if (null != os) {
                    os.close();
                }
            } catch (Exception e2) {
                System.out.println("关闭输出流失败");
            }
        }
    }

}

三.字符流,读取纯文本。



/**
 * 纯文本读取
 * @author Administrator
 *
 */
public class Demo01 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //创建源
        File src =new File("E:/xp/test/a.txt");
        //选择流
        Reader reader =null;
        try {
            reader =new FileReader(src);
            //读取操作
            char[] flush =new char[1024];
            int len =0;
            while(-1!=(len=reader.read(flush))){
                //字符数组转成 字符串
                String str =new String(flush,0,len);
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("源文件不存在");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件读取失败");
        }finally{
            try {
                if (null != reader) {
                    reader.close();
                }
            } catch (Exception e2) {
            }
        }
    }

}


四，文件的写出：        




/**
 * 写出文件
 * @author Administrator
 *
 */
public class Demo02 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //创建源
        File dest =new File("e:/xp/test/char.txt");
        //选择流
        Writer wr =null;
        try {
            //追加文件，而不是覆盖文件
            wr =new FileWriter(dest);
            //写出
            String msg ="追加.....锄禾日当午\r\n码农真辛苦\r\n一本小破书\r\n一读一上午";
            wr.write(msg);
            wr.append("倒萨发了看电视剧 ");

            wr.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                if (null != wr) {
                    wr.close();
                }
            } catch (Exception e2) {
            }
        }
    }

}
/**
 * 转换流: 字节转为字符
 * 1、输出流 OutputStreamWriter 编码
 * 2、输入流 InputStreamReader  解码
 * 
 * 确保源不能为乱码
 * @author Administrator
 *
 */
public class ConverDemo02 {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        //指定解码字符集
        BufferedReader br =new BufferedReader(
                new InputStreamReader(
                    new BufferedInputStream(
                            new FileInputStream( 
                                    new File("E:/xp/test/Demo03.java"))),"UTF-8")
                );
        //写出文件 编码
        BufferedWriter bw =new BufferedWriter(
                new OutputStreamWriter(
                    new BufferedOutputStream(   
                    new FileOutputStream(new File("E:/xp/test/encode.java")))));

        String info =null;
        while(null!=(info=br.readLine())){
            //System.out.println(info);
            bw.write(info);
            bw.newLine();
        }
        bw.flush();
        bw.close();
        br.close();
    }

}

其他流的补充

字节流

/**
 *1、文件  --程序->字节数组
 *1)、文件输入流     
 *      字节数组输出流
 *
 *
 * 2、字节数组  --程序->文件
 * 1)、字节数组输入流
 *      文件输出流
 * @author Administrator
 *
 */
public class ByteArrayDemo02 {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        byte[] data =getBytesFromFile("e:/xp/test/1.jpg");
        toFileFromByteArray(data,"e:/xp/test/arr.jpg");
    }
    /**
     * 2、字节数组  --程序->文件
     */
    public static void toFileFromByteArray(byte[] src,String destPath) throws IOException{
        //创建源
        //目的地
        File dest=new File(destPath);

        //选择流
        //字节数组输入流
        InputStream is =new BufferedInputStream(new ByteArrayInputStream(src));     
        //文件输出流
        OutputStream os =new BufferedOutputStream(new FileOutputStream(dest));

        //操作 不断读取字节数组
        byte[] flush =new byte[1];
        int len =0;
        while(-1!=(len =is.read(flush))){
            //写出到文件中
            os.write(flush, 0, len);
        }
        os.flush();

        //释放资源
        os.close();
        is.close();


    }


    /**
     * 1、文件  --程序->字节数组
     * @return
     * @throws IOException 
     */
    public static byte[] getBytesFromFile(String srcPath) throws IOException{
        //创建文件源
        File src =new File(srcPath);
        //创建字节数组目的地 
        byte[] dest =null;

        //选择流
        //文件输入流     
        InputStream is =new BufferedInputStream(new FileInputStream(src));
        //字节数组输出流 不能使用多态
        ByteArrayOutputStream bos =new ByteArrayOutputStream();


        //操作   不断读取文件 写出到字节数组流中
        byte[] flush =new byte[1024];
        int len =0;
        while(-1!=(len =is.read(flush))){
            //写出到字节数组流中
            bos.write(flush, 0, len);
        }
        bos.flush();

        //获取数据
        dest =bos.toByteArray();

        bos.close();
        is.close();     
        return dest;
    }

}

处理流

1、基本类型+String 保留数据+类型
输入流:DataInputStream readXxx
输出流:DataOutputStream writeXxx
2、引用类型 (对象) 保留数据+类型
反序列化 输入流:ObjectInputStream readObject()
序列化 输出流:ObjectOutputStream writeObject()
注意:
1)、先序列化后反序列化；反序列化顺序必须与序列化一致
2)、不是所有的对象都可以序列化， java.io.Serializable
不是所有的属性都需要序列化，transient

/**
 * 数据类型(基本+String)处理流
 * 1、输入流 DataInputStream  readXxx()
 * 2、输出流 DataOutputStream writeXxx()
 * 新增方法不能使用多态
 * 
 * java.io.EOFException :没有读取到相关的内容
 * @author Administrator
 *
 */
public class DataDemo01 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        try {
            //write("e:/xp/test/data.txt");
            //read("e:/xp/test/arr.txt"); //非法内容
            read("e:/xp/test/data.txt");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }



    }
    /**
     * 从文件读取数据+类型
     * @throws IOException 
     */
    public static void read(String destPath) throws IOException{
        //创建源
        File src =new File(destPath);
        //选择流
        DataInputStream dis =new DataInputStream(
                    new BufferedInputStream(
                                new FileInputStream(src)
                            )
                );

        //操作 读取的顺序与写出一致   必须存在才能读取
        //不一致，数据存在问题
        long num2 =dis.readLong();
        double num1 =dis.readDouble();
        String str =dis.readUTF();

        dis.close();
        System.out.println(num2+"-->"+str);

    }
    /**
     * 数据+类型输出到文件
     * @throws IOException 
     */
    public static void write(String destPath) throws IOException{
        double point =2.5;
        long num=100L;
        String str ="数据类型";

        //创建源
        File dest =new File(destPath);
        //选择流  DataOutputStream
        DataOutputStream dos =new DataOutputStream(
                    new BufferedOutputStream(
                                new FileOutputStream(dest)
                            )
                );
        //操作 写出的顺序 为读取准备
        dos.writeDouble(point);
        dos.writeLong(num);
        dos.writeUTF(str);      
        dos.flush();

        //释放资源
        dos.close();





    }

}

/**
 * 空接口只是标识
 * @author Administrator
 *
 */
public class Employee implements java.io.Serializable {
    //不需要序列化
    private transient String name;
    private double salary;
    public Employee() {
    }
    public Employee(String name, double salary) {
        super();
        this.name = name;
        this.salary = salary;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }


}

/**
 * 不是所有的對象都可以序列化  java.io.NotSerializableException
 * 不是所有的屬性都需要序列化  transient
 * @author Administrator
 *
 */
public class ObjectDemo01 {

    /**
     * @param args
     * @throws ClassNotFoundException 
     */
    public static void main(String[] args) throws ClassNotFoundException {
        try {
            seri("e:/xp/test/ser.txt");
            read("e:/xp/test/ser.txt");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //反序列化
    public static void read(String destPath) throws IOException, ClassNotFoundException{
        //创建源
        File src =new File(destPath);
        //选择流
        ObjectInputStream dis =new ObjectInputStream(
                    new BufferedInputStream(
                                new FileInputStream(src)
                            )
                );

        //操作 读取的顺序与写出一致   必须存在才能读取
        //不一致，数据存在问题
        Object obj =dis.readObject();
        if(obj instanceof Employee){
            Employee emp=(Employee)obj;
            System.out.println(emp.getName());
            System.out.println(emp.getSalary());
        }

        obj =dis.readObject();
        int[] arr=(int[])obj;
        System.out.println(Arrays.toString(arr));
        dis.close();
    }

    //序列化
    public static void seri(String destPath) throws IOException{
        Employee emp =new Employee("bjsxt",1000000);
        int[] arr ={1,2,3,45};
        //创建源
        File dest =new File(destPath);
        //选择流  ObjectOutputStream
        ObjectOutputStream dos =new ObjectOutputStream(
                    new BufferedOutputStream(
                                new FileOutputStream(dest)
                            )
                );
        //操作 写出的顺序 为读取准备
        dos.writeObject(emp);
        dos.writeObject(arr);
        //释放资源
        dos.close();
    }
}

编写工具类实现关闭的方法：

package com.bjsxt.io.util;

import java.io.Closeable;

public class FileUtil {

    /**
     * 工具类关闭流
     * 可变参数: ...  只能形参最后一个位置,处理方式与数组一致
     */
    public static void close(Closeable ... io){
        for(Closeable temp:io){
            try {
                if (null != temp) {
                    temp.close();
                }
            } catch (Exception e) {
            }
        }

    }
    /**
     * 使用泛型方法
     */
    public static <T extends Closeable> void closeAll(T ... io){
        for(Closeable temp:io){
            try {
                if (null != temp) {
                    temp.close();
                }
            } catch (Exception e) {
            }
        }
    }

}

打印流：

/**
 * PrintStream 打印流 -->处理流
 * @author Administrator
 *
 */
public class PrintStreamDemo01 {

    /**
     * @param args
     * @throws FileNotFoundException 
     */
    public static void main(String[] args) throws FileNotFoundException {
        System.out.println("test");
        PrintStream ps =System.out;
        ps.println(false);


        //输出到文件
        File src = new File("e:/xp/test/print.txt");
        ps = new PrintStream(new BufferedOutputStream(new FileOutputStream(src)));
        ps.println("io is so easy....");

        ps.close();
    }

}

System.in

System.out

System.err

/**
 * 三个常量
 * 1、System.in  输入流  键盘输入
 * 2、System.out 输出流   控制台输出
 *    System.err
 *    
 * ==>重定向   
 * setIn()
 * setOut()
 * setErr()
 * FileDescriptor.in
 * FileDescriptor.out
 * @author Administrator
 *
 */
public class SystemDemo01 {

    /**
     * @param args
     * @throws FileNotFoundException 
     */
    public static void main(String[] args) throws FileNotFoundException {
        //test1();
        //test2();
        //重定向
        System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream("e:/xp/test/print.txt")),true));
        System.out.println("a");  //控制台  -->文件      
        System.out.println("test");
        //回控制台
        System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)),true));
        System.out.println("back....");
    }
    public static void test2() throws FileNotFoundException{
        InputStream is =System.in;  //键盘输入
        is = new BufferedInputStream(new FileInputStream("e:/xp/test/print.txt"));
        Scanner sc = new Scanner(is);
        //System.out.println("请输入:");
        System.out.println(sc.nextLine());
    }

    public static void test1(){
        System.out.println("test");
        System.err.println("err");
    }

}

IO图形化小结：

一、步骤： 创建源 选择流 操作(读取|写出) 释放
二、流

节点流:离数据源|程序最近的流 处理流:装饰模式 提高性能增强功能
1、 字节流:可以处理一切(纯文本、音频、视频等)
1)、输入流 InputStream FileInputStream
ByteArrayInputStream
操作: read(字节数组)
a)、中间容器 byte[] flush=new byte[长度]
b)、接收长度 int len =0;
c)、循环读取 while(-1!=(len=流.read(flush))){}
d)、操作:输出、拷贝
2)、输出流 OutputStream FileOutputStream
ByteArrayOutputStream
操作: write(字节数组,0,长度) 输出
2、 字符流:只能处理纯文本
1)、输入流:Reader FileReader
操作: read(字符数组)
a)、中间容器 char[] flush=new char[长度]
b)、接收长度 int len =0;
c)、循环读取 while(-1!=(len=流.read(flush))){}
d)、操作:输出、拷贝
2）、输出流:Writer FileWriter
操作: write(字符数组,0,长度) 输出
1、 转换流:解码与编码字符集问题
1)、输入流:InputStreamReader à解码
2)、输出流:OutputStreamWriter—>编码
2、缓冲流:提高性能
1)、输入流:BufferedInputStream BufferedReader
2)、输出流:BufferedOutputStream BufferedWriter
3、处理数据+类型
1)、基本+字符串：必须存在才能读取 读取与写出顺序一致
a)、输入流:DataInputStream readXxx
b)、输出流:DataOutputStream writeXxx
2）、引用类型:Serializable transient
a)、反序列化:ObjectInputStream readObject
b)、序列化:ObjectOutputStream writeObject
4、打印流: PrintStream
5、System.in out err setIn setOut
以下流使用新增方法不能发生多态
1、 ByteArrayOutputStream: toByteArray()
2、 BufferedReader: readLine()
3、 BufferedWriter:newLine()
4、 DataInputStream DataOutputStream
5、 ObjectInputStream ObjectOutputStream
6、 PrintStream

Java io流总结
08-12
Java io流的总结
JAVA中IO流总结
皮斯特劳沃
12-24 5840
本文是在学习中的总结，欢迎转载但请注明出处：http://write.blog.csdn.net/postedit/42119261 我想你对JAVA的IO流有所了解，平时使用的也比较的多，但是对于其具体分类和继承体系可能知道的并不多，可能也很少去看相关的API文档，找出其中的关系和各自的应用 情形。本文简单对常用的IO流进行分类整理，并简单举例说明其应用。希望本文对你有所帮助。
IO流
AndrewBest的博客
02-21 268
目录File类概述常用构造器常用方法流的分类概述InputStreamReaderOutputStreamWriter节点流（或文件流）缓冲流转换流InputStreamReaderOutputStreamWriter标准输入、输出流打印流PrintStream&PrintWriter数据流对象流ObjectInputStream&ObjectOutputStream对象的序列化随机存取文件流RandomAccessFileCommonsIO File类 概述 java.io.File类：
javaIO流总结
JamesLi6的博客
07-24 575
一、  流的分类   •   按数据流动方向   – 输入流：只能从中读取字节数据，而不能向其写出数据   – 输出流：只能向其写入字节数据，而不能从中读取数据   •   按照流所处理的数据类型   – 字节流：用于处理字节数据。   – 字符流：用于处理Unicode字符数据。   •   按照流所处理的源   – 节点流:从/向一个特定的IO设备读/写数据的流
《JAVA_IO流学习总结》
04-23
总结来说，Java IO流是一个庞大的体系，覆盖了从基础的文件操作到复杂的网络通信，理解并熟练掌握这一部分将极大地提升Java开发者的技能。通过学习和实践，开发者可以灵活地处理各种数据输入输出场景，为应用程序...
javaio流学习总结.pdf
最新发布
02-28
本文将对Java IO流进行深入的总结和解析。 一、IO流的分类 Java IO流被分类为以下四类： 1. **按流的方向**：输入流（InputStream/Reader）负责数据的读取，而输出流（OutputStream/Writer）负责数据的写入。 2....
JavaIO流学习总结报告.doc
12-26
Java IO流是Java平台中用于处理输入输出操作的重要部分，它提供了数据传输的抽象层，让我们能够方便地处理各种数据源和接收端。流的概念是将数据视作一个连续的字节序列，可以是读取（输入流）或写入（输出流）。...
2022年java io流学习总结.docx
07-12
2022年的Java IO流学习总结主要涵盖以下核心知识点： 1. **流的概念**：流是数据传输的抽象概念，表示数据的流动方向，可以是从文件到内存，也可以是从键盘到屏幕。Java中的IO流分为两种基本类型，字节流（Byte ...
Java IO流总结
qq_45321888的博客
11-12 784
IO流概述: IO: 输入/输出(Input/Output) 流：是一种抽象概念,是对数据传输的总称。也就是说数据在设备间的传输称为流,流的本质是数据传输，IO流就是用来处理设备间数据传输问题的 常见的应用:文件复制;文件上传;文件下载 按流向分类： 输入流 输出流 按类型分类： 字节流 字符流 字节流 字节流抽象基类: InputStream: 这个抽象类是表示字节输入流的所有类的超类 OutputStream: 这个抽象类是表示字节输出流的所有类的超类 子类名特点: 子类名称都是以其父类名作为子类
JAVA IO流总结
80后大叔爱学习
08-02 251
1、File的说明： ①如何创建File类的实例： File(String filePath) File(String parentPath, String childPath) File(File parentPath,String childPath) ②路径： 相对...
Java IO 流总结
Skye's blog
11-11 382
本文对 Java 中的 IO 流的概念和操作进行了梳理总结，并给出了对中文乱码问题的解决方法。
java之IO流总结
melody_sy博客
12-21 570
java之IO流总结 1.什么是IO流？         Java中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。         Java.io是大多数面向数据
java IO流总结
WannerWang的博客
10-31 585
java IO流 字节流和字符流 InputStream（字节流）和Reader（字符流）是所有输入流的基类，本身不能创建实例来实现，但是是所有输入流的模板它们提供的方法所有的流都可以使用 OutPutStream（字节流） 与write （字符流）分别是按字节，与字符操作流中的数据。 java IO流执行输出时，不要忘记关闭关闭，关闭输出流除了可以保证流的物理资源被回收之外，可能还可以将
java io流总结
仰望星空
08-09 291
定义：io流简单的来说就是输入和输出流，io流用来处理设备间的数据传输。 按操作数据分为：字节流和字符流 按流向分为：输入流和输出流 字节流是java中可以按照最小字节单位读取的流，每次读写一个字节 字符流是基于字节流，去查找指定的码表 如果是纯文本数据优先使用字符流，除此之外都是使用字节流 io流的整体架构图： io流使用的简单示例： 字节流读写操作 /** * 读写文件流操作 字节流 ...
java IO流总结梳理
小虾的博客
03-08 594
http://blog.csdn.net/yuebinghaoyuan/article/details/73880591、什么是流？ 流是对数据传输的总称或抽象。即数据在两设备间的传输称为流。本质就是数据传输2、io流的分类根据数据流的方向：输入流和输出流根据处理数据单位：字节流和字符流根据实现功能不同：节点流和处理流输入流和输出流输入和输出都是从程序的角度来说的字节流和字符流字节流：一次读入或者...
JavaIO字节输出流详细总结教程
Java中的IO流是Java输入/输出的基础，用于处理设备之间数据的输入输出。Java流可以分为字节流和字符流两大类。字节流处理的基本单位是字节，用于处理二进制数据；字符流处理的基本单位是字符，通常用于处理文本数据...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值