IO流知识小结（一）

最新推荐文章于 2024-04-06 17:15:33 发布
原创 最新推荐文章于 2024-04-06 17:15:33 发布 · 280 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

输出流
这里写图片描述

输入流
这里写图片描述

File类
这里写图片描述

File类学习代码

package com.imooc.file;

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

public class FileDemo 
{

    public static void main(String[] args) 
    {
        //创建File对象的三种构造方法,由于反斜杠代表转义字符，因此两个反斜杠才能代表一个真正的反斜杠的作用
        /*
         * File(String pathname)
         * ——通过将给定的路径名​​字符串转换为抽象路径名来创建新的文件实例。
         * File(String parent, String child)
         * ——从父抽象路径名和子路径名字符串创建新的文件实例。
         * 注意File类对象指向的路径不需要一定存在
         */
        File file1=new File("G:\\imooc\\io\\score.txt");//方法一
        File file2=new File("G:\\imooc","io\\score.txt");//方法二

        //方法3
        /*
         * public File(File parent,String child)
         */
        File file3=new File("G:\\imooc");
        File file4=new File(file3,"io\\score.txt");
        //判断是文件还是目录
        /*
         * public boolean isDirectory()
         * ——测试此抽象路径名所表示的文件是否为目录。
         * public boolean isFile()
         * ——测试此抽象路径名所表示的文件是否为文件。
         */
        System.out.println("file1的路径名表示的是否是目录:"+file1.isDirectory());
        System.out.println("file1的路径名表示的是否是文件:"+file1.isFile());
        System.out.println("file2的路径名表示的是否是目录:"+file2.isDirectory());
        System.out.println("file2的路径名表示的是否是文件:"+file2.isFile());

        //创建目录
        /*
         * public boolean exists()
         * ——判断File类对象指向的路径是否存在,存在则返回true,不存在则返回false
         */
        File file5=new File("G:\\imooc","set\\HashSet");
        if(!file5.exists())//如果set目录及其子目录HashSet不存在,则创建多级目录
        {
            /*
             * public boolean mkdirs()
             * ——创建以File类对象指向的路径名命名的多级目录
             * public boolean mkdir()
             * ——创建以File类对象指向的路径名命名的单级目录
             */
            file5.mkdirs();//由于G盘imooc下没有set目录及其子目录,因此要调用mkdirs实现多级目录创建
            System.out.println("目录set\\HashSet创建成功!");
        }


        //创建文件
        /*
         * public boolean createNewFile() throws IOException
         * ——创建以File类对象指向的路径名命名的文件
         */
        if(!file1.exists())
        {
            try 
            {
                file1.createNewFile();
                System.out.println("文件score.txt创建成功!");
            } 
            catch (IOException e) 
            {
                e.printStackTrace();
            }
        }
    }
}

字节输入输出流
一、字节流
这里写图片描述
1、字节输入流类及其子类
之后的代码重点学习文件输入流和缓冲输入流，字符输入流等其他流可以对比着学习，基本上是大同小异。
这里写图片描述
(1)文件输入流及其常用方法
这里写图片描述
这里写图片描述

字节输入流之文件输入流学习代码一
package com.imooc.input_output_stream;

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

public class FileInputStreamDemo1 
{

    public static void main(String[] args) 
    {
        //创建一个FileInputStream对象
        /*
         * 两种常用构造方法:
         * public FileInputStream(File file) throws FileNotFoundException
         * public FileInputStream(String name) throws FileNotFoundException
         */
        try 
        {
            //由于imooc.txt是存放在这个工程目录下的,是相对路径,因此直接写文件名即可
            FileInputStream fis=new FileInputStream("imooc.txt");
            /*
             * public int read() throws IOException
             * ——从此文件输入流读取"一个"字节,返回读取的字节数据.
             * 注意,读取一个字节后就不会再读取这个字节了,相当于水管中取水滴
             * 如果第二遍执行read方法那么读取的就是下一个字节了
             */
            int n;
            while((n=(fis.read()))!=-1)//读取的字节为-1时,说明读到了文件的末尾
            {
                System.out.print((char) n);//将读到的字节转换为对应的字符
            }
            /*
             * public void close() throws IOException
             * ——关闭此文件输入流，并释放与流相关联的任何系统资源。
             * 要养成随手关闭输入流的习惯
             */
            fis.close();
        } 
        catch (FileNotFoundException e) 
        {
            e.printStackTrace();
        } 
        catch (IOException e) //由于FileNotFoundException是IOException的子类,因此IOException要放后面
        {
            e.printStackTrace();
        }
    }

}

字节输入流之文件输入流学习代码二
package com.imooc.input_output_stream;

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

public class FileInputStreamDemo2 
{

    public static void main(String[] args) 
    {
        try 
        {
            FileInputStream fis=new FileInputStream("imooc.txt");
            /*
             * public int read(byte[] b) throws IOException
             * ————从该输入流中最多读取b.length个字节的数据并存放在字节数组b中,返回实际读取的字节数
             * public int read(byte[] b,int off,int len) throws IOException
             * ————从输入流中最多读取len个字节的数据,并将其存放在字节数组b中,但放入数组b中时,从index为off的位置开始放
             * 并返回实际读取的字节数
             */
            byte[] b=new byte[100];
            fis.read(b);//等价于fis.read(b,0,12)
            //将字节数组转换为字符串输出,利用之前学过的String类构造方法public String(byte[] bytes)
            System.out.println(new String(b));
            fis.close();
        } 
        catch (FileNotFoundException e) 
        {
            e.printStackTrace();
        } 
        catch (IOException e) 
        {
            e.printStackTrace();
        }
    }

}

2、字节输出流及其子类
这里写图片描述
(1)、文件输出流及其常用方法
这里写图片描述

字节输出流之文件输出流学习代码一
package com.imooc.input_output_stream;

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

public class FileOutputStreamDemo1 
{

    public static void main(String[] args) 
    {
        try 
        {
            /*
             * public FileOutputStream(String name) throws FileNotFoundException
             * ————用这种构造方法创建的输出流输出字节时会覆盖要写入文件原有的数据
             * public FileOutputStream(File file,boolean append) throws FileNotFoundException
             * ————用这种构造方法创建的输出流输出输出字节时,若append为true则在要写入文件最后写入新输出的数据,否则覆盖
             */
            FileOutputStream fos=new FileOutputStream("imooc.txt");
            /*
             * public void write(int b) throws IOException
             * ————将指定的字符输出到输出流中，其中b既可以代表字节，也可以代表字符
             */
            fos.write(50);
            fos.write('a');//字符是可以和整型之间相互转换的
            fos.close();
        } 
        catch (FileNotFoundException e) 
        {
            e.printStackTrace();
        } catch (IOException e) 
        {
            e.printStackTrace();
        }
    }

}
字节输出流之文件输出流学习代码二
package com.imooc.input_output_stream;

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

public class FileOutputStreamDemo2 
{

    public static void main(String[] args) 
    {
        try 
        {
            /*
             * public FileOutputStream(String name) throws FileNotFoundException
             * ————用这种构造方法创建的输出流输出字节时会覆盖要写入文件原有的数据
             * public FileOutputStream(File file,boolean append) throws FileNotFoundException
             * ————用这种构造方法创建的输出流输出输出字节时,若append为true则在要写入文件最后写入新输出的数据,否则覆盖
             */
            FileOutputStream fos=new FileOutputStream("imooc.txt",true);
            /*
             * public void write(int b) throws IOException
             * ————将指定的字符输出到输出流中，其中b既可以代表字节，也可以代表字符
             */
            fos.write(50);
            fos.write('a');//字符是可以和整型之间相互转换的
            fos.close();
        } 
        catch (FileNotFoundException e) 
        {
            e.printStackTrace();
        } catch (IOException e) 
        {
            e.printStackTrace();
        }
    }

}
字节输出流之文件输出流学习代码三
package com.imooc.input_output_stream;

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

public class FileOutputStreamDemo3 
{

    public static void main(String[] args) 
    {
        //文件拷贝,实际上就是字节数据经输入流输入再经输出流输出到另一个文件的过程
        try 
        {
            //创建读取图片数据的输入流
            FileInputStream fis=new FileInputStream("happy.png");
            //创建输出图片数据的输出流
            FileOutputStream fos=new FileOutputStream("happycopy.png");
            int n;
            byte[] b=new byte[2048];
            /*
             * public void write(byte[] b,int off,int len) throws IOException
             * ————向输出流中输出字节数组b中off位置开始的长度为len的字节数据
             */
            while((n=fis.read(b))!=-1)
            {
                fos.write(b,0,n);//用这种多参数的write方法可以保证不会写入多余的数据
            }
            fis.close();
            fos.close();
        } 
        catch (FileNotFoundException e) 
        {
            e.printStackTrace();
        } 
        catch (IOException e) 
        {
            e.printStackTrace();
        }
    }

}

3、缓冲流
这里写图片描述

缓冲流学习代码
package com.imooc.input_output_stream;

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

public class BufferDemo 
{

    public static void main(String[] args) 
    {
        try 
        {
            FileOutputStream fos=new FileOutputStream("imooc.txt");
            //创建缓冲输出流,将文件输出流和缓冲输出流连接
            /*
             * public BufferedOutputStream(OutputStream out)
             * ————创建新的缓冲输出流，以将数据写入指定的基础输出流。
             */
            BufferedOutputStream bos=new BufferedOutputStream(fos);

            FileInputStream fis=new FileInputStream("imooc.txt");
            //将文件输入流和缓冲输入流连接
            /*
             * public BufferedInputStream(InputStream in)
             * ————创建缓冲输入流并保存其参数————基础输入流，供以后使用。
             */
            BufferedInputStream bis=new BufferedInputStream(fis);

            /*
             * public void write(int b) throws IOException
             * ————将指定的字节写入此缓冲输出流,但实际是存储在缓冲输出流的内部缓冲区buf中,只有缓冲区满了
             * 才会自动执行写操作,因此需要手动强制清空内部缓存区执行写操作
             * public void flush() throws IOException
             * ————刷新此缓冲输出流，这将强制任何缓冲的输出字节被写出到基础输出流。只有具有缓冲区的输出流才需要使用此方法强制执行写数据的操作，但建议在每一个write语句后都加一句flush以防万一
             */
            bos.write(50);
            bos.write('a');
            bos.flush();
            bos.close();//释放资源
            /*
             * 缓冲输入流的read方法与文件输入流的read方法基本一致
             */
            System.out.println(bis.read());
            System.out.println((char) bis.read());
            bis.close();
        } 
        catch (FileNotFoundException e) 
        {
            e.printStackTrace();
        } 
        catch (IOException e) 
        {
            e.printStackTrace();
        }

    }

}

二、字符流

这里写图片描述
字符输入流和输出流
这里写图片描述
这里写图片描述
由于字符流和字节流方法基本一致，只有处理数据的不同，因此不单独写学习代码了，直接拿出字节字符转换流的代码。字节流转换成字符流。

package com.imooc.reader_writer;

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

public class ChangeStreamDemo 
{

    public static void main(String[] args) 
    {
        try 
        {
            FileInputStream fis=new FileInputStream("imooc.txt");
            /*
             * 将字节输入流转换为字符输入流
             * public InputStreamReader(InputStream in)
             */
            InputStreamReader isr=new InputStreamReader(fis);
            int n;
            char[] cbuf=new char[10];
            /*
             * public int read() throws IOException
             * ————从输入流读取单个字符,返回读取的字符数据(转换为int类型)
             * public int read(char[] cbuf) throws IOException
             * ————从输入流读取最多cbuf.length个字符的数据,存放在字符数组cbuf中,返回实际读取的字符数
             * public String(char[] value,int offset,int count)
             * ————从字符数组value的offset位置开始,创建一个长度为count的字符串
            */

            /*
             * 以下注释代码为读取的步骤,由于这个步骤会导致下面的输出流的例子出错,因此注释掉
            while((n=isr.read(cbuf))!=-1)
            {
                System.out.print(new String(cbuf,0,n));//保证最后一次在未将数组cbuf存满的时候也能正确输出
            }
            */

            //字节输出流转字符输出流
            FileOutputStream fos=new FileOutputStream("imooc1.txt");
            /*
             * public OutputStreamWriter(OutputStream out)
             * ————将基础字节输出流转换为字符输出流
             * public void write(char[] cbuf,int off,int len) throws IOException
             * ————将cbuf字符数组中第off个位置开始长度为len的字符串输出到输出流中
             */
            OutputStreamWriter osw=new OutputStreamWriter(fos);
            while((n=isr.read(cbuf))!=-1)
            {
                osw.write(cbuf,0,n);
                osw.flush();/*所有含有缓冲区的输出流的write方法都是在输出流的未满时不自动执行write操作的,
                因此需要手动清空强制执行write操作才能将输出流中的数据写入文件,之前学习的字节输出流中没有flush是因为
                后面加了close();但是实际中最好两个都加上
                */
            }
            fis.close();
            fos.close();
            isr.close();
            osw.close();
        } 
        catch (FileNotFoundException e) 
        {
            e.printStackTrace();
        } 
        catch (IOException e) 
        {
            e.printStackTrace();
        }
    }

}

三、对象序列化及反序列化
步骤
这里写图片描述
用到的类
这里写图片描述

对象序列化学习代码之Goods商品类
package com.imooc.serial;

import java.io.Serializable;
/*创建一个实现序列化接口的类*/
public class Goods implements Serializable
{
    private String goodsId;
    private String goodsName;
    private double price;
    public Goods()
    {

    }
    public Goods(String goodsId, String goodsName, double price) 
    {
        this.goodsId = goodsId;
        this.goodsName = goodsName;
        this.price = price;
    }
    public String getGoodsId() 
    {
        return goodsId;
    }
    public void setGoodsId(String goodsId) 
    {
        this.goodsId = goodsId;
    }
    public String getGoodsName() 
    {
        return goodsName;
    }
    public void setGoodsName(String goodsName) 
    {
        this.goodsName = goodsName;
    }
    public double getPrice() 
    {
        return price;
    }
    public void setPrice(double price) 
    {
        this.price = price;
    }
    @Override
    public String toString() 
    {
        return "Goods [goodsId=" + goodsId + ", goodsName=" + goodsName + ", price=" + price + "]";
    }


}

对象序列化学习代码之商品测试类
package com.imooc.serial;

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

public class GoodsTest 
{

    public static void main(String[] args) 
    {
        //定义Goods类对象,将对象写入文件中,再读出来判断是否写入成功
        Goods goods1=new Goods("gd001","电脑",3000);
        try 
        {
            /*
             * public ObjectOutputStream(OutputStream out) throws IOException
             * ————创建一个对象输出流以写入指定的输出流
             * public final void writeObject(Object obj) throws IOException
             * ————将一个指定的对象写入对象输出流
             */
            //将对象信息写入文件
            FileOutputStream fos=new FileOutputStream("imooc.txt");
            ObjectOutputStream oos=new ObjectOutputStream(fos);
            oos.writeObject(goods1);//将goods1对象写入文件imooc.txt中
            oos.flush();
            oos.close();
            fos.close();

            /*
             * public final Object readObject() throws IOException,ClassNotFoundException
             * ————从对象输入流读出一个对象
             */
            //将对象信息从文件读出来
            FileInputStream fis=new FileInputStream("imooc.txt");
            ObjectInputStream ois=new ObjectInputStream(fis);
            Goods goods2=(Goods)ois.readObject();//由于readObject方法返回的是Object类，因此要强制转换
            System.out.println(goods2);
            fis.close();
            ois.close();
        } 
        catch (FileNotFoundException e) 
        {
            e.printStackTrace();
        } catch (IOException e) 
        {
            e.printStackTrace();
        } catch (ClassNotFoundException e) 
        {
            e.printStackTrace();
        }

    }

}

这里写图片描述

IO流知识点整理总结
shmilyche的博客
11-04 2489
目录 一、IO流概述和分类 1、概述 2、IO流的分类 3、IO流的结构图 4、IO流的使用场景 二、字节流（总） 1、字节流介绍 2、字节输出流（OutputStream） 2.1、构造方法 2.2、字节输出流写数据的方法 2.3、字节输出流写数据的步骤： 2.4、字节输出流写数据的问题处理 3、字节输入流（InputStream） 3.1、构造方法 3.2、字节输入流读取数据的步骤 4、字节流综合应用 5、字节缓冲流 5.1、介绍 5.2、构造方法 5.3..
JavaIO流知识点总结
ojemmm的博客
10-14 1751
知识点 package IO流原理与概念; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.ByteArrayInputStream; import...
IO流知识总结一
weixin_39816332的博客
09-12 221
File ：IO用于操作设备数据文件的，而数据常见的体现方式就是文件。 先了解文件的操作。 创建、删除、存在、获取、隐藏...... 需求：这么操作文件数据呢？ 使用IO流对象，而且文件数据都是字节 学习了可以操作的文件的字节流 InputStream |--FileInputStream OutputStream |--FileOutputStream 为了提高操作效
Java IO流知识点总结
最新发布
weixin_43836337的博客
04-06 1691
I（Input）O（Output） 通过IO可以处理程序与外部环境之间的数据传输。
JAVA—IO流知识点总结
m0_60469045的博客
10-22 394
字符集（Character set）是多个字符的集合，字符集种类较多，每个字符集包含的字符个数不同，常见字符集名称：ASCII字符集、GB2312字符集、BIG5字符集、 GB18030字符集、Unicode字符集等。------>FileWriter(File file,false):输出过程，会创建同名的文件对现有的文件进行覆盖。------->FileWriter(File file,true)：输出过程，会在现有的文件末尾追加写出的内容。换句话说，IO流就是以流的方式进行输入输出。
java 关于io流的知识点,Java IO流知识点总结
weixin_39609752的博客
03-20 302
Java IO流总结java最近对java IO流进行了比较全面的学习，下面对知识点进行比较全面的总结：函数一．IO流的基本概念学习IO流主要用于硬板、内存、键盘等处理设备上得数据操做，根据处理数据的数据类型的不一样能够分为：编码字节流(抽象基类为InPutStream和OutPutStream)和字符流(抽象基类为Reader和Writer)。spa根据流向不一样，能够分为：输入流和输出流。o...
JAVA IO流知识点全总结
weixin_64133130的博客
08-05 2585
javaio知识点总结，方便查阅io的相关的相关知识点
java中的io流知识总结_java中IO流的知识点总结
weixin_42510600的博客
02-12 1145
1.流的概念流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。2.IO流的分类IO流分为字符流和字节流.3.字节流和字符流的区别1.字节流读取的时候，读到一个字节就返回一个字节； 字符流使用了字节流读到一个或多个字节(中文对应的字节数是两个，在UTF-8码表中是3个字节)...
java中的io流知识总结_关于java中的io流知识总结详解
weixin_34587189的博客
02-12 417
一、Java io的开始：文件1. 我们主要讲的是流，流的本质也是对文件的处理，我们循序渐进一步一步从文件将到流去。2. java 处理文件的类 File，java提供了十分详细的文件处理方法，举了其中几个例子，其余的可以去packagecom.hxw.io; importjava.io.*; publicclassFileExample{publicstaTIcvoidmain(String［］...
IO流知识点总结
qq_33700236的博客
11-27 240
IO流知识点总结 数据源： 数据库、文件、内存、网络、IO设备。 核心类： File：文件类 InputStream：字节输入流 OutputStream:字节输出流 Reader:字符输入流 Writer：字符输出流 Closeable：关闭流接口 Flushable：刷新流接口 Serialiazble：序列化接口 流分类： 1.输入输出流 输入流：数据源导出程序，InputStream、Re...
Java中IO流知识点总结
12-22
一、流的分类 　1、按功能分 　读取流：InputStream Reader 　写出流：OutPutStream Writer 　2、按流的类型分类 　字节流：InputStream OutputStream 　字符流：Reader Writer 　二、流功能分析 　读取流...
Java知识点总结大全(五) -- IO流.xmind
12-17
Java知识点总结大全(五) -- io流,关注后面会分享面向对象，io,集合，多线程，网络，sql的总结
javaIO流知识大总结
07-28
在这个大总结中，我们将深入探讨Java IO流的基本概念、分类、常用类以及实践应用。 1. **基本概念** - **流（Stream）**：在Java中，流是一个抽象的概念，代表数据的有序序列。它可以是字节流或字符流，流向可以是...
IntelliJ idea 2017创建Web项目后web文件夹下没有WEB-INF的解决方法
热门推荐
轻风起自远东
02-06 4万+
使用idea创建一个Web项目后发现并没有网上教程所说的web文件夹下有WEB-INF文件夹以及web.xml，查看刘荣星的博客后找到了答案。 老版本： 新版本： 解决办法： Ctrl+Shift+Alt+S快捷键进入Project structure(项目结构)管理的界面 选择左边菜单栏里的Facet，点击后能看到有Deployment Descriptors的输入框 展开左侧
Java数据库连接——JDBC基础知识（操作数据库：增删改查）
轻风起自远东
04-03 6343
一、JDBC简介 JDBC是连接java应用程序和数据库之间的桥梁。什么是JDBC? Java语言访问数据库的一种规范,是一套API。JDBC (Java Database Connectivity) API，即Java数据库编程接口，是一组标准的Java语言中的接口和类，使用这些接口和类，Java客户端程序可以访问各种不同类型的数据库。比如建立数据库连接、执行SQL语句进行数据的存取操作。
一个小型公司员工的信息系统(控制台版)
轻风起自远东
01-17 3526
在慕课网学习java的时候有一个小型的公司员工信息系统的作业，其要求实现的效果如下： 某公司要开发内部的 “办公信息化管理系统”，请使用面向对象的思想描述以下员工信息。 程序运行参考效果如下： 任务描述 一、语言和环境 实现语言        Java语言 环境要求及开发工具        JDK、Eclipse
IntelliJ IDEA JSP文件不提示内置对象的解决方案
轻风起自远东
02-07 2370
出现这个问题的原因是没有添加Apache Tomcat的lib依赖 解决方法 打开project structure->Libraries 点击加号->找到apche tomcat文件夹下的lib目录，添加进来即可。
Java算法与数据结构
轻风起自远东
03-18 1363
为了提前准备今年的秋招，差不多开始复习算法与数据结构了，以前学算法的时候是以C语言为基础的，现在很久没碰C语言了，决定这次复习用Java实现，基本上是参考的Java算法神书：《数据结构与算法分析——Java语言描述》。 排序 时间复杂度O(n2)的排序 选择排序 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然...
播放器管理系统
轻风起自远东
02-07 1191
详细设计 一、类 1、歌曲类(Song) 属性：歌曲ID，歌曲名称，演唱者 方法：构造方法、getter/setter方法、hashCode()和equals()重写方法、toString重写方法 2、播放列表类(PlayList) 属性：播放列表名称、播放列表中的歌曲集合（List类型） 方法：构造方法、getter/setter方法、public void addToPlayLis
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值