JavaEE - 文件操作和IO

1. 文件操作—— IO

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

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

树型结构组织和目录

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

文件路径（Path）

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

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

其他知识

即使是普通文件，根据其保存数据的不同，也经常被分为不同的类型，我们一般简单的划分为文本文件和二进制文件，分别指代保存被字符集编码的文本和按照标准格式保存的非被字符集编码过的文件。

用记事本打开，如果打开之后是乱码,就是二进制.不是乱码就是文本~

Windows操作系统上，会按照文件名中的后缀来确定文件类型以及该类型文件的默认打开程序。但这个习俗并不是通用的，在 OSX、Unix、Linux等操作系统上，就没有这样的习惯，一般不对文件类型做如此精确地分类。

文件由于被操作系统进行了管理，所以根据不同的用户，会赋予用户不同的对待该文件的权限，一般地可以认为有可读、可写、可执行权限。

Windows操作系统上，还有一类文件比较特殊，就是平时我们看到的快捷方式（shortcut），这种文件只是对真实文件的一种引用而已。其他操作系统上也有类似的概念，例如，软链接（soft link）等

最后，很多操作系统为了实现接口的统一性，将所有的 I/O设备都抽象成了文件的概念，使用这一理念最为知名的就是 Unix、Linux操作系统——万物皆文件。

2. Java中操作文件

本节内容中，我们主要涉及文件的元信息、路径的操作，暂时不涉及关于文件中内容的读写操作。
Java中通过 java.io.File类来对一个文件（包括目录）进行抽象的描述。
注意，有 File对象，并不代表真实存在该文件。

File概述

我们先来看看 File类中的常见属性、构造方法和方法

属性

构造方法

方法

代码示例

示例1 观察 get系列的特点和差异

import java.io.File;
import java.io.IOException;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       File file = new File("..\\hello-world.txt"); // 并不要求该文件真实存在
       System.out.println(file.getParent());
       System.out.println(file.getName());
       System.out.println(file.getPath());
       System.out.println(file.getAbsolutePath());
       System.out.println(file.getCanonicalPath());
  }
}

运行结果

..
hello-world.txt
..\hello-world.txt
D:\代码练习\文件示例1\..\hello-world.txt
D:\代码练习\hello-world.tx

示例2 普通文件的创建、删除

import java.io.File;
import java.io.IOException;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       File file = new File("hello-world.txt"); // 要求该文件不存在，才能看到相同
的现象
       System.out.println(file.exists());
       System.out.println(file.isDirectory());
       System.out.println(file.isFile());
       System.out.println(file.createNewFile());
       System.out.println(file.exists());
       System.out.println(file.isDirectory());
       System.out.println(file.isFile());
       System.out.println(file.createNewFile());
  }
}

运行结果

false
false
false
true
true
false
true
false

示例3 普通文件的删除

import java.io.File;
import java.io.IOException;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       File file = new File("some-file.txt"); // 要求该文件不存在，才能看到相同的现
象
       System.out.println(file.exists());
       System.out.println(file.createNewFile());
       System.out.println(file.exists());
       System.out.println(file.delete());
       System.out.println(file.exists());
  }
}

运行结果

false
true
true
true
false

示例4 观察 deleteOnExit的现象

import java.io.File;
import java.io.IOException;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       File file = new File("some-file.txt"); // 要求该文件不存在，才能看到相同的现
象
       System.out.println(file.exists());
       System.out.println(file.createNewFile());
       System.out.println(file.exists());
       file.deleteOnExit();
       System.out.println(file.exists());
  }
}

运行结果

false
true
true
true

程序运行结束后，文件还是被删除了

示例5 观察目录的创建

import java.io.File;
import java.io.IOException;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       File dir = new File("some-dir"); // 要求该目录不存在，才能看到相同的现象
       System.out.println(dir.isDirectory());
       System.out.println(dir.isFile());
       System.out.println(dir.mkdir());
       System.out.println(dir.isDirectory());
       System.out.println(dir.isFile());
  }
}

运行结果

false
false
true
true
false

示例6 观察目录创建2

import java.io.File;
import java.io.IOException;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       File dir = new File("some-parent\\some-dir"); // some-parent 和 some-
dir 都不存在
       System.out.println(dir.isDirectory());
       System.out.println(dir.isFile());
       System.out.println(dir.mkdir());
       System.out.println(dir.isDirectory());
       System.out.println(dir.isFile());
  }
}

运行结果

false
false
false
false
false

mkdir()的时候，如果中间目录不存在，则无法创建成功; mkdirs()可以解决这个问题。

import java.io.File;
import java.io.IOException;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       File dir = new File("some-parent\\some-dir"); // some-parent 和 some-
dir 都不存在
       System.out.println(dir.isDirectory());
       System.out.println(dir.isFile());
       System.out.println(dir.mkdirs());
       System.out.println(dir.isDirectory());
       System.out.println(dir.isFile());
  }
}

运行结果

false
false
true
true
false

示例7 观察文件重命名

import java.io.File;
import java.io.IOException;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       File file = new File("some-file.txt"); // 要求 some-file.txt 得存在，可以
是普通文件，可以是目录
       File dest = new File("dest.txt");   // 要求 dest.txt 不存在
       System.out.println(file.exists());
       System.out.println(dest.exists());
       System.out.println(file.renameTo(dest));
       System.out.println(file.exists());
       System.out.println(dest.exists());
  }
}

运行结果

true
false
true
false
true

3. 文件内容的读写——数据流

InputStream概述

方法

说明
InputStream只是一个抽象类，要使用还需要具体的实现类。关于 InputStream的实现类有很多，基本可以认为不同的输入设备都可以对应一个 InputStream类，我们现在只关心从文件中读取，所以使用 FileInputStream

FileInputStream概述
构造方法

代码示例
示例1
将文件完全读完的两种方式。相比较而言，后一种的 IO次数更少，性能更好。

import java.io.*;
// 需要先在项目目录下准备好一个 hello.txt 的文件，里面填充 "Hello" 的内容
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       try (InputStream is = new FileInputStream("hello.txt")) {
    
    
           while (true) {
    
    
               int b = is.read();
               if (b == -1) {
    
    
                   // 代表文件已经全部读完
                   break;
              }
               
               System.out.printf("%c", b);
          }
      }
  }
}

import java.io.*;
// 需要先在项目目录下准备好一个 hello.txt 的文件，里面填充 "Hello" 的内容
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       try (InputStream is = new FileInputStream("hello.txt")) {
    
    
           byte[] buf = new byte[1024];
           int len;
           
           while (true) {
    
    
               len = is.read(buf);
               if (len == -1) {
    
    
                   // 代表文件已经全部读完
                   break;
              }
               
               for (int i = 0; i < len; i++) {
    
    
              System.out.printf("%c", buf[i]);
              }
          }
      }
  }
}

示例2
这里我们把文件内容中填充中文看看，注意，写中文的时候使用 UTF-8编码。hello.txt中填写 “你好中国”
注意：这里我利用了这几个中文的 UTF-8编码后长度刚好是 3个字节和长度不超过 1024字节的现状，但这种方式并不是通用的

import java.io.*;
// 需要先在项目目录下准备好一个 hello.txt 的文件，里面填充 "你好中国" 的内容
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       try (InputStream is = new FileInputStream("hello.txt")) {
    
    
           byte[] buf = new byte[1024];
           int len;
           while (true) {
    
    
               len = is.read(buf);
               if (len == -1) {
    
    
                   // 代表文件已经全部读完
                   break;
              }
               // 每次使用 3 字节进行 utf-8 解码，得到中文字符
               // 利用 String 中的构造方法完成
               // 这个方法了解下即可，不是通用的解决办法
               for (int i = 0; i < len; i += 3) {
    
    
                   String s = new String(buf, i, 3, "UTF-8");
                   System.out.printf("%s", s);
              }
          }
      }
  }
}

利用 Scanner进行字符读取

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

示例1

import java.io.*;
import java.util.*;
// 需要先在项目目录下准备好一个 hello.txt 的文件，里面填充 "你好中国" 的内容
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       try (InputStream is = new FileInputStream("hello.txt")) {
    
    
          try (Scanner scanner = new Scanner(is, "UTF-8")) {
    
    
              while (scanner.hasNext()) {
    
    
                  String s = scanner.next();
                  System.out.print(s);
              }
          }
      }
  }
}

OutputStream概述

方法

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

利用 OutputStreamWriter进行字符写入

示例1

import java.io.*;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       try (OutputStream os = new FileOutputStream("output.txt")) {
    
    
           os.write('H');
           os.write('e');
           os.write('l');
           os.write('l');
           os.write('o');
           // 不要忘记 flush
           os.flush();
      }
  }
}

import java.io.*;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       try (OutputStream os = new FileOutputStream("output.txt")) {
    
    
           byte[] b = new byte[] {
    
    
              (byte)'G', (byte)'o', (byte)'o', (byte)'d'
          };
           os.write(b);
         
           // 不要忘记 flush
           os.flush();
      }
  }
}

import java.io.*;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       try (OutputStream os = new FileOutputStream("output.txt")) {
    
    
           byte[] b = new byte[] {
    
    
              (byte)'G', (byte)'o', (byte)'o', (byte)'d', (byte)'B',
(byte)'a', (byte)'d'
          };
           os.write(b, 0, 4);
         
           // 不要忘记 flush
           os.flush();
      }
  }
}

import java.io.*;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       try (OutputStream os = new FileOutputStream("output.txt")) {
    
    
          String s = "Nothing";
           byte[] b = s.getBytes();
           os.write(b);
         
           // 不要忘记 flush
           os.flush();
      }
  }
}

import java.io.*;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       try (OutputStream os = new FileOutputStream("output.txt")) {
    
    
           String s = "你好中国";
           byte[] b = s.getBytes("utf-8");
       	   os.write(b);
           // 不要忘记 flush
           os.flush();
      }
  }
}

利用 PrintWriter找到我们熟悉的方法

上述，我们其实已经完成输出工作，但总是有所不方便，我们接来下将OutputStream处理下，使用PrintWriter类来完成输出，因为PrintWriter类中提供了我们熟悉的 print/println/printf方法

OutputStream os = ...;
OutputStreamWriter osWriter = new OutputStreamWriter(os, "utf-8"); // 告诉它，我
们的字符集编码是 utf-8 的
PrintWriter writer = new PrintWriter(osWriter);
// 接下来我们就可以方便的使用 writer 提供的各种方法了
writer.print("Hello");
writer.println("你好");
writer.printf("%d: %s\n", 1, "没什么");
// 不要忘记 flush
writer.flush();

示例1

import java.io.*;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       try (OutputStream os = new FileOutputStream("output.txt")) {
    
    
           try (OutputStreamWriter osWriter = new OutputStreamWriter(os, "UTF-
8")) {
    
    
               try (PrintWriter writer = new PrintWriter(osWriter)) {
    
    
                   writer.println("我是第一行");
                   writer.print("我的第二行\r\n");
                   writer.printf("%d: 我的第三行\r\n", 1 + 1);
                   writer.flush();
              }
          }
      }
  }
}

文件操作练习

我们学会了文件的基本操作 +文件内容读写操作，接下来，我们实现一些小工具程序，来锻炼我们的能力。

示例1

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

import java.io.*;
import java.util.*;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       Scanner scanner = new Scanner(System.in);
       System.out.print("请输入要扫描的根目录（绝对路径 OR 相对路径): ");
       String rootDirPath = scanner.next();
       File rootDir = new File(rootDirPath);
       if (!rootDir.isDirectory()) {
    
    
           System.out.println("您输入的根目录不存在或者不是目录，退出");
           return;
      }
       System.out.print("请输入要找出的文件名中的字符: ");
       String token = scanner.next();
       List<File> result = new ArrayList<>();
       // 因为文件系统是树形结构，所以我们使用深度优先遍历（递归）完成遍历
       scanDir(rootDir, token, result);
       System.out.println("共找到了符合条件的文件 " + result.size() + " 个，它们分别
是");
       for (File file : result) {
    
    
           System.out.println(file.getCanonicalPath() + "   请问您是否要删除该文
件？y/n");
           String in = scanner.next();
           if (in.toLowerCase().equals("y")) {
    
    
               file.delete();
          }
      }
  }
   private static void scanDir(File rootDir, String token, List<File> result) {
    
    
       File[] files = rootDir.listFiles();
       if (files == null || files.length == 0) {
    
    
           return;
      }
       for (File file : files) {
    
    
           if (file.isDirectory()) {
    
    
               scanDir(file, token, result);
          } else {
    
    
               if (file.getName().contains(token)) {
    
    
                   result.add(file.getAbsoluteFile());
              }
          }
      }
  }
}

示例2

进行普通文件的复制

import java.io.*;
import java.util.*;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       Scanner scanner = new Scanner(System.in);
       
       System.out.print("请输入要复制的文件（绝对路径 OR 相对路径): ");
       String sourcePath = scanner.next();
       File sourceFile = new File(sourcePath);
       if (!sourceFile.exists()) {
    
    
           System.out.println("文件不存在，请确认路径是否正确");
           return;
      }
       
       if (!sourceFile.isFile()) {
    
    
           System.out.println("文件不是普通文件，请确认路径是否正确");
           return;
      }
       System.out.print("请输入要复制到的目标路径（绝对路径 OR 相对路径): ");
       String destPath = scanner.next();
       File destFile = new File(destPath);
       if (destFile.exists()) {
    
    
           if (destFile.isDirectory()) {
    
    
               System.out.println("目标路径已经存在，并且是一个目录，请确认路径是否正
确");
               return;
          }
           
           if (destFile.isFile()) {
    
    
               System.out.println("目录路径已经存在，是否要进行覆盖？y/n");
               String ans = scanner.next();
               if (!ans.toLowerCase().equals("y")) {
    
    
                   System.out.println("停止复制");
                   return;
              }
          }
      }
       
       try (InputStream is = new FileInputStream(sourceFile)) {
    
    
           try (OutputStream os = new FileOutputStream(destFile)) {
    
    
               byte[] buf = new byte[1024];
               int len;
               
               while (true) {
    
    
                   len = is.read(buf);
                   if (len == -1) {
    
    
                       break;
                  }
                   
                   os.write(buf, 0, len);
              }
               
               os.flush();
          }
      }
      System.out.println("复制已完成");
  }
}

示例3

扫描指定目录，并找到名称或者内容中包含指定字符的所有普通文件（不包含目录）
注意：我们现在的方案性能较差，所以尽量不要在太复杂的目录下或者大文件下实验

import java.io.*;
import java.util.*;
public class Main {
    
    
   public static void main(String[] args) throws IOException {
    
    
       Scanner scanner = new Scanner(System.in);
       System.out.print("请输入要扫描的根目录（绝对路径 OR 相对路径): ");
       String rootDirPath = scanner.next();
       File rootDir = new File(rootDirPath);
       if (!rootDir.isDirectory()) {
    
    
           System.out.println("您输入的根目录不存在或者不是目录，退出");
           return;
      }
       System.out.print("请输入要找出的文件名中的字符: ");
       String token = scanner.next();
       List<File> result = new ArrayList<>();
       // 因为文件系统是树形结构，所以我们使用深度优先遍历（递归）完成遍历
       scanDirWithContent(rootDir, token, result);
       System.out.println("共找到了符合条件的文件 " + result.size() + " 个，它们分别
是");
       for (File file : result) {
    
    
           System.out.println(file.getCanonicalPath());
      }
  }
   private static void scanDirWithContent(File rootDir, String token,
List<File> result) throws IOException {
    
    
       File[] files = rootDir.listFiles();
       if (files == null || files.length == 0) {
    
    
           return;
      }
       for (File file : files) {
    
    
           if (file.isDirectory()) {
    
    
               scanDirWithContent(file, token, result);
          } else {
    
    
               if (isContentContains(file, token)) {
    
    
                   result.add(file.getAbsoluteFile());
              }
          }
      }
  }
  // 我们全部按照utf-8的字符文件来处理
   private static boolean isContentContains(File file, String token) throws
IOException {
    
    
       StringBuilder sb = new StringBuilder();
       try (InputStream is = new FileInputStream(file)) {
    
    
           try (Scanner scanner = new Scanner(is, "UTF-8")) {
    
    
               while (scanner.hasNextLine()) {
    
    
                   sb.append(scanner.nextLine());
                   sb.append("\r\n");
              }
          }
      }
       
       return sb.indexOf(token) != -1;
  }
}

代码参考

如何按字节进行数据读

public static void main(String[] args) {
    
    
    try (InputStream inputStream = new FileInputStream("d:/test.txt")) {
    
    
        // 一次读取若干个字节.
        while (true) {
    
    
            byte[] buffer = new byte[1024];
            int len = inputStream.read(buffer);
            if (len == -1) {
    
    
                // 如果返回 -1 说明读取完毕了
                break;
            }
            for (int i = 0; i < len; i++) {
    
    
                System.out.println(buffer[i]);
            }
        }
    } catch (IOException e) {
    
    
        e.printStackTrace();
    }
}

如何按字节进行数据写

public class Demo9 {
    
    
    public static void main(String[] args) {
    
    
        try (OutputStream outputStream = new FileOutputStream("d:/test.txt")) {
    
    
//            outputStream.write(97);
//            outputStream.write(98);
//            outputStream.write(99);

            byte[] buffer = new byte[]{
    
    97, 98, 99};
            outputStream.write(buffer);
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
    }
}

如何按字符进行数据读

public static void main(String[] args) {
    
    
    try (Reader reader = new FileReader("d:/test.txt")) {
    
    
        // 按照字符来读.
        while (true) {
    
    
            char[] buffer = new char[1024];
            int len = reader.read(buffer);
            if (len == -1) {
    
    
                break;
            }
//                for (int i = 0; i < len; i++) {
    
    
//                    System.out.println(buffer[i]);
//                }
            // 如果这里传入的 数组 是 byte 数组, 还可以手动的指定一下 utf8 字符集避免乱码.
            String s = new String(buffer, 0, len);
            System.out.println(s);
        }
    } catch (IOException e) {
    
    
        e.printStackTrace();
    }
}

如何按字符进行数据写

public static void main(String[] args) {
    
    
    try (Writer writer = new FileWriter("d:/test.txt")) {
    
    
        writer.write("xyz");
    } catch (IOException e) {
    
    
        e.printStackTrace();
    }
}