文件 IO - 技术栈

[一. 文件](#一. 文件)

[1.1 文件的概念](#1.1 文件的概念)

[1.2 文件目录](#1.2 文件目录)

[1.3 文件路径](#1.3 文件路径)

[1.3.1 绝对路径](#1.3.1 绝对路径)

[1.3.2 相对路径](#1.3.2 相对路径)

[1.4 文件的类型](#1.4 文件的类型)

[二. IO](#二. IO)

[2.1 文件系统操作-- File类](#2.1 文件系统操作-- File类)

[2.1.1 File类的构造方法](#2.1.1 File类的构造方法)

[2.1.2 File类中的方法](#2.1.2 File类中的方法)

[2.2 文件内容操作](#2.2 文件内容操作)

[2.2.1 字节流](#2.2.1 字节流)

[2.2.1.1 InputStream中的方法](#2.2.1.1 InputStream中的方法)

[2.2.1.2 FileInputStream](#2.2.1.2 FileInputStream)

编辑

[2.2.1.3 outputStream中的方法](#2.2.1.3 outputStream中的方法)

[2.2.1.4 FileOutputStream](#2.2.1.4 FileOutputStream)

[2.2.2 字符流](#2.2.2 字符流)

[2.2.2.1 Reader 与 FileReader](#2.2.2.1 Reader 与 FileReader)

[2.2.2.2 Writer 与 FileWriter](#2.2.2.2 Writer 与 FileWriter)

[2.2.3 Scanner搭配 InputStream 使用](#2.2.3 Scanner搭配 InputStream 使用)

[2.2.4 PrintWriter 类](#2.2.4 PrintWriter 类)

一. 文件

1.1 文件的概念

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

1.2 文件目录

通过文件的目录我们可以很好的对大量文件进行分类与归纳

1.3 文件路径

所有的"路径"术语都是在描述某个文件/目录所在位置

对于Windows系统来说，路径是从盘符（C: / D: / E：）开始的

对于Linux系统来说，路径是从"根目录"开始（/）

1.3.1 绝对路径

从盘符开始的路径：绝对路径

例如：D:\code-java\CodeGalaxy\_2025_2_23 这样的路径就是绝对路径

1.3.2 相对路径

相对路径是我们更常用到的表示路径的方法，它通常需要指定一个基准目录，这样我们就可以从基准目录出发找到目标文件

就这个文件路径为例：D:\code-java\CodeGalaxy\_2025_2_23

假设我们定 D:\code-java 为基准目录，则目标文件路径为：.\CodeGalaxy\_2025_2_23

假设我们定 D:\code-java\CodeGalaxy 为基准目录，则目标文件路径: .\_2025_2_23

其中的 . 就表示基准目录

. . 表示当前目录（基准目录）的上一级

假设我们定 D:\code-java\CodeGalaxy 为基准目录，那么 . . 就表示 D:\code-java

上述的路径都是使用 \（反斜杠）作为目录之间的分隔符的，使用 /（正斜杠）也是可以的

并且我们在开发中，优先使用 / （正斜杠）---Windows系统两个都支持，Linux系统只支持/ (正斜杠)

1.4 文件的类型

一般我们对文件的分类是站在文件存储的内容角度分：

文本文件：内部存储的内容是"字符串"，每一个部分都是一个"字符"（字符集/字符编码）
二进制文件：没有限制，可以存任何数据

我们在操作文件时要先知道该文件是文本文件还是二进制文件，编写代码的操作是有区别的（操作文本文件可以用字符流，也可以用字节流，但是操作二进制文件只能用字节流 ）----怎么判断---简单粗暴的方法---直接用记事本打开该文件---如果是乱码，就是二进制文件---反之则是文本文件

二. IO

IO 是 input（输入）output（输出）的缩写，而输入和输出是站在计算机/CPU 的角度

2.1 文件系统操作-- File类

文件系统操作是指编写代码对文件进行创建，移动，复制，删除，查看目录等基础操作

在Java中对文件系统的操作进行了封装---- File 类

2.1.1 File类的构造方法

java 复制代码

public class Test {
    public static void main(String[] args) {
        File parentFile=new File("D:/Mytest");
        File file1=new File(parentFile,"eg1.txt");  //构造方法1

        File file2=new File("D:/Mytest/eg1.txt");  //构造方法2

        File file3=new File("D:/Mytest","eg1.txt"); //构造方法3
        
    }
}

File类既可以可以构建文件的对象，也可以构建目录的对象

上面的三个File类的实例对象指向的是同一个文件

创建一个File的实例对象可以用绝对路径，也可以用相对路径

2.1.2 File类中的方法

getAbsolutePath() 与 getCanonicalPath() 区别

java 复制代码

 File file=new File("./eg2");
        System.out.println(file.getAbsolutePath());
        System.out.println(file.getCanonicalPath());

直接用相对路径来构造文件对象时，如果是在idea中运行的该代码：其中的**.**代表的是基准目录--代码运行所在的工作目录（如果不是在idea运行就另当别论）

file.getAbsolutePath()获得的是该文件所在的绝对路径（实际上是把它的基准目录的绝对路径和构造File对象所传入的文件名的字符串的一个简单拼接）

而file.getCanonicalPath()获得的是修饰过的该文件所在的绝对路径

当我们在创建File类对象时，我们传入的文件/目录可以不存在，不存在不会影响创建对象--因为File有一个能力，它能创建新的文件/目录，但是在真正的 .creatnewFile()/.mkdir()//mkdirs之前，我们调用.exists() 还是会返回flase
我们在创建文件/目录时可能会失败--原因：1.硬盘满了 2. 没有权限
createNewFile() ：若构造File类对象时传入的文件已存在，直接返回 false ，不会覆盖或报错
mkdir()--创建单层目录 / mkdirs() --创建多层嵌套目录：若构造File类对象时传入目录已存在，同样返回 false ，不会修改已有目录。（如果在调用mkdirs()时若传入的目录有部分存在--跳过创建已有目录，直接创建不存在的目录）
renameTo（File dest）：在使用该方法时必须需要两个File类对象（源 source 从哪里来目标 dest 到哪里去），下面来展示一下它的几个作用 1.重命名

java 复制代码

        File source=new File("D:/Mytest/eg1.txt");
        File dest=new File("D:/Mytest/eg2.txt");
             source.renameTo(dest);

移动

java 复制代码

        File source=new File("D:/Mytest/eg2.txt");
        File dest=new File("D:/Mytest222/eg2.txt");
             source.renameTo(dest);

移动+重命名

java 复制代码

File source=new File("D:/Mytest222/eg2.txt");
        File dest=new File("D:/Mytest/eg1.txt");
             source.renameTo(dest);

delete（）与deletonExit（）区别

delete（）：直接删除从硬盘中删除，不是放进回收站

deletonExit（）：在JVM进程退出前才删除（方便操作临时文件）

2.2 文件内容操作

读：把文件内容获取出来

写：对文件内进行修改

对于上述读和写的操作，操作系统提供了相关的API函数，而Java对这些API进行了进一步的封装--一组类--流对象

而Java标准库中对此分出来两个的类别：字节流和字符流

2.2.1 字节流

字节流 : 读写时，以字节为基本单位

需要用到 InputStream（输入）和outputStream（输出）这两个抽象类，当然我们在进行具体的操作是用到它们的子类

2.2.1.1 InputStream中的方法

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

2.2.1.2 FileInputStream

FileInputStream 的构造方法

FileInputStream只能用来读文件

FileInputStream.read() 方法有三个方式：

1.int read（）：一次只读一个字节，如果还未读到文件末尾，返回的是读取的单个字节对应的 int 类型值，如果已经读到文件末尾，则返回 -1

java 复制代码

public class Test {
    public static void main(String[] args) throws IOException {
        
        File file=new File("D:/Mytest/eg1.txt");
        InputStream inputStream=new FileInputStream(file);//创建流对象的过程就相当于"打开文件"

        while (true){
           int n= inputStream.read();//打开完毕，就可以进行读操作
           if(n==-1){
               break;
           }
            System.out.printf("%x\n",n);
        }
        
    }
}

int read（byte [ ] b) : 一次读若干字节，一次性最多读满数组容量的字节数，如果还没读到文件末尾，返回的是本次读取到的实际字节数目，如果已经读到文件末尾，则返回 -1，其中的 byte [ ] b 是"输出型参数"，读取到的字节会放在该数组中。由于 byte [ ] b 后面没有指定读取字节所要放的位置，所以每一次读（调用read（））都会从下标为0的地方进行存放本次所读取到的字节（每一次读不会清空前一次读所存放在b数组的内容）

java 复制代码

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

        File file=new File("D:/Mytest/eg1.txt");
        InputStream inputStream=new FileInputStream(file);
        byte[] bytes=new byte[1024];
        while (true){
           int n=inputStream.read(bytes);
           if(n==-1){
               break;
           }
            for (int i = 0; i <n; i++) {
                System.out.printf("%x\n",bytes[i]);
            }
        }

    }
}

int read（byte [ ] b，int off ，int len) ：off 指定了每一次读取字节后存放到数组b的起始位置，len 指定了每一次预期读取的最大字节数

我们知道InputStream的核心操作：1.打开文件（创建流对象）2. 读文件(read) 3. 关闭文件（close），我们已经了解了前两个操作，现在我们来了解如何关闭文件--- close（）

关闭文件

特殊情况下，我们不用不必关闭文件：如果在进程中读取文件完毕后，立即退出--原因---进程退出整个PCB都释放了（操作系统内核释放的）

关闭文件有两种方式，一种是手动调用close（），另外更推荐的一种是使用 try with resources，使用这个就可以不用手动调 close（），代码如下：

java 复制代码

public class Test {
    public static void main(String[] args) {

        File file = new File("D:/Mytest/eg1.txt");
        try(  InputStream inputStream = new FileInputStream(file)){
            byte[] bytes = new byte[1024];
            while (true) {
                int n ;
                n = inputStream.read(bytes);

                if (n == -1) {
                    break;
                }
                for (int i = 0; i < n; i++) {
                    System.out.printf("%x\n", bytes[i]);
                }
            }

        }catch (IOException e){
            e.printStackTrace();
        }
    }

}

2.2.1.3 outputStream中的方法

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

2.2.1.4 FileOutputStream

FileOutputStream 的构造方法

FileOutputStream 只能用来写文件

FileOutputStream的 write（）有三种方式，如下所示

1.**void write（int b）**一次写一个字节

java 复制代码

public class Test {
    public static void main(String[] args) throws IOException {
        OutputStream outputStream=new FileOutputStream("D:/Mytest/eg1.txt");
        outputStream.write(65);  //文件写入 A
        
    }
}

**void（byte [ ] b）**一次写完整的字节数组，与读不同，写是一次性写完（所以不用使用while循环）

java 复制代码

public class Test {
    public static void main(String[] args) throws IOException {
        OutputStream outputStream=new FileOutputStream("D:/Mytest/eg1.txt");
        byte[] bytes=new byte[]{65,66,67,68,69,70};
        outputStream.write(bytes);  //文件写入ABCDEF

    }
}

**void（byte [ ] b，int off ，int len）**指定写入数组的一部分

java 复制代码

public class Test {
    public static void main(String[] args) throws IOException {
        OutputStream outputStream=new FileOutputStream("D:/Mytest/eg1.txt");
        byte[] bytes=new byte[]{65,66,67,68,69,70};
        outputStream.write(bytes,1,5); //在文件中写入BCDEF
    }
}

注意对于FileOutputStream写文件，每一次打开文件（new FileOutputStream的文件对象）都会先清除文件的全部内容，如果我们想从文件的末尾开始写而不清除原文件的内容（追加写）---在创建文件FileOutputStream对象时设置为true------如 OutputStream outputStream=new FileOutputStream("D:/Mytest/eg1.txt",true);

对于写的操作同样需要关闭文件---同样使用更简便的方式--- try with resources

java 复制代码

public class Test {
    public static void main(String[] args)  {
        try( OutputStream outputStream=new FileOutputStream("D:/Mytest/eg1.txt")){
            byte[] bytes=new byte[]{65,66,67,68,69,70};
            outputStream.write(bytes);

        }
        catch (IOException e){
            e.printStackTrace();
        }
        
    }
}

2.2.2 字符流

字符流 : 读写时，以字符为基本单位

需要用到 Reader**（输入）和 Writer（输出）这两个抽象类，当然我们在进行具体的操作是用到它们的子类（与字节流的写与读类似）**

2.2.2.1 Reader 与 FileReader

FileReader类是Reader抽象类的子类，只用于字符流的读操作

FileReader的 read（）的四种方式

和 FileInputStream.read( )的三个方法是类似的，只是它的第三个方式使用的 CharBuffer（是对char的高级封装）

java 复制代码

public class Test {
    public static void main(String[] args) throws IOException {
     try(Reader reader=new FileReader("D:/Mytest/eg1.txt")){
         while(true){

             int n=reader.read();

             if(n==-1){
                 break;
             }
             char c=(char)n;
             System.out.println(c);

         }

     }
        catch (IOException e){
         e.printStackTrace();
        }

    }
}

java 复制代码

public class Test {
    public static void main(String[] args) throws IOException {
     try(Reader reader=new FileReader("D:/Mytest/eg1.txt")){

         char[] chars=new char[1024];
         while(true){

             int n=reader.read(chars);

             if(n==-1){
                 break;
             }
             for (int i = 0; i <n; i++) {
                 System.out.println(chars[i]);
             }
         }

     }
        catch (IOException e){
         e.printStackTrace();
        }

    }
}

不管是字节流的读和写，还是字符流的读和写都要关闭文件

2.2.2.2 Writer 与 FileWriter

FileWriter类是Writer 抽象类的子类，只用于字符流的写操作

FileWriter的 write（）的五种方式

由于与字节流的操作基本类似，这里就不过多讲解了

java 复制代码

public class Test {
    public static void main(String[] args) throws IOException {
     try(Writer writer=new FileWriter("D:/Mytest/eg1.txt",true)){
         writer.write("abcdef");

     }
        catch (IOException e){
         e.printStackTrace();
        }

    }
}

2.2.3 Scanner搭配 InputStream 使用

我们平时使用 Scanner 是把控制台输入的内容读取到程序中，而一般传入的参数System.in中的 in 实际上是InputStream类型的

所以我们不仅能使用Scanner读取控制台输入的内容（Scanner的输入源本质是 InputStream），也能从构建成InputStream类型的文件对象中读取内容到程序中,然后我们就能通过Scanner提供的一系列针对性的读取方法---能够根据数据类型灵活解析InputStream中的内容

java 复制代码

public class Test {
    public static void main(String[] args) throws FileNotFoundException {

        InputStream inputStream=new FileInputStream("D:/Mytest/eg1.txt");
        Scanner sc=new Scanner(inputStream);
        while (sc.hasNext()){
            System.out.println(sc.nextInt());
        }

    }
}

2.2.4 PrintWriter 类

PrintWriter 类是writer 抽象类的间接子类，能够针对文件进行格式化的写入

PrintWriter 的 printf（）方法既可以输出/写入内容到控制台中，也可以写入到文件中，关键就在于实例化 PrintWriter 对象时传入的参数，如果是传入文件--就写入到文件中。如果是传入的System.out--就写入/输出到控制台中

java 复制代码

public class Test {
    public static void main(String[] args) throws FileNotFoundException {
    try(PrintWriter p=new PrintWriter("D:/Mytest/eg1.txt")){
       p.printf("%d+%d=%d",10,20,30);

   }catch (IOException e){
        e.printStackTrace();
    }

    }
}

文件中：

复制代码