Java学习41-Java 流(Stream)、文件(File)和IO

Dear_喜阳阳

于 2024-04-04 18:07:24 发布

阅读量809

点赞数 6

文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/weixin_42892630/article/details/137379238

版权

文件(File)

File类的理解

File类位于java.io包下，本章涉及到的相关流也都声明在java.io包下。
File类的一个对象，对应于操作系统下的一个文件或者directory
File类中声明了新建，删除，获取名称，重命名等方法，并没有涉及到文件内容的读写操作。想实现文件内容的读写，我们需要使用io流。
File类的对象，通常是作为io流操作的文件的端点出现的。

内部api使用说明
2.1 构造器

public FIle(String pathname):以pathname为路径创建FIle对象，可以是绝对路径或者相对路径，如果pathname。
public FIle(String parent, String child) :以parent为父路径，child为子路径，创建File对象。
public File(File parent, String child):根据一个父File对象和子文件路径创建FIle对象。

2.2 方法

概念

绝对路径：以windows操作系统为例，包括盘符在内的文件或者文件目录的完整路经。

相对路径：相对于某一个文件目录来讲的相对位置。在IDEA中，如果使用单元测试方法@Test，那就是相对于当前的module来讲，在同一个路径；
如果使用main()方法，那就是相对于当前的project来讲，在同一个路径；

代码举例：

package File;

import org.junit.Test;

import java.io.File;

public class CreateFile {
    /*
    public File(String pathname): pathname为路径创建File对象
    public File(String parent,String child): parent为父路径, child为在子路径创建File对象
    public File(File parent,String child): 根据父File和子文件路径创建File对象
    文件的路径表示方式：
    方式1：绝对路径；以windows为例。包括盘符在内的文件或文件目录的完整路径
    方式2：相对路径 相对于某一个文件目录来讲的相对位置
     // 在IDEA中，如果使用单元测试方法@Test，那就是相对于当前的module来讲，在同一个路径
    // 在IDEA中，如果使用main()方法，那就是相对于当前的project来讲，在同一个路径


    */


    // 如果没有后缀名字，比如File f2 = new File("test02042024dir")这是个dicectory，
    // 也没有写路径，这就是相对路径，是相对于一个文件目录来讲的相对位置。
    // 什么相对路径呢？
    // 在IDEA中，如果使用单元测试方法@Test，那就是相对于当前的module来讲，同一路径
    // 在IDEA中，如果使用main()方法，那就是相对于当前的project来讲，同一路径

@Test
    public void test1(){
    //public File(String pathname): pathname为路径创建File对象
    File f1 = new File("test2.txt");
    File f2 = new File("test02042024dir");

    System.out.println("test@ "+f1.getAbsolutePath());
    //test@ /home/dx/javadir/java_study/src/test2.txt

    System.out.println("test@ "+f2.getAbsolutePath());
    //test@ /home/dx/javadir/java_study/src/test02042024dir

    // 注意: new File("test2.txt")仅仅是创建了一个内存上的对象，
    // 这时候实际磁盘上可能并没有这个文件，创建对象并不会报错
    // 如果文件不存在，那么也需要等到后面实际读取文件时候才会发现问题并报错


}

   //public static void main(String[] args) {
   //    File f1 = new File("test2.txt");
   //    File f2 = new File("test02042024dir");
   //    System.out.println("main@ "+f1.getAbsolutePath());
   //    System.out.println("main@ "+f2.getAbsolutePath());
   //    //main@ /home/dx/javadir/java_study/src/test2.txt
   //    //main@ /home/dx/javadir/java_study/src/test02042024dir
   //}


    @Test
    public void test2(){
    // public File(String parent,String child): parent为父路径, child为在子路径创建File对象
    // public File(File parent,String child): 根据父File和子文件路径创建File对象
    // 参数1一定是个文件目录
    // 参数2可以是一个文件，也可以是一个文件目录
    File file1 = new File("/home/dx/javadir/java_study/src/test02042024dir/","testfile2.txt");
    System.out.println("test2@ "+file1.getAbsolutePath());
    //test2@ /home/dx/javadir/java_study/src/test02042024dir/testfile2.txt

        File file2 = new File("/home/dx/javadir/java_study/src/test02042024dir","test2dir");
        System.out.println("test2@ "+file2.getAbsolutePath());
        //test2@ /home/dx/javadir/java_study/src/test02042024dir/test2dir

    }

    @Test
    public void test3(){
    //public File(File parent,String child): 根据父File和子文件路径创建File对象
        // 参数1一定是个文件目录(系统会根据它所在的目录，创建子目录然后来创建文件或目录)
        // 参数2可以是一个文件，也可以是一个文件目录

    File f1 =  new File("testdir2","test4");
        System.out.println("test3@ "+f1.getAbsolutePath());
        //test3@ /home/dx/javadir/java_study/src/testdir2/test4

    File f2 =  new File("testdir3","test5.txt");
        System.out.println("test3@ "+f2.getAbsolutePath());
        //test3@ /home/dx/javadir/java_study/src/testdir3/test5.txt
    }



}

File的实例化和常用方法

/*
- 获取文件和目录基本信息
- public String getName()：获取名称
- public String getPath()：获取路径
- public String getAbsolutePath()：获取绝对路径
- public File getAbsoluteFile()：获取绝对路径表示的文件
- public String getParent()：获取上层文件目录路径。若无，返回null
- public long length()：获取文件长度(即字节数)，不能获取目录的长度。
- public long lastModified()：获取最后一次的修改时间，毫秒值
- */
- 相对路径举例

package File;

import org.junit.Test;

import java.io.File;

public class FileTest1 {



    @Test
    public void test1(){
        File f1 = new File("hello.txt");
        System.out.println(f1.getName());//hello.txt

        System.out.println(f1.getPath());//因为上面写的是个相对路径，所以这里也只是相对路径hello.txt

        System.out.println(f1.getAbsolutePath());//home/dx/javadir/java_study/src/hello.txt

        System.out.println(f1.getAbsoluteFile());//home/dx/javadir/java_study/src/hello.txt

        System.out.println(f1.getParent());//因为目前写的文件是个相对路径，没有parent所以结果为null

        System.out.println(f1.getAbsoluteFile().getParent());//home/dx/javadir/java_study/src/

        System.out.println(f1.length());//占多少个字节 目前文件也不存在，为0

        System.out.println(f1.lastModified());//最近一次修改的时间，毫秒值。这里为零0


    }


}

运行结果：

hello.txt
hello.txt
/home/dx/javadir/java_study/src/hello.txt
/home/dx/javadir/java_study/src/hello.txt
null
/home/dx/javadir/java_study/src
0
0

上面字节数和最近修改的时间都为0,因为文件其实不存在。先再手动构建一个file放在/home/dx/javadir/java_study/src/hello.txt位置，随便修改文件字节内容。上述代码不变，再次测试。可以看到这次运行输出f1.length()字节数，最后修改时间都有了变化。

hello.txt
hello.txt
/home/dx/javadir/java_study/src/hello.txt
/home/dx/javadir/java_study/src/hello.txt
null
/home/dx/javadir/java_study/src
1119
1712118242797

Process finished with exit code 0

- 绝对路径举例
  现在手动创建directory位置放在/home/dx/javadir/java_study/testdir01/

package File;

import org.junit.Test;

import java.io.File;

public class FileTest1 {

    /*
     * 获取文件和目录基本信息
     * public String getName()：         获取名称
     * public String getPath()：         获取路径
     * public String getAbsolutePath()： 获取绝对路径
     * public File   getAbsoluteFile(): 获取绝对路径表示的文件
     * public String getParent()：       获取上层文件目录路径。若无，返回null
     * public long   length()：          获取文件长度(即字节数)，不能获取目录的长度。
     * public long   lastModified()：    获取最后一次的修改时间，毫秒值
     *
     * */

    @Test
    public void test1(){
        File f1 = new File("hello.txt");
        System.out.println(f1.getName());//hello.txt

        System.out.println(f1.getPath());//因为上面写的是个相对路径，所以这里也只是相对路径hello.txt

        System.out.println(f1.getAbsolutePath());//home/dx/javadir/java_study/src/hello.txt

        System.out.println(f1.getAbsoluteFile());//home/dx/javadir/java_study/src/hello.txt

        System.out.println(f1.getParent());//因为目前写的文件是个相对路径，没有parent所以结果为null

        System.out.println(f1.getAbsoluteFile().getParent());//home/dx/javadir/java_study/src/

        System.out.println(f1.length());//占多少个字节 目前用户没有创建，文件不存在，为0

        System.out.println(f1.lastModified());//最近一次修改的时间，毫秒值。如果用户没有去创建文件，那么文件不存在，为零0


    }


    @Test
    public void test2(){
        File f1 = new File("/home/dx/javadir/java_study/testdir01");
        System.out.println(f1.getName());//现在在上面的位置创建了一个文件夹directory

        System.out.println(f1.getPath());//因为上面写的是个绝对路径，而且是文件夹，所以这里给出文件夹的绝对路径

        System.out.println(f1.getAbsolutePath());//因为上面写的是个绝对路径，而且是文件夹，所以这里给出文件夹的绝对路径

        System.out.println(f1.getAbsoluteFile());//因为上面写的是个绝对路径，而且是文件夹，所以这里给出文件夹的绝对路径

        System.out.println(f1.getParent());//因为上面写的是个绝对路径，而且是文件夹，所以这里给出文件夹的绝对路径

        System.out.println(f1.getAbsoluteFile().getParent());//给出文件夹的上级home/dx/javadir/java_study/

        System.out.println(f1.length());//占多少个字节，如果是判断directory这个方法因版本不同而返回值不同

        System.out.println(f1.lastModified());//最近一次修改的时间，毫秒值。

    }

}

返回值：


testdir01
/home/dx/javadir/java_study/testdir01
/home/dx/javadir/java_study/testdir01
/home/dx/javadir/java_study/testdir01
/home/dx/javadir/java_study
/home/dx/javadir/java_study
4096
1712119638024

注意上述 File 对象表示的是一个目录，而不是一个文件，那么调用 length() 方法的结果可能因Java版本和文件系统而异。在一些Java版本和文件系统中，尝试对目录调用 length() 可能会抛出 IOException。另外，对于目录调用 length() 可能会返回目录本身的大小（这通常是一个很小的值，因为目录本身只包含元数据，比如权限、时间戳和指向其内容的指针等）。

提示：想要检查 File 对象是否表示一个目录，建议使用 isDirectory() 方法。

列出目录的下一级
public String[] list():返回一个String数组，表示该File目录中的所有子文件或目录。
public File[] listFiles()：返回一个File数组，表示该File目录中的所有子文件或目录。
*/

/*
* 列出目录的下一级
* public String[] list():返回一个String数组，表示该File目录中的所有子文件或目录。
* public File[] listFiles()：返回一个File数组，表示该File目录中的所有子文件或目录。
*
* */

package File;

import org.junit.Test;

import java.io.File;

public class FileTest1 {

    @Test
    public void test3(){
        File f3 = new File("/home/dx/javadir/java_study/out/production/java_study/");

        //String[] list()展示全体文件或目录名字
        String[] s1 = f3.list();//list()返回File下面展示的所有的文件或目录
        for (String s : s1) {
            System.out.println(s);
        }

        System.out.println("=====================>");

        //File[] listFiles()展示全体文件或目录带路径
        File[] myfiles = f3.listFiles();
        for (File file : myfiles) {
            System.out.println(file);//直接列出所有文件的全路径
            //System.out.println(file.getName()); //不想要全路径，只想要文件夹下面所有文件的名字，用getName()，这样结果和上一条使用xx.list()类似
        }


    }
}

运行结果：

ClassDemo
Thread
Math
scanner
test
oop
Stringtest
Wrapper
struct
static_study
Stream
InnerClass
method
Arrays
exception
Enum
testfile_can_be_delete_created_by_dx.txt
Compare
.idea
LambdaTest
=====================>
/home/dx/javadir/java_study/out/production/java_study/ClassDemo
/home/dx/javadir/java_study/out/production/java_study/Thread
/home/dx/javadir/java_study/out/production/java_study/Math
/home/dx/javadir/java_study/out/production/java_study/scanner
/home/dx/javadir/java_study/out/production/java_study/test
/home/dx/javadir/java_study/out/production/java_study/oop
/home/dx/javadir/java_study/out/production/java_study/Stringtest
/home/dx/javadir/java_study/out/production/java_study/Wrapper
/home/dx/javadir/java_study/out/production/java_study/struct
/home/dx/javadir/java_study/out/production/java_study/static_study
/home/dx/javadir/java_study/out/production/java_study/Stream
/home/dx/javadir/java_study/out/production/java_study/InnerClass
/home/dx/javadir/java_study/out/production/java_study/method
/home/dx/javadir/java_study/out/production/java_study/Arrays
/home/dx/javadir/java_study/out/production/java_study/exception
/home/dx/javadir/java_study/out/production/java_study/Enum
/home/dx/javadir/java_study/out/production/java_study/testfile_can_be_delete_created_by_dx.txt
/home/dx/javadir/java_study/out/production/java_study/Compare
/home/dx/javadir/java_study/out/production/java_study/.idea
/home/dx/javadir/java_study/out/production/java_study/LambdaTest

Process finished with exit code 0

/*
* File类的重命名功能
* public boolean renameTo(File dest)：把文件重命名为指定的文件路径。
*
* 举例：file1.renameTo(file2)要想此方法执行完返回true。要求：
* file1必须存在，且file2文件目录必须为真，但是file2不可以存在。
*
* */

举例说明：

package File;

import org.junit.Test;

import java.io.File;

public class FileTest1 {
    @Test
    public void test4(){
        File ff1 = new File("hello.txt");
        System.out.println(ff1.getAbsolutePath());

        File ff2 = new File("/home/dx/javadir/java_study/testdir02/hello_cpy.txt");
        boolean renameSuccess = ff1.renameTo(ff2);
        System.out.println(renameSuccess);
    }
}

运行结果：

/home/dx/javadir/java_study/src/hello.txt
true

Process finished with exit code 0

/* 判断功能的方法
* public boolean exists()：此File表示的文件或目录是否实际存在
* public boolean isDirectory() ：此File表示的是否为目录
* public boolean isFile ：此File表示的是否是文件
* public boolean canRead ：判断是否可读
* public boolean canWrite ：判断是否可写
* public boolean isHidden() ：判断是否隐藏
* */

package File;

import org.junit.Test;

import java.io.File;

public class FileTest1 {
 @Test
    public void test5(){
        File f5 = new File("/home/dx/javadir/java_study/testdir02/hello_cpy.txt");
        System.out.println(f5.exists());          //true
        System.out.println(f5.isDirectory());     //false
        System.out.println(f5.isFile());          //true
        System.out.println(f5.canRead());         //true
        System.out.println(f5.canWrite());        //true
        System.out.println(f5.isHidden());        //false

        System.out.println("=====================>");

        File ff5 = new File("/home/dx/javadir/java_study/testdir03");
        System.out.println(ff5.exists());          //true
        System.out.println(ff5.isDirectory());     //true
        System.out.println(ff5.isFile());          //false
        //System.out.println(ff3.canRead());         //true
        //System.out.println(ff3.canWrite());        //true
        //System.out.println(ff3.isHidden());        //false

    }
}

运行结果：

true
false
true
true
true
false
=====================>
true
true
false

Process finished with exit code 0

/* 创建 删除功能
* public boolean createNewFile(): 创建文件，若文件存在则不会创建，直接返回false
* public boolean mkdir() : 创建文件目录，若此目录已经存在则不会创建。如果此文件目录的上层目录不存在，也创建不了。
* public boolean mkdirs() : 创建文件目录，若上层文件目录不存在，则一起创建
* public boolean delete() : 删除文件或文件夹
* 注意：1. java删除不走回收站，删掉就真的没了。
* 2. 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录
* */

文件的创建


package File;

import org.junit.Test;

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

public class FileTest1 {

    @Test
    public void test06() throws IOException {
        //文件的测试删除
        File f6 = new File("/home/dx/javadir/java_study/testdir01/test06.txt");
        //当前directory存在，但是test06.txt不存在

        if(!f6.exists()){ //如果文件不存在，那就创建这个文件。
            boolean isSucc = f6.createNewFile();
            if(isSucc){
                System.out.println("创建成功"); //第一次运行，走这里，显示“创建成功”
            }
        }
            else{
                System.out.println("此文件已经存在");
                System.out.println(f6.delete()?"文件删除成功":"文件删除失败");
            }

        }


    }

运行结果：

此文件已经存在
文件删除成功

Process finished with exit code 0

文件夹创建示例：

package File;

import org.junit.Test;

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

public class FileTest1 {
        @Test
    public void test07(){
        //创建时候父目录已经存在，只需要创建子目录dir和dirs区别不大
        File f7 = new File("/home/dx/javadir/java_study/testdir03/mytestdir");
        //第一次执行时，/home/dx/javadir/java_study/testdir03/是存在的，但是mytestdir是不存在的。
            System.out.println(f7.mkdir());
            // 指令执行完毕，返回true并且mytestdir应该就被创建出来了。
            // 当第二次执行时候，就会返回false因为这个文件夹已经存在了。


            File f8 = new File("/home/dx/javadir/java_study/testdir03/mydirs");
            //第一次执行时，/home/dx/javadir/java_study/testdir03/是存在的，但是mydirs是不存在的。
            System.out.println(f8.mkdirs());
            // 第一次指令执行完毕，返回true并且mydirs应该就被创建出来了。
            // 第二次执行时返回false，因为这个文件夹已经存在了。

        }



    @Test
    public void test08(){
        //创建时候父目录不存在，不但需要创建子目录，还需要创建父目录。
        File fdir8 = new File("/home/dx/javadir/java_study/testdir03/test08dir/iotestdir");
        //第一次执行时，/home/dx/javadir/java_study/testdir03/test08dir是不存在的，父目录都不在，mkdir创建不了了。
        System.out.println(fdir8.mkdir());
        // 指令执行完毕，永远返回false，父目录不存在，子目录文件夹创建不出来。



        File fdirs8 = new File("/home/dx/javadir/java_study/testdir03/test08dirs/iotestdirs");
        //第一次执行时，/home/dx/javadir/java_study/testdir03/test08dirs/是不存在的，mydirs先去创建不存在的父目录。
        System.out.println(fdirs8.mkdirs());
        // 第一次指令执行完毕，返回true，运用mydirs，test08dirs/iotestdirs文件夹应该就被创建出来了。
        // 第二次执行时返回false，因为这个文件夹已经存在了。

    }


    @Test
    public void test09(){
        File fdirs09 = new File("/home/dx/javadir/java_study/testdir03/test08dirs/iotestdirs");
        //第一次执行时，/home/dx/javadir/java_study/testdir03/test08dirs/是不存在的，mydirs先去创建不存在的父目录。
        System.out.println(fdirs09.mkdirs()+"...testdir03/test08dirs/iotestdirs创建成功");
        System.out.println(fdirs09.delete()+"...testdir03/test08dirs/iotestdirs删除成功");

    }
}

注意，最后使用删除directory的方法，需要保证directory里面是空的，否则返回false，文件夹删不掉。

File的应用案例

练习：创建一个与hello.txt文件在相同目录下的另一个名叫abc.txt的文件。

package File;

import org.junit.Test;
import java.io.File;
import java.io.IOException;

public class FileTest2 {
    @Test
    public void test1(){
        File f1= new File("hello.txt");
        //System.out.println(f1.getAbsoluteFile().getParent());
        System.out.println(f1.getAbsolutePath());
        //f1.renameTo(new File("abc.txt"));

        File f2 = new File(f1.getAbsoluteFile().getParent(),"abc.txt");
        System.out.println(f2.getAbsolutePath());

    }
}

运行结果

/home/dx/javadir/java_study/src/hello.txt
/home/dx/javadir/java_study/src/abc.txt

Process finished with exit code 0

知识补充： File类有一个文件过滤器方法
public String[ ] list(FilternameFilter filter)

用法参考下面的结构，其中mydir是用户自定义的file表示的一个地址。
使用时候可以将mydir和myresult换成其他名字。

File mydir = new File("/home/study/src/Files/");
 String [] myresult = mydir.list(new FilenameFilter() {
 @Override
 public boolean accept(File dir, String name) {
//根据各个项目逻辑要求，在这写一些filter逻辑，
//只有return true的name才会被记录在myresult中

   return true;
   }

});

练习2：查阅一个目录下是否有扩展名为.jpg的文件，如果有，请输出他们的名字。

package File;

import org.junit.Test;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.Arrays;

public class FileTest2 {
 public void test2(){
        File mydir = new File("/home/dx/javadir/java_study/src/File/");

        //写法1：
        String[] s1 = mydir.list();
        for (String s : s1) {
            if(s.endsWith(".jpg"))
            System.out.println("第一种解法： "+s);
        }

        //写法2：
        File[] myfiles = mydir.listFiles();
        for (File myfile : myfiles) {
            if(myfile.getName().endsWith(".jpg")){
                System.out.println("第二种解法： "+myfile.getName());
            }
        }

        //写法3：public String[ ] list(FilenameFilter filter)
            String [] myst = mydir.list(new FilenameFilter() {
                @Override
                public boolean accept(File dir, String name) {

                  //  if(name.endsWith(".jpg"))
                  //      return true;
                  //  else
                  //      return false;
                    return (name.endsWith(".jpg"));
                }
            });
        for (String s : myst) {
            System.out.println("第三种解法： "+s);
        }

        }



    }

实际输出：

第一种解法： Text File.jpg
第一种解法： test02File.jpg
第二种解法： Text File.jpg
第二种解法： test02File.jpg
第三种解法： Text File.jpg
第三种解法： test02File.jpg

Process finished with exit code 0

练习3 遍历指定文件目录下所有文件的名称，包括子文件目录中的文件。
提示，如果需要可以构建方法类似下面这种
public void printFileName(File file)//其中file可能是文件也可能是文件目录
然后用递归作相应运算

拓展1：删除指定文件目录及其下的所有文件
提示，如果需要可以构建方法类似下面这种method，然后用递归做运算
public void deleteDirectory(File file) //其中file可能是文件也可能是文件目录

拓展2：计算指定文件目录占用空间的大小
提示，如果需要可以构建方法类似下面这种method，然后用递归做运算
public long getDirectorySize(File file) //其中file可能是文件也可能是文件目录

参考代码

package File;

import org.junit.Test;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.Arrays;

public class FileTest2 {
    @Test
    public void test1() {
        File f1 = new File("hello.txt");
        //System.out.println(f1.getAbsoluteFile().getParent());
        System.out.println(f1.getAbsolutePath());
        //f1.renameTo(new File("abc.txt"));

        File f2 = new File(f1.getAbsoluteFile().getParent(), "abc.txt");
        System.out.println(f2.getAbsolutePath());

    }

    @Test

    public void test2() {
        File mydir = new File("/home/dx/javadir/java_study/src/File/");

        //写法1：
        String[] s1 = mydir.list();
        for (String s : s1) {
            if (s.endsWith(".jpg"))
                System.out.println("第一种解法： " + s);
        }

        //写法2：
        File[] myfiles = mydir.listFiles();
        for (File myfile : myfiles) {
            if (myfile.getName().endsWith(".jpg")) {
                System.out.println("第二种解法： " + myfile.getName());
            }
        }

        //写法3：public String[ ] list(FilenameFilter filter)
        String[] myst = mydir.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {

                //  if(name.endsWith(".jpg"))
                //      return true;
                //  else
                //      return false;
                return (name.endsWith(".jpg"));
            }
        });
        for (String s : myst) {
            System.out.println("第三种解法： " + s);
        }

    }


    @Test
    public void test03() {
        File mydir = new File("/home/dx/javadir/java_study/src/CanBeDeleteTestDirectory/");
        ListAllNames(mydir);

        /* 思考：如果仅仅是一层有文件夹，那可以再进一层，但是如果有很多层文件夹，下面的方法就不可用了。
        //可以用递归的思维方式，建立一个方法method：每次发现下一层是文件就打印出来，是文件夹就继续调用这个method，总会有调用完毕的时候。
        *
            File[] myarr = mydir.listFiles();
            for (File file : myarr) {
                if(file.isDirectory()){
                    for (File listFile : file.listFiles()) {
                        System.out.println(listFile);
                    }
                }
                else
                System.out.println(file);
            }
 */
    }


    @Test

    public void tes04() {
        //比如想要删除这个文件夹下面的所有东西
        // /home/dx/javadir/java_study/src/CanBeDeleteTestDirectory/test01dir/
        File mydeltask = new File("/home/dx/javadir/java_study/src/CanBeDeleteTestDirectory/");
        System.out.println(mydeltask.getTotalSpace());
        //注意这个pathname不要在地址开始写空格，不要写成类似"   /home/dx/javadir/java_study/src/..."

        System.out.println(getDirectorySize(mydeltask));
        
        DeleteAllNames(mydeltask);
        System.out.println("-------file(s) deleted, done!---------->");

    }

    public static void ListAllNames(File dirin) {
        for (File microfile : dirin.listFiles()) {
            if (microfile.isDirectory()) {
                ListAllNames(microfile);
            } else {
                System.out.println(microfile);
            }
        }
    }





    public static void DeleteAllNames(File dirin){
        for (File microfile : dirin.listFiles()) {
            if (microfile.isDirectory()) {
                {DeleteAllNames(microfile);
                    microfile.delete();}
            } else {
                microfile.delete();
            }
        }
    }

    public void printFileName(File file){
        if(file.isFile()){
            System.out.println(file.getName());
        } else if (file.isDirectory()) {
            File[] files =file.listFiles();
            for (File f : files) {
                printFileName(f);
            }
        }
    }
    public void deleteDirectory(File file){
        //如果file是文件，直接delete
        //如果file是目录，先把它的下一级干掉，然后删除自己
        if(file.isDirectory()){
            File[] all = file.listFiles();
            //循环删除的是file的下一级
            for (File f : all) {//f代表file的每一个下级
                deleteDirectory(f);
            }
        }
        //删除自己
        file.delete();
    }


    public long getDirectorySize(File file){
        //file是文件，那么直接返回file.length()
        //file是目录，那么它的下一级所有大小加起来就是它的总大小
        long size =0;
        if(file.isFile()){
            size = file.length();
        }
        else{
            File[] all = file.listFiles();//获取file的下一级
            //类加all[i]的大小
            for (File f : all) {
                size+=getDirectorySize(f); //f的大小
            }
        }
        return size;
    }

}

Dear_喜阳阳

关注

6
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
Java学习41-Java 流(Stream)、文件(File)和IO

注意上述 File 对象表示的是一个目录，而不是一个文件，那么调用 length() 方法的结果可能因Java版本和文件系统而异。另外，对于目录调用 length() 可能会返回目录本身的大小（这通常是一个很小的值，因为目录本身只包含元数据，比如权限、时间戳和指向其内容的指针等）。上述代码不变，再次测试。File类中声明了新建，删除，获取名称，重命名等方法，并没有涉及到文件内容的读写操作。注意，最后使用删除directory的方法，需要保证directory里面是空的，否则返回false，文件夹删不掉。
复制链接

扫一扫