File类和递归

于 2021-08-12 16:03:13 发布
阅读量120 收藏
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cococonger_/article/details/119645390
版权

文章目录

一、File类

1.1、概述

java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。
java把电脑中的文件和文件夹(目录)封装为了一个File类，我们可以使用File类对文件和文件夹进行操作。

我们可以使用File类的方法：

  • 创建一个文件或文件夹
  • 删除文件或文件夹
  • 获取文件或文件夹
  • 判断文件或文件夹是否存在
  • 对文件夹进行遍历
  • 获取文件的大小

File类是一个与系统无关的类，任何的操作系统都可以使用这个类中的方法

重点：File(文件)、directory(文件夹/目录)、path(路径)

1.2、File类的成员变量

  • pathSeparator：路径分隔符，如配置windows环境变量时多个路径之间用;分隔
  • separator：文件名称分隔符，windows用反斜杠\表示
    /*
    java.io.File类
    获取当前系统中对应的分隔符
    案例中的两个分隔符都有字符串和字符两种格式
 */
public class TestFile1 {
    public static void main(String[] args) {
        String pathSeparator = File.pathSeparator;
        System.out.println(pathSeparator);// windows用分号;   linux用冒号:

        String separator = File.separator;
        System.out.println(separator);// windows用反斜杠\   linux用正斜杠/
    }
}

1.3、File类的构造方法

  • 路径
    • 绝对路径：是一个完整的路径，以盘符开始的路径
    • 相对路径：是一个简化的路径
      • 相对指的是相对于当前项目的根目录
      • 当前目录：F:\study-code\file
      • 如果使用当前项目的分目录，路径可以简化书写
      • F:\study-code\file\123.txt 可以简化为 123.txt(可以省略项目的根目录)
  • 注意
    • 路径不区分大小写
    • 路径中的文件名称分隔符windows使用反斜杠\，一个\代表转义字符，\\代表一个普通的\
  1. File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名，来创建新的 File实例
    public class TestFile2 {
    public static void main(String[] args) {
        show01();
    }

    /*
        参数：
            String pathname：字符串的路径名称
            路径可以是文件结尾，也可以是文件夹结尾
            路径可以是相对路径，也可以是绝对路径
     */
    private static void show01() {
        // 文件结尾
        File f1 = new File("F:\\study-code\\file\\a.txt");
        System.out.println(f1);// F:\study-code\file\a.txt
        // 文件夹结尾
        File f2 = new File("F:\\study-code\\file");
        System.out.println(f2);// F:\study-code\file

        // 相对路径
        File f3 = new File("b.txt");
        System.out.println(f3);// b.txt
    }
}
  2. File(String parent, String child)：从父路径名字符串和子路径名字符串创建新的 File实例
    public class TestFile2 {
    public static void main(String[] args) {
        show02("e:\\", "a.txt");
    }

    /*
        参数：把路径分成了两部分
            String parent：父路径
            String child：子路径
        好处：
            父路径和子路径可以单独书写，使用灵活，父路径和子路径都可以变化
     */
    private static void show02(String parent, String child) {
        File f1 = new File(parent, child);
        System.out.println(f1);
    }
}
  3. File(File parent, String child)：从父抽象路径名和子路径名字符串创建新的 File实例
    public class TestFile2 {
    public static void main(String[] args) {
        show03();
    }

    /*
        File(File parent, String child)：从父抽象路径名和子路径名字符串创建新的 File实例。
        参数：把路径分成了两部分
            File parent：父路径
            String child：子路径
        好处：
            父路径和子路径可以单独书写，使用灵活，父路径和子路径都可以变化
            父路径是File类型，可以使用File的方法对路径进行一些操作，再使用路径创建对象
     */
    private static void show03() {
        File parent = new File("c:\\");
        File file = new File(parent, "a.txt");
        System.out.println(file);
    }
}
  • 注意：
    • 路径可以是存在的，也可以是不存在的
    • 创建File对象，只是把字符串路径封装为File对象，不考虑路径的真假情况

1.4、获取功能方法

  1. getAbsolutePath()：返回此File的绝对路径名字符串
    public class TestFile3 {
    public static void main(String[] args) {
        show01();
    }

    /*
        获取构造方法中传递的路径
        无论路径是绝对的还是相对的，返回的都是绝对路径
     */
    private static void show01() {
        File f1 = new File("F:\\study-code\\file\\a.txt");
        String path1 = f1.getAbsolutePath();
        System.out.println(path1); // F:\study-code\file\a.txt

        File f2 = new File("a.txt");
        String path2 = f2.getAbsolutePath();
        System.out.println(path2); // F:\study-code\file\a.txt
    }
}
  2. getPath()：返回此File的路径名字符串
    public class TestFile3 {
    public static void main(String[] args) {
        show02();
    }

    /*
        获取构造方法中传递的路径
        传的是什么路径，就返回什么路径
     */
    private static void show02() {
        File f1 = new File("F:\\study-code\\file\\a.txt");
        String path1 = f1.getPath();
        System.out.println(path1);

        File f2 = new File("a.txt");
        String path2 = f2.getPath();
        System.out.println(path2);
        System.out.println(f2.toString()); // toString调用的就是getPath方法
    }
}
  3. getName()：返回由此File表示的文件或目录的名称
    public class TestFile3 {
    public static void main(String[] args) {
        show03();
    }

    /*
        获取的就是构造方法传递路径的结尾部分(文件/文件夹)
        绝对路径或相对路径都可以
     */
    private static void show03() {
        File f1 = new File("F:\\study-code\\file\\a.txt");
        String path1 = f1.getName();
        System.out.println(path1);

        File f2 = new File("F:\\study-code\\file");
        String path2 = f2.getName();
        System.out.println(path2);
    }
}
  4. length()：返回由此File表示的文件的长度
    public class TestFile3 {
    public static void main(String[] args) {
        show04();
    }

    /*
        获取的是构造方法指向的文件的大小，以字节为单位的
        注意：
            文件夹是没有大小概念的，不能获取文件夹大小
            如果构造方法中给出的路径不存在，返回为0
     */
    private static void show04() {
        File f1 = new File("E:\\money.jpg");
        long l1 = f1.length();
        System.out.println(l1); // 文件大小

        File f2 = new File("E:\\FromWatch");
        System.out.println(f2.length()); // 0
    }
}

1.5、判断功能的方法

  1. exists()：判断此File表示的文件或目录是否实际存在
    public class TestFile4 {
    public static void main(String[] args) {
        show01();
    }

    /**
     * 用于判断构造方法中的路径是否存在
     */
    private static void show01() {
        File f1 = new File("F:\\study-code\\file");
        System.out.println(f1.exists()); // true

        File f2 = new File("F:\\study-code\\file2");
        System.out.println(f2.exists()); // false

        File f3 = new File("file.iml"); // 相对路径
        System.out.println(f3.exists()); // true

        File f4 = new File("file"); // 相对路径
        System.out.println(f4.exists()); // false
    }
}
  2. isDirectory()：用于判断构造方法中给定的路径是否以文件夹结尾
  3. isFile()：用于判断构造方法中给定的路径是否以文件结尾
    public class TestFile4 {
    public static void main(String[] args) {
        show02();
    }

    /**
     *  注意：
     *      电脑的硬盘中只有文件和文件夹，所以两个方法是互斥的
     *      两个方法的使用前提是：路径必须存在，否则都返回false
     */
    private static void show02() {
        File f1 = new File("F:\\study-code\\file2");
        System.out.println(f1.isDirectory()); // false
        System.out.println(f1.isFile()); // false

        File f2 = new File("F:\\study-code\\file");
        System.out.println(f2.isDirectory()); // true
        System.out.println(f2.isFile()); // false

        File f3 = new File("F:\\study-code\\file\\file.iml");
        System.out.println(f3.isDirectory()); // false
        System.out.println(f3.isFile()); // true
    }
}

1.6、创建删除的方法

  1. createNewFile()：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件
    public class TestFile5 {
    public static void main(String[] args) throws IOException {
        show01();
    }

    /**
     *  创建文件的路径和名称在构造方法(构造方法的参数)
     *  返回值是一个布尔值
     *  注意：
     *      此方法只能创建文件，不能创建文件夹
     *      创建文件的路径必须存在，否则会抛出异常
     */
    private static void show01() throws IOException {
        File f1 = new File("F:\\study-code\\file\\1.txt");
        System.out.println(f1.createNewFile()); // true，再次执行会返回false

        File f2 = new File("2.txt");
        System.out.println(f2.createNewFile()); // true，再次执行会返回false

        File f3 = new File("F:\\study-code\\file2\\2.txt");
        System.out.println(f3.createNewFile()); // 路径不存在会抛出IO异常
    }
}
  2. mkdir()：创建单级空文件夹
  3. mkdirs()：既可以创建单级空文件夹，也可以创建多级文件夹
    public class TestFile5 {
    public static void main(String[] args) throws IOException {
        show02();
    }

    /**
     *  创建文件的路径和名称在构造方法(构造方法的参数)
     *  文件夹不存在，创建文件夹返回true
     *  文件夹存在或构造方法中给出的路径不存在，返回false
     *  注意：
     *      此方法只能创建文件夹，不能创建文件
     */
    private static void show02() {
        File f1 = new File("aaa");
        System.out.println(f1.mkdir());

        File f2 = new File("111\\222\\333");
        System.out.println(f2.mkdirs());
    }
}
  4. delete()：删除由此File表示的文件或目录
    public class TestFile5 {
    public static void main(String[] args) throws IOException {
        show03();
    }

    /**
     *  可以删除构造方法路径中给出的文件/文件夹
     *  删除成功返回true
     *  文件夹中有内容或路径不存在，返回false
     *  注意：
     *      delete方法是直接在硬盘删除文件/文件夹，不走回收站
     */
    private static void show03() {
        File f1 = new File("F:\\study-code\\file\\1.txt");
        System.out.println(f1.delete()); // true

        File f2 = new File("aaa");
        System.out.println(f2.delete()); // true
    }
}

1.7、文件夹的遍历

  • list()：返回一个String数组，表示该File目录中的所有子文件或目录。

  • listFiles()：返回一个File数组，表示该File目录中的所有的子文件或目录。

  • 注意：

    • list方法和listFiles方法遍历的是构造方法中给出的目录
    • 如果构造方法中给出的目录的路径不存在，会抛出空指针异常
    • 如果构造方法中给出的路径不是一个目录，也会抛出空指针异常
    • 可以获取到隐藏的文件
    public class TestFile6 {
    public static void main(String[] args) {
        show01();
        show02();
    }

    /**
     * listFiles()：返回一个File数组，表示该File目录中的所有的子文件或目录。
     * 遍历构造方法中给出的目录，会获取目录中所有的文件/文件夹，把文件/文件夹封装为File对象，
     * 多个File对象存储到File数组中
     */
    private static void show02() {
        File file = new File("F:\\study-code\\file");
        File[] list = file.listFiles();
        for (File s : list) {
            System.out.println(s); // 打印出来的是下一级文件夹和文件的目录
        }
    }

    /**
     * list()：返回一个String数组，表示该File目录中的所有子文件或目录。
     * 遍历构造方法中给出的目录，会获取目录所有文件/文件夹的名称，
     * 把获取到的多个名称存储到一个String类型的数组中
     */
    private static void show01() {
        File file = new File("F:\\study-code\\file");
        String[] list = file.list();
        for (String s : list) {
            System.out.println(s); // 打印出来的是下一级文件夹和文件
        }
    }

}

二、递归

2.1、概述

  • 递归：指在当前方法内调用自己的这种现象。
  • 递归的分类:
    • 递归分为两种，直接递归和间接递归。
    • 直接递归称为方法自身调用自己。
    • 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。
  • 注意事项：
    • 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
    • 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
    • 构造方法,禁止递归
  • 递归的使用前提：

    • 当调用方法的时候，方法的主体不变，每次调用方法的参数不同，可以使用递归

      public class TestRecursion1 {
    public static void main(String[] args) {
        a();
    }

    /**
     * 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出
     * a方法会在栈内存中一直调用a方法，就会导致栈内存中会有无数个a方法
     * 方法太多了，超出栈内存的大小，就会导致内存溢出的错误
     */
    private static void a() {
        System.out.println("a方法");
        a();
    }
}
  • 注意
    • 当一个方法调用其他方法时，被调用的方法没有执行完毕，当前方法会一直等待调用的方法执行完毕，才会继续执行
    • 构造方法禁止递归，否则会导致编译报错。因为构造方法是创建对象的，一直递归会导致内存中有无数多个对象，直接编译报错

2.2、递归累加求和

// 使用递归计算1-n之间的和
public class TestRecursion2 {
    public static void main(String[] args) {
        System.out.println(sum(3));
    }


    /**
     * 定义一二个方法，使用递归计算1-n之间的和
     * 已知：
     *      最大值
     *      最小值
     *  使用递归必须明确：
     *      递归的结束条件
     *      递归的目的
     */
    public static int sum(int n) {
        // 获取到1的时候结束
        if (n == 1) {
            return 1;
        }
        return n + sum(n-1);
    }
}
  • 注意
    • 使用递归求和，main方法调用sum方法，sum方法会一直调用sun方法，导致在内存中有多个sum方法
    • 频繁的创建方法，调用方法，销毁方法，导致效率低下

2.3、递归求阶乘

// 使用递归计算阶乘
public class TestRecursion3 {
    public static void main(String[] args) {
        int jc = jc(5);
        System.out.println(jc);
    }

    // 定义方法：使用递归计算阶乘
    public static int jc (int n) {
        if (n == 1) {
            return 1;
        }
        return n * jc(n-1);
    }
}

2.4、递归打印多级目录

// 递归打印多级目录
public class TestRecursion4 {
    public static void main(String[] args) {
        File file = new File("F:\\study-code\\file");
        getAllFile(file);
    }

    // 定义一个方法，参数传递File类型的目录，方法中对这个目录进行遍历
    public static void getAllFile(File dir) {
        System.out.println(dir);// 被遍历的目录名称
        File[] files = dir.listFiles();
        for (File file : files) {
            // 判断是否是文件夹
            if (file.isDirectory()) {
                getAllFile(file);
            }else {
                System.out.println(file);
            }
        }
    }
}

三、综合案例

3.1、文件搜索

搜索项目中的.java文件

// 只要.java结尾的文件
public class TestRecursion5 {
    public static void main(String[] args) {
        File file = new File("F:\\study-code\\file");
        getAllFile(file);
    }

    // 定义一个方法，参数传递File类型的目录，方法中对这个目录进行遍历
    public static void getAllFile(File dir) {
        File[] files = dir.listFiles();
        for (File file : files) {
            // 判断是否是文件夹
            if (file.isDirectory()) {
                getAllFile(file);
            }else {
                String name = file.getName();
                if (name.endsWith(".java")) {
                    System.out.println(file);
                }
            }
        }
    }
}

3.2、文件过滤器

调用File[] listFiles(FileFilter filter)的重载方法

java.io.FileFilter接口：用于抽象路径名(File对象)的过滤器。就是用来过滤文件的。

  • 抽象方法：
    • boolean accept(File pathname) ：测试pathname是否应该包含在当前File目录中
    • 参数
      • pathname：使用listFiles方法遍历目录，得到的每一个文件对象

java.io.FilenameFilter接口：文件名称过滤器，用于过滤文件名称

抽象方法：

  • boolean accept(File dir, String name) ：测试指定文件是否应该包含在某一文件列表中
  • 参数
    • dir：构造方法中被遍历的目录
    • name：使用listFiles方法遍历目录，得到的每一个文件对象

过滤器原理：

File[] listFiles(FileFilter filter)方法：

  1. listFiles方法会对构造方法中传递的目录进行遍历，获取目录中的每一个文件/文件夹，并封装为File对象
  2. listFiles方法会调用参数传递的过滤器中的方法accept
  3. listFiles方法会把遍历得到的每一个File对象传递给accept方法的参数pathname
  4. accept方法的返回值是一个boolean，如果返回的是true，就会把传递过去的File对象保存到数组中，false则不会

所以在accept方法中判断即可

代码实现：

// 只要.java结尾的文件，使用过滤器来实现需求
public class TestFilter1 {
    public static void main(String[] args) {
        File file = new File("F:\\study-code\\file");
        getAllFile(file);
    }

    // 定义一个方法，参数传递File类型的目录，方法中对这个目录进行遍历
    public static void getAllFile(File dir) {
        File[] files = dir.listFiles(new FileFilterImpl()); // 传递过滤器对象
        for (File file : files) {
            // 判断是否是文件夹
            if (file.isDirectory()) {
                getAllFile(file);
            }else {
                System.out.println(file);
            }
        }
    }
}

// 创建过滤器FileFilter的实现类，重写accept方法
public class FileFilterImpl implements FileFilter {
    public boolean accept(File pathname) {
        // 定义过滤的规则，需要把文件夹放过去
        return pathname.isDirectory() || pathname.toString().endsWith(".java");
    }
}

3.3、使用FilenameFilter优化

public class DiGuiDemo4 {
    public static void main(String[] args) {
        File dir = new File("D:\\aaa");
        printDir2(dir);
    }
  
    public static void printDir2(File dir) {
      	// 匿名内部类方式,创建过滤器子类对象
        File[] files = dir.listFiles((dir, name) -> new File(dir, name).isDirectory() || name.endsWith(".java");
        );
      	// 循环打印
        for (File file : files) {
            if (file.isFile()) {
                System.out.println("文件名:" + file.getAbsolutePath());
            } else {
                printDir2(file);
            }
        }
    }
}
Clam.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Test File递归删除.java
10-14
File类操作递归删除 大型文件秒删 无法找回 千万不要删系统盘
Java基础——File类、递归、文件过滤器
波波鱼的博客
06-07 173
1.File类 java.io.File类 java把电脑中的文件和文件夹封装为了一个File类，我们可以使用File类对文件和文件夹进行操作 创建一个文件/文件夹 删除一个文件/文件夹 获取创建一个文件/文件夹 判断文件/文件夹是否存在 对文件夹进行遍历 获取文件的大小 File类是一个与操作系统无关的类，任何的操作系统都可以使用这个类中的方法 重点记住以下三个单词： fil...
Java的File类实现文件目录递归及统计相关数据
OrangeHap
01-14 392
@Test public void fileProcessor() { File file = new File("D://Snipaste-2.2.4-Beta-x64"); HashMap<String, Object> data = new HashMap<>(); data.put("fileSize", B...
使用过滤器递归打印多级目录
Beauty_Yao的博客
10-17 192
1、题目： 递归打印多级目录 要求： 只能打印出以.xml结尾的文件 2、递归分析： 递归：方法自己调用自己 递归分为直接递归和间接递归； 直接递归称为方法自身调用自己 间接递归可以A调用B，B调用A， 注意事项： 1、递归一定要有条件限定，保证递归能停止下来，否则发生栈内存溢出 2、在递归中虽然有限定条件，但是递归次数不能太多，否则也会发生栈内存溢出 3、构造方法，禁止递归 使用前提：...
FIle类和递归方法的使用
黑某人
03-14 198
File类 概述：文件和目录【文件夹和盘符】路径名的抽象表示形式；文件和目录在内存中的另外一种表现形式 路径：文件或目录在磁盘中的位置的地址 绝对路径： 概述：从根目录开始一直到文件本省的位置的地址 根路径： windows系统：根路径就是盘符路径 mac、linux系统：根路径就是【/】 相对路径： 概述：相对于某个路径而言的路径【有一个参考的路径】 在eclipse当中相对路径相对于工程路径 ...
Java练习>递归>>打印多级目录
越努力，越幸福！
08-11 405
案例： package DiGui; import java.io.File; /* 递归打印多级目录 需求： G:\Demo02 G:\Demo02\.idea G:\Demo02\.idea\misc.xml G:\Demo02\.idea\modules.xml G:\Demo02\.i...
19.【File类、递归】_递归_
10-02
非常好用且全面的java map区块学习，里面有源码
day08【File类、递归】-笔记1
08-04
第一章 File类1.1 概述java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。1.2 构造方法public
Java基础知识-day08【File类、递归】.pdf
10-26
java学习课件，供参考学习使用
day19_阻塞队列、线程池、File类、递归.pdf
11-02
day19_阻塞队列、线程池、File类、递归.pdf
方法引用, Stream流，File类 , 递归 ，字节流.md
08-25
关于一些java的流处理
php实现递归抓取网页类实例
01-20
本文实例讲述了php实现递归抓取网页类的方法。分享给大家供大家参考。具体如下： <?php class crawler{ private $_depth=5; private $_urls=array(); function extract_links($url) { if(!$this->_started)...
day09-方法引用, Stream流，File类 , 递归 ，字节流.md
04-07
day09-方法引用, Stream流，File类 , 递归 ，字节流.md
SEARCHFILE:使用递归和过滤选项搜索给定文件夹下的文件和目录-matlab开发
06-01
% SEARCHFILE 在给定文件夹下搜索文件和/或目录％ 句法% list = searchfile('dir', 'filter', 'recflag') % % 'dir'（可选）- % 要搜索的源目录。 如果没有指定， % 当前工作目录将被使用% % '过滤器'（可...
PHP实现递归复制整个文件夹的类实例
01-20
本文实例讲述了PHP实现递归复制整个文件夹的类。分享给大家供大家参考。具体如下： <?php /* * 文件夹复制类 */ class CopyFile { public $fromFile; public $toFile; /* * $fromFile 要复制谁 * $toFile ...
复习File类和递归方法使用
m0_48811221的博客
08-03 84
File类 /* java.io.File类: 文件和目录路径名的抽象表示形式。 File类封装了计算机中的文件和文件夹,我们可以通过File类中的方法操作计算机中的文件和文件夹 可以使用FIle类中的方法创建文件|文件夹 可以使用FIle类中的方法删除文件|文件夹 可以使用FIle类中的方法获取文件|文件夹的路径 可以使用FIle类中的方法遍历文件夹
java file.length 单位_java 获取文件夹大小，文件大小(返回大小单位)，文件个数
weixin_39724793的博客
02-13 2390
import java.io.File;import java.text.DecimalFormat;import java.io.FileInputStream;public class GetFileSize{public long getFileSizes(File f) throws Exception{//取得文件大小long s=0;if (f.exists()) {FileInput...
java - 删除文件
我的世界里头，谁懂我！
12-30 242
java删除文件 package IO.file; import java.io.File; /** * 删除文件和目录 * @author chen * */ public class DeleteFileUtil { /** * 删除文件，可以是文件或文件夹 * @param fileName 要删除的文件名 * @return 删除成功返回true，否则返...
Java的文件类File和递归（笔试的常见题）
与其在害怕丢脸,不如在旅途中尽情地丢脸
12-08 2391
File类(递归) 5的阶乘 递归调用的弊端：不能调用的次数过多（7000次左右），容易导致栈内存溢出 递归调用的好处：不用知道循环的次数 构造方法是不可使用递归的。 递归不一定需要返回值（类似文件夹查找不需要返回值） File类(练习) 需求:从键盘输入接收一个文件夹路径,打印出该文件夹下所有的.java文件名 分析: 从键盘接收一个文件夹路径 1,如果录入的是不存在,给与提示 2,如果录入的
java file类删除文件夹
最新发布
11-22
2. 然后可以使用Files类的静态方法delete(Path path)来删除文件夹，但是该方法只能删除空文件夹，如果要删除非空文件夹，需要先递归删除文件夹中的所有文件和子文件夹，然后再删除该文件夹，例如： ```java public ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值