java File相关操作

本文通过大量的示例,介绍和讲解了Java File操作。

1)创建文件  2)删除文件  3)判断文件是否存在  4)创建文件夹  5)文件类型判断  6)获取文件信息

7)获取目录下文件名  8)递归打印所有文件名  9)递归删除整个文件夹  10)Properties类

11)SequenceInputStream类:连接多个流  12)对象序列化实现Serializable接口  13)管道流

14)RandomAccessFile类   15)DataStream类  16)ByteArrayStream类


1、创建文件

1)boolean java.io.File.createNewFile() throws IOException用来创建文件,如果文件存在,创建失败,返回false;

2)new File("a.txt");并不创建文件实体,只是创建一个指向“a.txt”的引用。

3)路径分隔符:File.separator

[java]  view plain  copy
  1. package file.dol.sn;  
  2.   
  3. import java.io.File;  
  4.   
  5. public class FileDemo {  
  6.   
  7.     public static void main(String[] args) {  
  8.         //new File()就相当于是C语言中定义一个指向“a.txt”的文件指针  
  9.         File f1 = new File("a.txt");  
  10.         try   
  11.         {  
  12.             //创建文件:boolean java.io.File.createNewFile() throws IOException  
  13.             boolean b = f1.createNewFile();  
  14.             //第二次将会创建失败false,这里和流不一样  
  15.             System.out.println(b);  
  16.         }   
  17.         catch (Exception e)   
  18.         {  
  19.             // TODO: handle exception  
  20.         }  
  21.         //目录分隔符:File.separator,相当于“\\”跨平台。  
  22.         //File f2 = new File("E:\\tmp","b.txt");  
  23.         File f2 = new File("E:"+File.separator+"tmp","b.txt");  
  24.         System.out.println(f2);  
  25.     }  
  26. }  
2、删除文件

1)delete():删除文件成功返回true,删除失败返回false( boolean java.io.File.delete()  )

2)deleteOnExit():程序退出时,自动删除文件。一般用于对程序创建的临时文件进行操作,退出时删除。( void java.io.File.deleteOnExit()  )

[java]  view plain  copy
  1. package file.dol.sn;  
  2.   
  3. import java.io.File;  
  4.   
  5. public class FileDemo {  
  6.   
  7.     public static void main(String[] args) {  
  8.   
  9.         File f1 = new File("a.txt");  
  10.         try   
  11.         {  
  12.             boolean b = f1.createNewFile();  
  13.             //删除文件:boolean java.io.File.delete()  
  14.             f1.delete();  
  15.             //程序退出时,自动删除:void java.io.File.deleteOnExit()  
  16.             //f1.deleteOnExit();  
  17.         }   
  18.         catch (Exception e)   
  19.         {  
  20.             // TODO: handle exception  
  21.         }  
  22.     }  
  23. }  
3、判断文件是否存在

exists():判断文件是否存在( boolean java.io.File.exists() )

[java]  view plain  copy
  1. package file.dol.sn;  
  2.   
  3. import java.io.File;  
  4.   
  5. public class FileDemo {  
  6.   
  7.     public static void main(String[] args) {  
  8.   
  9.         File f1 = new File("not.txt");  
  10.         //判断文件是否存在:boolean java.io.File.exists()  
  11.         boolean b = f1.exists();  
  12.         System.out.println(b);  
  13.     }  
  14. }  
4、创建文件夹

1)mkdir():只能创建“一级目录”(boolean java.io.File.mkdir());

2)mkdirs():可以创建多级目录(boolean java.io.File.mkdirs())。

[java]  view plain  copy
  1. package file.dol.sn;  
  2.   
  3. import java.io.File;  
  4.   
  5. public class FileDemo {  
  6.   
  7.     public static void main(String[] args) {  
  8.   
  9.         File dir1 = new File("abc");  
  10.         File dir2 = new File("a\\b\\c\\d");  
  11.         try   
  12.         {  
  13.             //创建文件目录(即文件夹):boolean java.io.File.mkdir()  
  14.             //该方法只能创建“一级”目录  
  15.             boolean b =  dir1.mkdir();  
  16.             System.out.println(b);  
  17.             //创建多级文件夹:boolean java.io.File.mkdirs()  
  18.             b =  dir2.mkdirs();  
  19.             System.out.println(b);  
  20.         }   
  21.         catch (Exception e)   
  22.         {  
  23.             System.out.println(e.toString());  
  24.         }  
  25.     }  
  26. }  
5、文件类型判断

1)exists():判断文件是否存在,注意:一定要先判断这个;

2)isDirectory():判断是否为文件夹;

3)isFile():判断是否为文件;

4)isHidden():判断是否为隐藏文件;

5)isAbsolute():判断是否为绝对路径,这里不管文件是否存在都能判断。

[java]  view plain  copy
  1. package file.dol.sn;  
  2.   
  3. import java.io.File;  
  4.   
  5. public class FileDemo {  
  6.   
  7.     public static void main(String[] args) {  
  8.   
  9.         File f = new File("C:\\abc.txt");  
  10.         try   
  11.         {  
  12.             //判断文件是否存在  
  13.             if (f.exists())  
  14.             {  
  15.                 //判断文件是否是文件夹  
  16.                 if (f.isDirectory())  
  17.                 {  
  18.                     System.out.println("文件夹");  
  19.                 }  
  20.                 //判断文件是否是文件  
  21.                 if (f.isFile())  
  22.                 {  
  23.                     System.out.println("文件");  
  24.                 }  
  25.                 //判断是否为隐藏文件  
  26.                 if (f.isHidden())  
  27.                 {  
  28.                     System.out.println("隐藏文件");  
  29.                 }  
  30.             }  
  31.             else   
  32.             {  
  33.                 System.out.println("文件不存在");  
  34.             }  
  35.             //判断是否为绝对路径,不管文件是否存在  
  36.             if (f.isAbsolute())  
  37.             {  
  38.                 System.out.println("是绝对路径");  
  39.             }  
  40.         }   
  41.         catch (Exception e)   
  42.         {  
  43.             System.out.println(e.toString());  
  44.         }  
  45.     }  
  46. }  

6、获取文件信息

1)getName():获取文件名;

2)getParent():获取文件父目录;

3)getPath():获取文件路径;

4)getAbsolutePath():获取文件绝对路径;

5)lastModified():获得文件最后一次被修改的时间;

6)length():获取文件大小;

7)renameTo():文件剪切,将文件f1剪切然后粘贴到f2(相当于右键f1->剪切->粘贴->f2所在目录)

[java]  view plain  copy
  1. package file.dol.sn;  
  2.   
  3. import java.io.File;  
  4.   
  5. public class FileDemo {  
  6.   
  7.     public static void main(String[] args) {  
  8.   
  9.         File f1 = new File("abc.txt");  
  10.         File f2 = new File("E:\\Java\\test.txt");  
  11.         try   
  12.         {  
  13.             //获得文件名  
  14.             System.out.println(f1.getName());  
  15.             //获得绝对路径中的父目录,如:File("abc.txt")则该返回为null  
  16.             System.out.println(f1.getParent());  
  17.             //获得相对路径  
  18.             System.out.println(f1.getPath());  
  19.             //获得绝对路径  
  20.             System.out.println(f1.getAbsolutePath());  
  21.             //获得文件最后一次被修改的时间  
  22.             System.out.println(f1.lastModified());  
  23.             //获得文件大小  
  24.             System.out.println(f1.length());  
  25.             //文件剪切,将文件f1剪切然后粘贴到f2(相当于右键f1->剪切->粘贴->f2所在目录)  
  26.             f1.renameTo(f2);  
  27.         }   
  28.         catch (Exception e)   
  29.         {  
  30.             System.out.println(e.toString());  
  31.         }  
  32.     }  
  33. }  
7、获取目录下文件名

1)listRoots():获取系统盘符;

2)list():获取“X:\\”目录下的所有文件名,包括隐藏文件和文件夹(调用list()方法时,必须先封装一个目录,且必须存在的目录。)

3)list(FilenameFilter filter):列出文件名的时候,可以进行过滤操作(如:列出后缀名为.txt的文件)。

4)listFiles():列出目录下文件名,不包括文件夹。

[java]  view plain  copy
  1. package file.dol.sn;  
  2.   
  3. import java.io.File;  
  4. import java.io.FilenameFilter;  
  5.   
  6. public class FileDemo {  
  7.   
  8.     public static void main(String[] args) {  
  9.         //1.获得系统有效盘符  
  10.         File[] files = File.listRoots();  
  11.         for (File f : files)  
  12.             System.out.println(f.toString());  
  13.         System.out.println("——————————————————————");  
  14.         //2.获得C:\\目录下的所有文件名,包括隐藏文件和文件夹  
  15.         //调用list()方法时,必须先封装一个目录,且必须存在的目录。  
  16.         File fnFile = new File("C:\\");  
  17.         String[] strings = fnFile.list();  
  18.         for (String s : strings)  
  19.             System.out.println(s);  
  20.         System.out.println("——————————————————————");  
  21.         //3.调用list()方法,列出后缀名为.txt的文件  
  22.         strings = fnFile.list(new FilenameFilter() {  
  23.               
  24.             @Override  
  25.             public boolean accept(File dir, String name) {  
  26.                 //找出后缀名为.txt的文件名  
  27.                 return name.endsWith(".txt");  
  28.             }  
  29.         });  
  30.         for (String s : strings)  
  31.             System.out.println(s);  
  32.         System.out.println("——————————————————————");  
  33.         //4.获取C:\\目录下的文件夹,不包括文件夹  
  34.         files = fnFile.listFiles();  
  35.         for (File f : files)  
  36.             System.out.println(f.toString());  
  37.     }  
  38. }  
8、递归打印所有文件名

注意:测试中,有些隐藏文件名不能访问还是其他的原因,当在打印根目录(如:"C:\\")下的所有文件名时,会有个叫“System Volume Information”的隐藏文件夹,访问失败,所以以下代码中,不访问隐藏文件。

[java]  view plain  copy
  1. package file.dol.sn;  
  2.   
  3. import java.io.File;  
  4.   
  5. public class FileDemo {  
  6.   
  7.     public static void main(String[] args) {  
  8.   
  9.         File dirFile = new File("E:\\Dol");  
  10.         showDir(dirFile,0);  
  11.     }  
  12.     public static void showDir(File dir,int level)  
  13.     {  
  14.         System.out.println(printSpace(level)+"文件夹:"+dir.getName());  
  15.         level += 4;  
  16.         File[] file = dir.listFiles();  
  17.         for (File f : file)  
  18.         {  
  19.             //递归进入所有非隐藏文件夹  
  20.             if (f.isDirectory() && !f.isHidden())  
  21.                 showDir(f,level);  
  22.             //打印文件名  
  23.             else  
  24.                 System.out.println(printSpace(level)+f.getName());  
  25.         }  
  26.     }  
  27.     //实现分层次打印,补充空格  
  28.     public static StringBuffer printSpace(int level)  
  29.     {  
  30.         StringBuffer space = new StringBuffer();  
  31.         for (int i = 0; i < level; ++i)  
  32.         {  
  33.             space.append("  ");  
  34.         }  
  35.         return space;  
  36.     }  
  37. }  

9、递归删除整个文件夹

[java]  view plain  copy
  1. package file.dol.sn;  
  2.   
  3. import java.io.File;  
  4.   
  5. public class FileDemo {  
  6.   
  7.     public static void main(String[] args) {  
  8.   
  9.         File dirFile = new File("E:\\Dol");  
  10.         deleteDir(dirFile,0);  
  11.     }  
  12.     public static void deleteDir(File dir,int level)  
  13.     {  
  14.         File[] file = dir.listFiles();  
  15.         //循环递归删除文件夹里面的所有内容  
  16.         for (File f : file)  
  17.         {  
  18.             //递归进入所有非隐藏文件夹  
  19.             if (f.isDirectory() && !f.isHidden())  
  20.                 deleteDir(f,level);  
  21.             //删除文件  
  22.             else  
  23.             {  
  24.                 f.delete();  
  25.                 System.out.println(f.getName()+"——已删除");  
  26.             }  
  27.         }  
  28.         //删除该文件夹  
  29.         dir.delete();  
  30.         System.out.println(dir.getName()+"——已删除");  
  31.     }  
  32. }  

10、Properties类

1)常用的基本操作,设置键值,获取值。

[java]  view plain  copy
  1. package file.dol.sn;  
  2.   
  3. import java.util.Properties;  
  4. import java.util.Set;  
  5.   
  6. public class FileDemo {  
  7.   
  8.     public static void main(String[] args) {  
  9.         //Properties是HashTable的子类,里面存放的都是键值对的字符串  
  10.         Properties prop = new Properties();  
  11.         //设置键值  
  12.         prop.setProperty("Dolphin""海豚");  
  13.         prop.setProperty("Dol""CSDN");  
  14.         //获取  
  15.         String value = prop.getProperty("Dolphin");  
  16.         System.out.println("@@@@value@@@@"+value);  
  17.           
  18.         //返回一个集合  
  19.         Set<String> nameSet = prop.stringPropertyNames();  
  20.         for (String s : nameSet)  
  21.         {  
  22.             System.out.println(s+":"+prop.getProperty(s));  
  23.         }  
  24.     }  
  25. }  
2)读取配置文件

读取配置文件,并对配置文件进行修改,修改后再保存。

[java]  view plain  copy
  1. package file.dol.sn;  
  2.   
  3. import java.io.FileInputStream;  
  4. import java.io.FileOutputStream;  
  5. import java.io.IOException;  
  6. import java.util.Properties;  
  7.   
  8. public class FileDemo {  
  9.   
  10.     public static void main(String[] args) throws IOException{  
  11.   
  12.         Properties prop = new Properties();  
  13.         //Properties加载的文件必须为键值对,#注释的不会被加载  
  14.         FileInputStream fis = new FileInputStream("pz.txt");  
  15.         prop.load(fis);  
  16.         //添加一个键值对  
  17.         prop.setProperty("Dol""123");  
  18.         //对键值对进行修改  
  19.         prop.setProperty("Dol""321");  
  20.         FileOutputStream fos = new FileOutputStream("pz.txt");  
  21.         //保存配置文件  
  22.         //void java.util.Properties.store(OutputStream arg0, String arg1) throws IOException  
  23.         //第二个参数为注释,可写可不写,写入时会自动添加#  
  24.         prop.store(fos, "comment");  
  25.           
  26.         prop.list(System.out);  
  27.         fis.close();  
  28.         fos.close();  
  29.     }  
  30. }  

11、SequenceInputStream类:连接多个流

说明:Enumeration(列举)
public interface Enumeration<E>实现 Enumeration 接口的对象,它生成一系列元素,一次生成一个。连续调用 nextElement 方法将返回一系列的连续元素。
例如,要输出 Vector<E> v 的所有元素,可使用以下方法:
for (Enumeration<E> e = v.elements(); e.hasMoreElements();)
System.out.println(e.nextElement());
这些方法主要通过向量的元素、哈希表的键以及哈希表中的值进行枚举。枚举也用于将输入流指定到 SequenceInputStream 中。
注:此接口的功能与 Iterator 接口的功能是重复的。此外,Iterator 接口添加了一个可选的移除操作,并使用较短的方法名。新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。
有两个方法:
hasMoreElements() 测试此枚举是否包含更多的元素。
nextElement() 如果此枚举对象至少还有一个可提供的元素,则返回此枚举的下一个元素。

[java]  view plain  copy
  1. package file.dol.sn;  
  2.   
  3. import java.io.FileInputStream;  
  4. import java.io.FileOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.SequenceInputStream;  
  7. import java.util.Enumeration;  
  8. import java.util.Vector;  
  9.   
  10. public class FileDemo {  
  11.   
  12.     public static void main(String[] args) throws IOException {  
  13.   
  14.         //将多个流加入集合  
  15.         Vector<FileInputStream> vector = new Vector<FileInputStream>();  
  16.         vector.add(new FileInputStream("E:\\1.txt"));  
  17.         vector.add(new FileInputStream("E:\\2.txt"));  
  18.         vector.add(new FileInputStream("E:\\3.txt"));  
  19.   
  20.         //java.util.Enumeration<FileInputStream>用法见说明  
  21.         Enumeration<FileInputStream> en = vector.elements();  
  22.         //连接多个流  
  23.         SequenceInputStream sis = new SequenceInputStream(en);  
  24.         //启动输出流  
  25.         FileOutputStream fos = new FileOutputStream("E:\\4.txt");  
  26.         //开始文件拷贝  
  27.         byte[] buf = new byte[1024];  
  28.         int len = 0;  
  29.         while ((len=sis.read(buf))!=-1)  
  30.             fos.write(buf,0,len);  
  31.         //关闭资源  
  32.         fos.close();  
  33.         sis.close();  
  34.     }  
  35. }  

12、对象序列化实现Serializable接口

1)添加序列号;

2)静态成员变量不可序列化;

3)堆内存变量要想不被序列化,可以加transient关键字。

[java]  view plain  copy
  1. package file.dol.sn;  
  2.   
  3. import java.io.FileInputStream;  
  4. import java.io.FileOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.ObjectInputStream;  
  7. import java.io.ObjectOutputStream;  
  8. import java.io.Serializable;  
  9.   
  10. //序列化,必须实现Serializable接口,该接口不需要覆盖方法  
  11. class Person implements Serializable  
  12. {  
  13.     //记得添加序列化号  
  14.     public static final long serialVersionUID = 42L;  
  15.   
  16.     //堆内存变量可序列化  
  17.     private String name;  
  18.     private int age;  
  19.     //如果不想将堆内存里面的变量序列化,如下声明就可以了  
  20.     //transient int age;  
  21.     //注意,静态成员变量不可序列化  
  22.     private static String sex = "male";  
  23.     public Person(String n, int a, String s)  
  24.     {  
  25.         name = n;  
  26.         age = a;  
  27.         sex = s;  
  28.     }  
  29.     //覆盖toString()方便println()打印  
  30.     public String toString()  
  31.     {  
  32.         return name+":"+age+":"+sex;  
  33.     }  
  34. }  
  35. public class FileDemo {  
  36.   
  37.     public static void WriteOut() throws IOException  
  38.     {  
  39.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));  
  40.         oos.writeObject(new Person("Dolphin"20,"female"));  
  41.         oos.close();  
  42.     }  
  43.     public static void ReadIn() throws Exception  
  44.     {  
  45.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));  
  46.         Person p = (Person)ois.readObject();  
  47.         ois.close();  
  48.         System.out.println(p);  
  49.     }  
  50.     //这里直接抛出一个较大的异常Exception(IOException的基类)  
  51.     public static void main(String[] args) throws Exception {  
  52.         //注意:以下函数需要分两次运行,每次只运行一个,方便观察运行效果  
  53.         //WriteOut();  
  54.         ReadIn();  
  55.     }  
  56. }  

13、管道流

1)平时两个流读写都是通过内存变量,进行数据操作的;

2)这里引入管道流,开启两个线程,一个读取流,一个写入流,直接将两个流对接上。

[java]  view plain  copy
  1. package io.dol.sn;  
  2.   
  3. import java.io.PipedInputStream;  
  4. import java.io.PipedOutputStream;  
  5. //实现Runnable方法,多线程  
  6. class Read implements Runnable  
  7. {  
  8.     private PipedInputStream in;  
  9.     public Read(PipedInputStream in)   
  10.     {  
  11.         this.in = in;  
  12.     }  
  13.     public void run()   
  14.     {  
  15.         try {  
  16.             byte[] buf = new byte[1024];  
  17.             int len = 0;  
  18.             //如果流中无数据,read()进入等待状态  
  19.             while ((len=in.read(buf))!=-1)  
  20.             {  
  21.                 System.out.println(buf);  
  22.             }  
  23.             in.close();  
  24.         } catch (Exception e) {  
  25.             throw new RuntimeException("管道流读取失败");  
  26.         }  
  27.     }  
  28. }  
  29.   
  30. class Write implements Runnable  
  31. {  
  32.     private PipedOutputStream out;  
  33.     public Write(PipedOutputStream in)   
  34.     {  
  35.         this.out = out;  
  36.     }  
  37.     public void run()   
  38.     {  
  39.         try {  
  40.             out.write("Piped lai la...".getBytes());  
  41.             out.close();  
  42.         } catch (Exception e) {  
  43.             throw new RuntimeException("管道流输出失败");  
  44.         }     
  45.     }  
  46. }  
  47.   
  48. public class PipedStreamDemo {  
  49.   
  50.     public static void main(String[] args) {  
  51.           
  52.         PipedInputStream in = new PipedInputStream();  
  53.         PipedOutputStream out = new PipedOutputStream();  
  54.           
  55.         Read r = new Read(in);  
  56.         Write w = new Write(out);  
  57.         //开启两线程  
  58.         new Thread(r).start();  
  59.         new Thread(w).start();  
  60.     }  
  61. }  

14、RandomAccessFile类

[java]  view plain  copy
  1. package io.dol.sn;  
  2.   
  3. import java.io.IOException;  
  4. import java.io.RandomAccessFile;  
  5.   
  6. public class RafDemo {  
  7.   
  8.     public static void Read() throws IOException  
  9.     {  
  10.         RandomAccessFile raf = new RandomAccessFile("raf.txt""rw");  
  11.         byte[] buf= new byte[4];  
  12.         raf.read(buf);  
  13.         String name = new String(buf);  
  14.         int age;  
  15.         age = raf.readInt();  
  16.           
  17.         raf.close();  
  18.           
  19.         System.out.println("网名:"+name);  
  20.         System.out.println("年龄:"+age);  
  21.     }  
  22.     public static void Write() throws IOException  
  23.     {  
  24.         RandomAccessFile raf = new RandomAccessFile("raf.txt""rw");  
  25.         raf.write("海豚".getBytes());  
  26.         raf.writeInt(20);  
  27.         raf.close();  
  28.     }  
  29.     public static void main(String[] args) throws IOException {  
  30.           
  31.         Write();  
  32.         Read();  
  33.         //调整指针位置  
  34.         //raf.seek(pos);  
  35.         //跳过字节数  
  36.         //raf.skipBytes(n);  
  37.     }  
  38. }  

15、DataStream类

[java]  view plain  copy
  1. package io.dol.sn;  
  2.   
  3. import java.io.DataInputStream;  
  4. import java.io.DataOutputStream;  
  5. import java.io.FileInputStream;  
  6. import java.io.FileOutputStream;  
  7. import java.io.IOException;  
  8.   
  9. public class DataStreamDemo {  
  10.   
  11.     public static void main(String[] args) throws IOException {  
  12.         //写数据  
  13.         DataOutputStream out = new DataOutputStream(new FileOutputStream("data.txt"));  
  14.           
  15.         out.writeInt(123);  
  16.         out.writeDouble(56.88);  
  17.         out.writeBoolean(true);  
  18.         out.close();  
  19.         //读数据  
  20.         DataInputStream in = new DataInputStream(new FileInputStream("data.txt"));  
  21.         int nInt = in.readInt();  
  22.         double nDou = in.readDouble();  
  23.         boolean b = in.readBoolean();  
  24.         in.close();  
  25.         //显示  
  26.         System.out.println("nInt:"+nInt);  
  27.         System.out.println("nDou:"+nDou);  
  28.         System.out.println("b:"+b);  
  29.     }  
  30. }  

16、ByteArrayStream类

[java]  view plain  copy
  1. package io.dol.sn;  
  2.   
  3. import java.io.ByteArrayInputStream;  
  4. import java.io.ByteArrayOutputStream;  
  5.   
  6. import javax.print.attribute.standard.Sides;  
  7.   
  8. public class ByteArrayStreamDemo {  
  9.   
  10.     public static void main(String[] args) {  
  11.   
  12.         ByteArrayInputStream in = new ByteArrayInputStream("Dolphin".getBytes());  
  13.         ByteArrayOutputStream out = new ByteArrayOutputStream();  
  14.           
  15.         int len = 0;  
  16.         // int java.io.ByteArrayInputStream.read() 从此输入流中读取下一个数据字节  
  17.         while ((len=in.read())!=-1)  
  18.         {  
  19.             out.write(len);  
  20.         }  
  21.         System.out.println(out.size());  
  22.     }  
  23. }  

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值