• Java文件操作

    目录

    1.文件系统概述

    2.Java中的文件操作

    1.文件系统概述

    1.1 认识文件

    我们先来认识狭义上的文件(file)。针对硬盘这种持久化存储的I/O设备，当我们想要进行数据保存时， 往往不是保存成一个整体，而是独立成一个个的单位进行保存，这个独立的单位就被抽象成文件的概念，就类似办公桌上的一份份真实的文件一般。

    文件除了有数据内容之外，还有一部分信息，例如文件名、文件类型、文件大小等并不作为文件的数据 而存在，我们把这部分信息可以视为文件的元信息。

    1.2 树型结构组织和目录 

    随着文件越来越多，对文件的系统管理也被提上了日程，如何进行文件的组织呢，一种合乎自然 的想法出现了，就是按照层级结构进行组织 —— 也就是我们数据结构中学习过的树形结构。这样，一 种专门用来存放管理信息的特殊文件诞生了，也就是我们平时所谓文件夹(folder)或者目录(directory)的 概念。

     

     比如上面这种就是一种典型的树形结构组织。

     1.3 文件路径（Path）

    如何在文件系统中如何定位我们的一个唯一的文件就成为当前要解决的问题，从树型结构的角度来看，树中的每个结点都可以被一条从根开始，一直到达的结点的路径所描 述，而这种描述方式就被称为文件的绝对路径（absolute path）。（类似于我们之前学过的二叉树）

     

     比如这就是一个绝对路径。

    除了可以从根开始进行路径的描述，我们可以从任意结点出发，进行路径的描述，而这种描述方式就被称为相对路径（relative path），相对于当前所在结点的一条路径。

    关于这两个路径的区别，大家可参照物理学上相对位移和绝对位移，主要就是参照点不同。

    2.Java中操作文件 

    2.1 File概述和简单使用

    Java 中通过 java.io.File 类来对一个文件（包括目录）进行抽象的描述。注意，有 File 对象，并不 代表真实存在该文件。

    无论是我们这里提到的File对象，还是我们后面所提到的InputStream对象等，它们都是因为不方便直接操作硬盘里面的数据，才在内存里构造一个和它相关联的对象，操作这个对象就相当于操作硬盘数据。

    就类似于我们日常生活中所使用的遥控器，虽然我们也可以直接对家电等直接进行操作，但因为不方便，所以我们才会使用遥控器。

     我们先简单了解一下File类的基础信息 

    方法

     我们简单看一下下面几段代码：

    观察 get 系列的特点和差异

    1. public class Demo1 {
    2.     public static void main(String[] args) throws IOException {
    3.         File file = new File("./hello-world.txt"); // 并不要求该文件真实存在
    4.         System.out.println(file.getParent());
    5.         System.out.println(file.getName());
    6.         System.out.println(file.getPath());
    7.         System.out.println(file.getAbsolutePath());
    8.         System.out.println(file.getCanonicalPath());
    9.     }
    10. }

     普通文件的创建

    1. public class Demo1 {
    2.     public static void main(String[] args) throws IOException {
    3.         // 前面没写 ./ , 也相当于是 ./, ./ 可以省略~~
    4.         File file = new File("helloworld.txt");
    5.         System.out.println(file.exists());
    6.         System.out.println(file.isDirectory());
    7.         System.out.println(file.isFile());
    8.         System.out.println("========================");
    9.         // 创建文件
    10.         file.createNewFile();
    11.         System.out.println(file.exists());
    12.         System.out.println(file.isDirectory());
    13.         System.out.println(file.isFile());
    14.     }
    15. }

     普通文件删除

    1. public static void main(String[] args) throws InterruptedException, IOException {
    2.         // 文件删除
    3.         File file = new File("helloworld.txt");
    4.         System.out.println(file.exists());
    5.         System.out.println("=======================");
    6.         file.delete();
    7.         System.out.println(file.exists());
    8.     }

    创建文件目录 

    1. public class Demo1 {
    2.     public static void main(String[] args) {
    3.         File file = new File("test/aa/1");
    4.         System.out.println(file.exists());
    5.         System.out.println(file.isDirectory());
    6.         System.out.println("=========================");
    7.         // file.mkdir();
    8.         file.mkdirs();
    9.         System.out.println(file.exists());
    10.         System.out.println(file.isDirectory());
    11.     }
    12. }

     这里需要注意一下两个方法的区别，在上面的代码我们如果使用mkdir方法，虽然程序不会报错，但是目录并不会被创建。

     文件重命名

    1. public class Demo {
    2.     // 文件重命名
    3.     public static void main(String[] args) {
    4.         File file1 = new File("./test1.txt");
    5.         File file2 = new File("./test2.txt");
    6.         file1.renameTo(file2);
    7.     }
    8. }

    2.2 文件内容的读写 —— 数据流

    在Java中关于文件的读写，提供了一些类

    第一组： InputStream OutputStream 字节流，以字节为单位，一般用来操作二进制文件

    第二组： Reader Writer 字符流，以字符为单位，一般用来操作文本文件

    关于流的概念我们可以通过下图简单了解一些

     注意：InputStream/OutputStream不能直接实例化，需要用到子类FileInputStream/FileOutputstream来读/写文件

    根据文件名分成不同的文件夹（文件归档）
    rar 1星 超过10%的资源 10.61MB
    下载

    2.2.1 简单字节文件的读取 

     我们在打开文件后就得到了InputStream对象，后续针对文件的操作都是通过InputStream展开的

     在我们执行完一系列操作后一定要记得关闭文件，释放资源

     为什么需要这样做？

    首先我们需要知道，我们释放的资源主要是文件描述符表，他是用来存储当前进程打开的文件，每次打开文件都会占据文件描述符表的一个位置，而位置是存在上限的，如果一个进程一直在打开文件，没有释放，此时会导致我们后续进程在打开文件时失败

    下面我们看到两段代码：

    1. public class Demo1 {
    2.     public static void main(String[] args){
    3.        try(InputStream inputStream=new FileInputStream("test.txt")){
    4.            while(true){
    5.                //读取文件过程
    6.                int b=inputStream.read();
    7.                //读到文件尾退出
    8.                if(b==-1){
    9.                    break;
    10.                }
    11.                System.out.printf("%c",b);
    12.            }
    13.        }catch(IOException e){
    14.            e.printStackTrace();
    15.        }
    16.     }
    17. }

     大家可能注意到，我们这段代码好像并没有关闭文件资源，但实际上我们是为了代码的简洁采用了 try-with-resources语法来简化我们的代码，使用方法如下：

    try-with-resources 是 JDK 7 中一个新的异常处理机制，它能够很容易地关闭在 try-catch 语句块中使用的资源。所谓的资源（resource）是指在程序完成后，必须关闭的对象。try-with-resources 语句确保了每个资源在语句结束时关闭。所有实现了 java.lang.AutoCloseable 接口（其中，它包括实现了 java.io.Closeable 的所有对象），可以使用作为资源。也就是说在try执行完后（）资源就会自动关闭，不需要我们再去处理。

    1. public class Demo1 {
    2.     public static void main(String[] args){
    3.        try(InputStream inputStream=new FileInputStream("test.txt")){
    4.            byte[] buf=new byte[1024];
    5.            int len;
    6.            while (true) {
    7.                len = inputStream.read(buf);
    8.                if (len == -1) {
    9.                    // 代表文件已经全部读完
    10.                    break;
    11.                }
    12.                for (int i = 0; i < len; i++) {
    13.                    System.out.printf("%c", buf[i]);
    14.                }
    15.            }
    16.            //循环输入输出，避免文件过大一次读不完
    17.        }catch(IOException e){
    18.            e.printStackTrace();
    19.        }
    20.     }
    21. }

     其实这两段代码干的事情是一样的，但是第二段代码是将读取的结果存储到byte数组内然后再去输出，这样IO次数更少，效率更高。（采用byte类型数组是因为read方法向数组内存入的数据类型就是byte，而采用while循环读入和for循环输出是因为防止文件过大数组不能一次存储完全部数据）

    我们把结果放出来给大家展示一下：

    2.2.2 利用 Scanner 进行字符读取

    以上我们都是采用字节流来读取简单的字节文件，那么假如读取中文怎么办呢？

    假如我们的文本为“你好中国”，用之前的代码来读会出现以下结果

    这是因为了这几个中文的 UTF-8 编码后长度刚好是 3 个字节，所以直接这样读是行不通的，那我们还能用字节流来读取吗？答案是可以的。看到下面一段代码。

    1. public class Demo2 {
    2.     public static void main(String[] args) throws IOException {
    3.         try (InputStream is = new FileInputStream("test.txt")) {
    4.             byte[] buf = new byte[1024];
    5.             int len;
    6.             while (true) {
    7.                 len = is.read(buf);
    8.                 if (len == -1) {
    9.                     // 代表文件已经全部读完
    10.                     break;
    11.                 }
    12.                 // 每次使用 3 字节进行 utf-8 解码，得到中文字符
    13.                 // 利用 String 中的构造方法完成
    14.                 // 这个方法了解下即可，不是通用的解决办法
    15.                 for (int i = 0; i < len; i += 3) {
    16.                     String s = new String(buf, i, 3, "UTF-8");
    17.                     System.out.printf("%s", s);
    18.                 }
    19.             }
    20.         }
    21.     }
    22. }

    的确能够成功输出，但是并不是通用的解决方法，我们继续优化。

    上述例子中，我们看到了对字符类型直接使用 InputStream 进行读取是非常麻烦且困难的，所以，我 们使用一种我们之前比较熟悉的类来完成该工作，就是 Scanner 类。

    1. public class Demo2 {
    2.     public static void main(String[] args) throws IOException {
    3.         try(InputStream inputStream=new FileInputStream("test.txt")){
    4.             Scanner scanner=new Scanner(inputStream);
    5.             String s=scanner.nextLine();
    6.             System.out.println(s);
    7.         }
    8.     }
    9. }

    于是我们得到了上面一段非常简短的代码，Scanner的用法就参照平时即可。

     

    VB 文件夹浏览操作 控件
    rar 0星 超过10%的资源 39KB
    下载

     当然由于中文是一个个字符，那么我们使用Reader（字符流）自然也是可以的，代码也比较简单

    1. public class Demo2 {
    2.     // 使用字符流读一下文件
    3.     public static void main(String[] args) throws IOException {
    4.         //由于已知文本较短就没有使用while来读入，这里注意
    5.         Reader reader = new FileReader("test.txt");
    6.         char[] buffer = new char[1024];
    7.         int len = reader.read(buffer);
    8.         for (int i = 0; i < len; i++) {
    9.             System.out.println(buffer[i]);
    10.         }
    11.         reader.close();
    12.     }
    13. }

    2.2.3 OutputStream 概述

    说明

    OutputStream 同样只是一个抽象类，要使用还需要具体的实现类。我们现在还是只关心写入文件中， 所以使用 FileOutputStream 

    利用 OutputStreamWriter 进行字符写入 

    以下给出几段代码示例

    1. public class Main {
    2.     public static void main(String[] args) throws IOException {
    3.         try (OutputStream os = new FileOutputStream("output.txt")) {
    4.             os.write('H');
    5.             os.write('e');
    6.             os.write('l');
    7.             os.write('l');
    8.             os.write('o');
    9.             // 不要忘记 flush
    10.             os.flush();
    11.        }
    12.    }
    13. }
    1. public class Main {
    2.     public static void main(String[] args) throws IOException {
    3.         try (OutputStream os = new FileOutputStream("output.txt")) {
    4.            String s = "Nothing";
    5.             byte[] b = s.getBytes();
    6.             os.write(b);
    7.           
    8.             // 不要忘记 flush
    9.             os.flush();
    10.        }
    11.    }
    12. }
    1. public class Main {
    2.     public static void main(String[] args) throws IOException {
    3.         try (OutputStream os = new FileOutputStream("output.txt")) {
    4.             String s = "你好中国";
    5.             byte[] b = s.getBytes("utf-8");
    6.             os.write(b);
    7.         // 不要忘记 flush
    8.             os.flush();
    9.        }
    10.    }
    11. }

    2.2.4 利用 PrintWriter输出

    上述，我们其实已经完成输出工作，但总是有所不方便，我们接来下将 OutputStream 处理下，使用 PrintWriter 类来完成输出

    因为 PrintWriter 类中提供了我们熟悉的 print/println/printf 方法

    1. OutputStream os = ...;
    2. OutputStreamWriter osWriter = new OutputStreamWriter(os, "utf-8"); // 告诉它，我
    3. 们的字符集编码是 utf-8 的
    4. PrintWriter writer = new PrintWriter(osWriter);
    5. // 接下来我们就可以方便的使用 writer 提供的各种方法了
    6. writer.print("Hello");
    7. writer.println("你好");
    8. writer.printf("%d: %s\n", 1, "没什么");
    9. // 不要忘记 flush
    10. writer.flush();
    1. public static void main(String[] args) throws IOException {
    2.         try (OutputStream outputStream = new FileOutputStream("test2.txt")) {
    3.             // 此处的 PrintWriter 的用法就和 System.out 是一样的了
    4.             PrintWriter printWriter=new PrintWriter(outputStream);
    5.             printWriter.println("hello");
    6.             printWriter.flush();
    7.         } catch (IOException e) {
    8.             e.printStackTrace();
    9.         }
    10.     }

    上面那段代码就是利用PrintWriter来将文本输出到了“test2.txt”文件中，当然别忘了flush操作。

    2.2.5 小程序练习

    扫描指定目录，并找到名称中包含指定字符的所有普通文件（不包含目录），并且后续询问用户是否要 删除该文件

    1. public class Demo2 {
    2.     public static void main(String[] args) {
    3.         Scanner scanner = new Scanner(System.in);
    4.         System.out.println("请输入要扫描的路径: ");
    5.         String rootPath = scanner.next();
    6.         File root = new File(rootPath);
    7.         if (!root.exists()) {
    8.             System.out.println("您输入的路径不存在, 无法进行扫描!");
    9.             return;
    10.         }
    11.         System.out.println("请输入要删除的文件名(或者一部分): ");
    12.         String toDelete = scanner.next();
    13.  
    14.         // 准备进行递归, 通过递归的方式, 来找到所有的文件.
    15.         // 找到所有的文件之后, 再尝试进行删除
    16.         scanDir(root, toDelete);
    17.     }
    18.  
    19.     public static void scanDir(File rootDir, String toDelete){
    20.         File[] files=rootDir.listFiles();//当前目录下所有文件
    21.         if(files==null){
    22.             // 空目录, 直接返回
    23.             return;
    24.         }
    25.         for(File f:files){
    26.             if(f.isDirectory()){
    27.                 //是目录则继续递归
    28.                 scanDir(f,toDelete);
    29.             }else{
    30.                 //普通文件
    31.                 tryDelete(f, toDelete);
    32.             }
    33.         }
    34.     }
    35.  
    36.     public static void tryDelete(File f, String toDelete){
    37.         // 看看当前文件名是否包含了 toDelete, 如果包含, 就删除, 否则就啥都不干
    38.         if(f.getName().contains(toDelete)){
    39.             try {
    40.                 System.out.println("是否要删除文件(Y/n): " + f.getCanonicalPath());
    41.                 Scanner scanner = new Scanner(System.in);
    42.                 String choice = scanner.next();
    43.                 if (choice.equals("Y")) {
    44.                     f.delete();
    45.                 }
    46.             } catch (IOException e) {
    47.                 e.printStackTrace();
    48.             }
    49.         }
    50.     }
    51. }

    进行普通文件的复制

    1. public class Demo3 {
    2.     public static void main(String[] args) {
    3.         // 准备工作
    4.         Scanner scanner=new Scanner(System.in);
    5.         System.out.println("请输入要复制的文件路径: ");
    6.         String srcPath = scanner.next();
    7.         File srcFile = new File(srcPath);
    8.         if(!srcFile.exists()){
    9.             System.out.println("要复制的文件不存在!");
    10.             return;
    11.         }
    12.         if (!srcFile.isFile()) {
    13.             System.out.println("要复制的不是普通文件!");
    14.             return;
    15.         }
    16.         System.out.println("请输入要复制到的目标路径: ");
    17.         String destPath = scanner.next();
    18.         File destFile=new File(destPath);
    19.         if (destFile.exists()) {
    20.             System.out.println("要复制到的目标已经存在! ");
    21.             return;
    22.         }
    23.         // 进行拷贝工作
    24.         try (InputStream inputStream=new FileInputStream(srcFile)){
    25.             try(OutputStream outputStream=new FileOutputStream(destFile)){
    26.                 byte[] buf=new byte[1024];
    27.                 while(true){
    28.                     int len= inputStream.read(buf);
    29.                     System.out.println("len="+len);
    30.                     if(len==-1){
    31.                         System.out.println("拷贝完成");
    32.                         break;
    33.                     }
    34.                     outputStream.write(buf,0,len);//从buf数组获取数据写入目标路径
    35.                 }
    36.             }
    37.         }catch (IOException e){
    38.             e.printStackTrace();
    39.         }
    40.         System.out.println("复制完成");
    41.     }
    42. }

     

  • 相关阅读:
    Spread for ASP.NET 15.2 个性化需求中文版
    Java基础进阶反射
    APS高级排产助取暖器企业实现生产计划管理效率的提升
    Ionic list - ion-item的相关用法
    垃圾收集器ParNew&CMS与底层三色标记算法
    MySQL开发技巧——索引
    SpringBoot配置数据库密码加密的方法
    从分布式锁谈CAP
    （待填坑）【数据结构】笛卡尔树
    BreederDAO 第一项提案发布：DAO 组织的宪法章程
  • 原文地址：https://blog.csdn.net/weixin_60778429/article/details/126136171