JavaEE--文件的操作和IO

文件操作和IO

认识文件

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

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

1.树型结构组织和目录

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

2、文件路径（Path）

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

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

注意：建议大家写代码的时候把写路径的时候要写成斜杠'/'，因为'\'是需要转义的

3、其他知识

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

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

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

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

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

二、Java 中操作文件

本节内容中，我们主要涉及文件的元信息、路径的操作，暂时不涉及关于文件中内容的读写操作。

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

1、File概述

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

1.1属性

构造方法：

方法：

实例1：

java 复制代码

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

public class demo1 {
    public static void main(String[] args) throws IOException {
       File file = new File("E:/code/mysql/bak/person");
       // File file = new File("./person.test");
        System.out.println(file.getParent());
        System.out.println(file.getName());
        System.out.println(file.getAbsoluteFile());
        System.out.println(file.getCanonicalFile());
        //因为我们传入的路径是绝对路径
        System.out.println(file.getPath());

    }
}

实例2：

java 复制代码

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

public class demo1 {
    public static void main(String[] args) throws IOException {
       //File file = new File("E:/code/mysql/bak/person");
       File file = new File("./person.test");
        System.out.println(file.getParent());
        System.out.println(file.getName());
        System.out.println(file.getAbsoluteFile());
        System.out.println(file.getCanonicalFile());
        //因为我们传入的路径是绝对路径
        System.out.println(file.getPath());

    }
}

第一个路径里的 .\ 是 "当前目录" 的占位符（在文件路径中，. 代表当前所在目录），所以 project_2025_12_6\.\person.test 等价于直接写 project_2025_12_6\person.test。
第二个路径是简化后的写法，省略了 "当前目录" 的占位符，直接指向目标文件。

实例3：

java 复制代码

import java.io.File;

public class demo2 {
    public static void main(String[] args) {
        File file = new File("E:code/mysql/person");
        System.out.println(file.isFile());
        System.out.println(file.isDirectory());
        System.out.println(file.exists());

    }
}

可以手动创建一下这个文件

java 复制代码

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

public class demo2 {
    public static void main(String[] args) throws IOException {
        File file = new File("./test.txt");
        if(!file.exists()) {
            file.createNewFile();
        }
        System.out.println(file.isFile());
        System.out.println(file.isDirectory());
        System.out.println(file.exists());

    }
}

Path路径问题

1. 在IDE中运行（如IntelliJ IDEA）

基准路径通常是项目根目录
例如：/Users/username/your-project/
文件会在这个目录下查找

2. 在命令行中使用 `java` 命令运行

基准路径是执行命令时所在的目录
例如在终端中执行：

bash 复制代码

cd /some/directory
java -jar your-app.jar  # 基准路径是 /some/directory

实例4：

java 复制代码

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;

public class demo4 {
    public static void main(String[] args) {
        File file = new File("C:/");
        String[] string = file.list();
        System.out.println(Arrays.toString(string));

    }
}

实例5：

java 复制代码

import java.io.File;
import java.util.Arrays;

public class demo5 {
    public static void main(String[] args) {
        File file = new File("C:/");
        File[] files = file.listFiles();
        System.out.println(Arrays.toString(files));


    }
}

实例6：

三、文件内容的读写⸺数据流

1、InputStream 概述

1.2说明

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

java 复制代码

import java.io.*;
import java.util.zip.InflaterInputStream;

public class demo6 {
    public static void main(String[] args) throws IOException {
        File file = new File("./test");
      if(!file.exists()){
          file.createNewFile();
      }
      try(InputStream inputStream = new FileInputStream("./test");){

          while(true){
              int data = inputStream.read();
            if(data == -1){
                break;
            }
              System.out.println(data);
          }
      }

    }
}

存的是"你好"根据UTF-8 编码对中文字符的 "3 字节编码格式"导致的 ------ 你提供的 228、189、160（对应 "你"），以及 229、165、189（对应 "好"），都是中文字符在 UTF-8 编码下的"3 个字节"

1 位十六进制 → 对应 4 个二进制位（4bit）；
2 位十六进制 → 正好对应 8 个二进制位（8bit），也就是1 个字节。

java 复制代码

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class demo7 {
    public static void main(String[] args) throws IOException {

        try(InputStream inputStream = new FileInputStream("./test");){
            while(true){
                int data = inputStream.read();
                if(data == -1){
                       break;
                }
                System.out.printf("0x%x\n ",data);
        }

        }
    }
}

使用

java 复制代码

import java.io.FileInputStream;
import java.io.IOException;

public class ReadExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("test.txt")) {
            // 创建缓冲区（这里设为10字节）
            byte[] buffer = new byte[10];
            int bytesRead;
            int totalBytes = 0;
            
            // 循环读取直到文件末尾
            while ((bytesRead = fis.read(buffer, 0, buffer.length)) != -1) {
                totalBytes += bytesRead;
                System.out.println("本次读取了 " + bytesRead + " 字节");
                System.out.println("内容: " + new String(buffer, 0, bytesRead));
            }
            
            System.out.println("总共读取了 " + totalBytes + " 字节");
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2、FileInputStream 概述

2.1构造方法

3、代码示例

示例1

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

java 复制代码

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);
            }
        }
    }
 }

java 复制代码

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字节的现状，但这种方式并不是通用的

java 复制代码

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);
                }
            }
         }
     }
 }

4、利用Scanner进行字符读取

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

java 复制代码

 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);
                 }
             }
         }
     }
 }

5、OutputStream概述

5.1方法

try-with -resource

核心：

只要资源类实现了 java.lang.AutoCloseable（或其子接口 java.io.Closeable），并重写 close() 方法，就可以放入 try-with-resources 的括号中 ------JVM 会在 try 块执行完毕（无论正常结束还是抛出异常）后，自动调用资源的 close() 方法 ，无需手动在 finally 中关闭。

1. 基础写法

java 复制代码

try (资源类型 资源变量 = 资源实例) {
    // 业务逻辑：使用资源
} catch (异常类型 e) {
    // 异常处理
}
// 无需finally：资源会自动关闭

2. 多个资源（分号；分隔）

java 复制代码

try (资源1 变量1 = 实例1; 资源2 变量2 = 实例2) {
    // 同时使用多个资源
} catch (异常类型 e) {
    // 异常处理
}
// 关闭顺序：与声明顺序相反（先关变量2，再关变量1）

read（）

第一次 read()：读到 h → 返回 104（h的 ASCII 码）→ 打印 104；
第二次 read()：读到 e → 返回 101 → 打印 101；
第三次 read()：读到 l → 返回 108 → 打印 108；
第四次 read()：读到 l → 返回 108 → 打印 108；
第五次 read()：读到 o → 返回 111 → 打印 111；
第六次 read()：文件已经没有字节了 → 返回 -1 → 触发 break 跳出循环。

实例1：

java 复制代码

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class demo8 {
    public static void main(String[] args) throws FileNotFoundException {
        try(OutputStream outputStream = new FileOutputStream("./output");){
         byte[] bytes = new byte[]{97,98,99};
         outputStream.write(bytes);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

注意;会覆盖原来的写入你要写入的内容

5、OutputStream概述

5.1方法

说明 OutputStream同样只是⼀个抽象类，要使⽤还需要具体的实现类。我们现在还是只关⼼写⼊文件中，所以使⽤FileOutputStream 利用OutputStreamWriter进⾏字符写入

fileName: "./output.txt"：指定写入目标文件为 "当前项目目录下的 output.txt"，若文件不存在会自动创建；
append: true：表示写入方式为追加模式------ 新内容会添加到文件已有内容的末尾，而非覆盖原有内容。

示例1

java 复制代码

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();
        }
    }
 }

java 复制代码

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();
        }
    }
 }

java 复制代码

 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'
            };
            os.write(b, 0, 4);
          
            // 不要忘记 flush 
            os.flush();
        }
    }
 }

java 复制代码

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();
         }
     }
 }

java 复制代码

 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();
         }
     }
 }

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

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

java 复制代码

 OutputStream os = ...;
 OutputStreamWriter osWriter = new OutputStreamWriter(os, "utf-8");        
 PrintWriter writer = new PrintWriter(osWriter);

java 复制代码

 // 接下来我们就可以⽅便的使⽤ writer 提供的各种⽅法了 
 writer.print("Hello");
 writer.println("你好");
 writer.printf("%d: %s\n", 1, "没什么");
 
 // 不要忘记 flush 
 writer.flush();

示例1

java 复制代码

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

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

java 复制代码

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() + "请问您是否要删除该⽂件");
            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

java 复制代码

进行普通文件的复制

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

扫描指定目录，并找到名称或者内容中包含指定字符的所有普通文件（不包含目录）

#注：我们现在的方案性能较差，所以尽量不要在太复杂的目录下或者大文件下实验

java 复制代码

 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
        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 IOE
        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;
    }
 }

代码参考

java 复制代码

如何按字节进行数据读

try (InputStream is = ...) {
    byte[] buf = new byte[1024];
    while (true) {
        int n = is.read(buf);
        if (n == -1) {
            break;
        }
        
        // buf 的 [0, n) 表⽰读到的数据，按业务进⾏处理 
    }
 }
AI写代码
java
运行

如何按字节进行数据写

try (OutputStream os = ...) {
    byte[] buf = new byte[1024];
    while (/* 还有未完成的业务数据 */) { 
        // 将业务数据填⼊ buf 中，⻓度为 n 
        int n = ...;
        os.write(buf, 0, n);
    }
    os.flush();        // 进⾏数据刷新操作
}
AI写代码
java
运行
如何按字符进行数据读

try (InputStream is = ...) {
    try (Scanner scanner = new Scanner(is, "UTF-8")) {
        while (scanner.hasNextLine()) {
            String line = scanner.nextLine();
            
            // 根据 line 做业务处理
 
        }
    }
 }

如何按字符进行数据写

java 复制代码

try (OutputStream os = ...) {
    try (OutputStreamWriter osWriter = new OutputStreamWriter(os, "UTF-8")) {
        try (PrintWriter writer = new PrintWriter(osWriter)) {
            while (/* 还有未完成的业务数据 */) { 
                writer.println(...);
            }
            writer.flush(); // 进⾏数据刷新操作 
        }
    }
 }

JavaEE--文件的操作和IO

文件操作和IO

认识文件

1.树型结构组织和目录

2、文件路径（Path）

3、其他知识

二、Java 中操作文件

1、File概述

1.1属性

实例1：

实例2：

实例3：

Path路径问题

1. 在IDE中运行（如IntelliJ IDEA）

2. 在命令行中使用 java 命令运行

实例4：

实例5：

三、文件内容的读写⸺数据流

1、InputStream 概述

1.2说明

2、FileInputStream 概述

2.1构造方法

3、代码示例

5、OutputStream概述

5.1方法

try-with -resource

核心：

1. 基础写法

2. 多个资源（分号；分隔）

5、OutputStream概述

5.1方法

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

七、小程序练习

2. 在命令行中使用 `java` 命令运行