【JavaEE】——文件IO（万字长文）

阿华代码，不是逆风，就是我疯

你们的点赞收藏是我前进最大的动力！！

希望本文内容能够帮助到你！！

目录

一：认识文件

1：文件的概念

2：文件的结构

3：文件路径

（1）绝对路径

（2）相对路径

（3）举例

二：文件的分类

1：文本文件

2：二进制文件

3：如何判断文件的种类

三：Feil类对文件操作

1：Feil类

2：File类的构造方法

3：获取属性方法

代码示例一

代码示例二

 4：判断方法

 5：创建删除方法

6：创建移动方法

7：创建File对象代表的目录

8：文件改名操作

四：文件流

五：字节流

1：InputStream

（0）打开文件

（1）构造方法

（2）类/异常解析

（3）文件资源泄露

（4）：read方法

①引入

②三种参数代码示例

2：OutputStream

3：Scanner联动

​编辑

六：字符流

1：Reader类

2：Writer类 

 八：文件的搜索（重点）

 九：文件的复制

十：查询文本内容中包含“word”的文件

---

---

一：认识文件

1：文件的概念

对于计算机来说，“文件”是一个非常广义的概念，可以指普通的文件，文件夹，一些硬件设备也被抽象成了文件（例如：键盘，耳机，显示器，网卡等）

对于机械硬盘来说它更加擅长顺序读写，不擅长随机读写

比如有一个很大的文件，我们需要把这个文件整体复制一份就是顺序读写

某个目录中有很多的小文件，（数目比较多）需要把整个目录都拷贝一份，就是随机读写。

2：文件的结构

文件系统的结构是按照“树形结构”来组织文件的，是N叉树，一个普通文件（非目录）就是一个叶子节点，对一个目录文件来说，里面又可以有很多的子节点

3：文件路径

形如上述的图片，从树根节点，一级一级的往下走，直到直到目标文件，这个过程中经过的所有文件目录的名字串起来，使用正斜杠——“/”，或者反斜杠——“\”分割，就构成了“路径”

注：此过程并非是遍历树，可以想象成类似于Hash这样的结构

（1）绝对路径

从树根节点 出发，一层一层到达目标文件

（2）相对路径

先指定一个“当前目录”/“基准目录”，从当前目录出发，找到目标文件

（3）举例

二：文件的分类

1：文本文件

文本文件是按照“字符串”的形式来理解文本内容的（文本文件里面的二进制内容，也都表示为字符串，可以理解为——二进制内容都是合法的字符（像字符编码，英文字母用ASCII，汉字用utf8/gbk））

举例：.java   .c    .cpp   文本文档

2：二进制文件

二进制文件没有上述的限制，储存任何数据都可以。

举例：图片，音频，可执行程序，动态库，.class文件，富文本文件

富文本文件包括不限于：word  docx excle  xlsx  power point  pptx

3：如何判断文件的种类

使用记事本打开文本文件，如果看到的是乱码，就是二进制文件

三：Feil类对文件操作

引入：在Java中，对于文件操作的Api这里有两类

针对文件系统的操作：创建，删除，重命名，

针对文件内容的操作：读文件，写文件

1：Feil类

2：File类的构造方法

3：获取属性方法

代码示例一

构造File用绝对路径

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


public class IO1 {
    public static void main(String[] args) throws IOException {
        File f = new File("C:/User/1/test.txt");//绝对路径
        //File f = new File("./test.txt");
        System.out.println(f.exists());//判断文件目录是否存在
        System.out.println(f.getParent());
        System.out.println(f.getName());//返回file对象的名称
        System.out.println(f.getPath());//返回file对象的文件路径
        System.out.println(f.getAbsolutePath());//返回绝对路径
        System.out.println(f.getCanonicalPath());//返回对象修饰过后的路径canonical规范的
    }

}

代码示例二

构造对象用相对路径

.getPath()得到的就是构造方法中的参数

Canonical（读音：克挠你扣）规范的——可以理解为化简路径

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-01
 * Time: 19:28
 */
public class IO1 {
    public static void main(String[] args) throws IOException {
        //File f = new File("C:/User/1/test.txt");//绝对路径
        File f = new File("./test.txt");
        System.out.println(f.exists());//判断文件目录是否存在
        System.out.println(f.getParent());//返回父目录文件路径
        System.out.println(f.getName());//返回file对象的名称
        System.out.println(f.getPath());//返回file对象的文件路径
        System.out.println(f.getAbsolutePath());//返回绝对路径
        System.out.println(f.getCanonicalPath());//返回对象修饰过后的路径canonical规范的
    }

}

 4：判断方法

我们可以使用file.createNewFile（如下代码），也可以直接手动在当前目录创建一个File文件——名字叫test.txt

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


public class IODemon2 {
    public static void main(String[] args) throws IOException {
        File file = new File("./test.txt");
        System.out.println(file.exists());//文件存在吗
        System.out.println(file.isFile());//是普通文件嘛
        System.out.println(file.isDirectory());//是目录吗
        boolean ret = file.createNewFile();//创建文件；返回的结果就是创建成功和创建失败
        System.out.println("ret:" + ret);
    }


}

 5：创建删除方法

file.delete删除文件，返回值类型为boolean类型

file.deleteNewFile退出时删除文件，返回值为void

注：删除目录只能一级一级的删除

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-01
 * Time: 20:17
 */
public class IODemon3 {
    public static void main(String[] args) throws IOException, InterruptedException {
        File file = new File("./test.txt");
        //boolean ret = file.delete();//删除文件
        //System.out.println(ret);
        boolean ret = file.createNewFile();//创建文件

        file.deleteOnExit();//返回值为void类型，退出的时候删除文件，测试的时候注意看左边的目录栏
        Thread.sleep(5000);



    }


}

6：创建移动方法

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-01
 * Time: 20:44
 */
public class IODemon4 {
    public static void main(String[] args) {
        File file = new File(".");
        //返回的是对象代表的目录下所有的文件
        //返回的是一个String[]类型的数组
        String[] files = file.list();
        System.out.println(Arrays.toString(files));

        //返回的file对象代表的目录下所有的文件，不过是以file对象表示
        File[] files2 = file.listFiles();
        System.out.println(Arrays.toString(files2));
    }
}

7：创建File对象代表的目录

import java.io.File;
import java.lang.reflect.Field;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-01
 * Time: 20:58
 */
public class IODemon5 {
    public static void main(String[] args) {
       /* File file = new File("./aaa");//创建file为对象的目录
        boolean ret = file.mkdir();
        System.out.println(ret);*/

       /* File file = new File("./bbb");
        boolean ret2 = file.mkdirs();//mkdirs（可以用于创建单个目录，也可以用于创建多级目录）
        System.out.println(ret2);*/

         /*File file = new File("./aaa/bbb/ccc");
        boolean ret2 = file.mkdirs();//mkdirs（可以用于创建单个目录，也可以用于创建多级目录）
        System.out.println(ret2);*/

        File file = new File("./bbb");
        boolean ret = file.delete();//删除只能一级目录一级目录的删
        System.out.println(ret);


    }
}

8：文件改名操作

注意细节：file1文件改名为file2对象

import java.io.File;


public class IODemon6 {
    public static void main(String[] args) {
        File file1 = new File("./aaa/bbb/ccc/bbb");
        File file2 = new File("./bbb");
        boolean ret = file2.renameTo(file1);//把bbb这个文件移入"./aaa/bbb/ccc"的/ccc下
        System.out.println(ret);
    }

}

四：文件流

什么是文件流呢？

举个例子：要写100字节的内容，我们可以分10次写每次写10字节的内容，也可以分5次来写，每次写20字节的内容;当然也可以一次性写完

“流”是操作系统提供的概念，Java标准库中对于“进行了”封装，提供了一组类来负责这些工作

我们把这些类主要分为两种：字节流和字符流

五：字节流

代表类：InputStream——输入流，OutPutStream——输出流

1：InputStream

（0）打开文件

按照读文件的方式打开一个文件

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-02
 * Time: 11:46
 */
public class IODemon7 {
    public static void main(String[] args) throws IOException {
        /*
        //打开文件
        InputStream inputStream = new FileInputStream("./test.txt");
        //在中间一定会涉及一些对文件的操作之类的，如果遇到bug或者像return之类的不可控的操作，close操作可能就会执行不到了
        //打开了文件最后还要关掉，打开文件操作会抛出FileNotFoundException异常
        inputStream.close();
        //关闭文件会抛出IOException异常，前后两者为父类子类的关系
        */

        /*
        //第二种写法
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream("./test.txt");
        }finally{
            inputStream.close();
        }
        */
        
        
        /*
        //第三种写法，try with resources版本
        try (InputStream inputStreeam = new FileInputStream("./test.txt")){
            //出了try{}代码块范围后，编译器会自动调用.close方法关闭文件
            //FileInputStream继承于InputStream，InputStream又实现了Closeable接口，必须实现了Closeable接口才可以被放到try（）里面
        }
        */
        
        
        

    }



}

（1）构造方法

注：你给cpu送的信息叫输入，比如读操作。cpu给存储器等这些硬件设备送的信息叫做输出，比如写操作

（2）类/异常解析

（3）文件资源泄露

如果不执行文件关闭.close方法，就会有大问题。这里本质上是释放了文件的相关资源（PCB文件描述符表，不懂得铁子可以看前面写过的文章）这个表本质是一个数组或者顺序表，每打开一个文件，就会占据一个位置，如果不关闭一直打开就会导致表被耗尽，后续再想打开就会报错。

那么提问，文件描述符表不会动态扩容吗？对操作系统的内核来说，需要很高的性能，付出的代价太大了，容易造成系统的卡顿

（4）：read方法

①引入

read读文件就是把硬盘数据读取到内存当中buffer，译为缓冲区

注意点①：offset此处缩写了

注意点②：传入的数组，在方法内部对数组内容修改过后，方法外部也能生效

注意点③：字符流读取文件的时候，

②三种参数代码示例

①*不带参数的读，一个一个字符的读

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-02
 * Time: 12:18
 */
public class IOStream8 {
    public static void main(String[] args) throws IOException {
        try(InputStream inputStream = new FileInputStream("./test.txt")){
            //读取操作,读到-1的时候就会停止
            while(true){
                int a = inputStream.read();
                if (a == -1){
                    break;
                }
                System.out.print(a + " ");//读取的abcdef是ascii码值
            }
        }
    }
}

②*带入数组参数的读取，一次读取多个字符

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-02
 * Time: 12:56
 */
public class IODemon9 {
    public static void main(String[] args) throws IOException {
        try(InputStream inputStream = new FileInputStream("./test.txt")){

            while (true){
                //也可以一次读若干个字节,buffer(缓冲区)
                byte[] buffer = new byte[1024];//读的时候会尝试把buffer[1024]填满
                int n = inputStream.read(buffer);//传入的参数是buffer数组，方法内部对数组内容进行修改后，方法外部也能生效，实际上填不满1024个字节，
                if (n == -1){
                    break;//读取到最后一个字符，就break
                }
                for (int i = 0; i < n; i++) {
                    System.out.printf(" %x " ,buffer[i]);//遍历数组，并打印
                }

            }
        }
    }
}

③*构造String从0读到n（利用offset）

offset翻译为抵消补偿

注意看while循环：什么是文件流，假设我们要读取的文件很大，在这个循环中，每次尽可能读取1024个字节（可能读到的字节数比这个要小），这次读不完，我们就先用String给存起来（0到n），下一次while循环就接着读，“特别像字符串拼接   ”

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-02
 * Time: 13:22
 */
public class IODemon10 {
    public static void main(String[] args) throws IOException {
        try(InputStream inputStream = new FileInputStream("./test.txt")){
            while (true){
                //也可以一次读若干个字节,buffer(缓冲区)
                byte[] buffer = new byte[1024];//读的时候会尝试把buffer[1024]填满
                int n = inputStream.read(buffer);//传入的参数是buffer数组，方法内部对数组内容进行修改后，方法外部也能生效
                if (n == -1){
                    break;
                }
                String string = new String(buffer , 0 , n);//构造一个String对象，数组前n个字节来构造

                    System.out.printf(string);//遍历数组，并打印
            }
        }
    }
}

2：OutputStream

按照写的方式打开文件

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-05
 * Time: 12:06
 */
public class IODemo11 {
    public static void main(String[] args) throws FileNotFoundException {
        try{
            //打开操作会把原有文件中的内容清空，所以罪魁祸首不是Write操作而是打开操作
            OutputStream outputStream = new FileOutputStream("./test.txt");
            //OutputStream outputStream = new FileOutputStream("./test.txt",true);追加写
            byte[] buffer = new byte[]{97,98,99,100,101};
            outputStream.write(buffer);

        }catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

3：Scanner联动

Scanner（System.in）中System.in本质就是一个InputStream

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-05
 * Time: 13:21
 */
public class IODemo14 {
    public static void main(String[] args) throws FileNotFoundException {
        try(InputStream inputStream = new FileInputStream("./test.txt")){
            Scanner scanner = new Scanner(inputStream);
            while(scanner.hasNext()){
                String s = scanner.next();
                System.out.println(s);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
}

六：字符流

以字符为单位进行读写，例如：用utf8表示汉字，3个字节就是一个汉字，每次读写都得以3个字节为单位来进行读写，不能一次读半个汉字

在用char类型的数组存储汉字时是把3个字节组成的utf8汉字转化为了Unicode，输出为String类型时在把Unicode转化为字节

代表类：Reader——输入，Writer——输出

1：Reader类

代码示例

把byte换为char测试一下，区别在于打印汉字

import java.io.*;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-05
 * Time: 12:33
 */
public class IODemo12 {
    public static void main(String[] args) {
        try{
            //Reader和Writer的字符流与OutputStream和InputStream相似
            Reader reader= new FileReader("./test.txt");
            while(true){
                char[] buffer = new char[1024];
                int n = reader.read(buffer);
                if (n == -1){
                    break;
                }
                String s = new String(buffer , 0 , n);
                System.out.println(s);
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
         }
    }
}

如果文件中有内容换行操作了，那么有可能会有一些内容打印不到

2：Writer类 

记住：要把文件打开操作放到try（）的括号里，要不然不会默认执行close关闭文件操作

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-05
 * Time: 13:07
 */
public class IODemo13 {
    public static void main(String[] args) {
        try(Writer writer = new FileWriter("./test.txt",true)) {

            String s = "可选择续写操作 或者 清空在写操作";
            writer.write(s);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

 八：文件的搜索（重点）

import java.io.File;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-05
 * Time: 13:42
 */
public class IODemon15 {
    //用代码实现，查询文件这样一个功能
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你要查询的文件名");
        String fileName = scanner.next();
        System.out.println("请输入查询的目录");
        String rootPath = scanner.next();
        //这一步卡住了，创建一个文件对象
        File rootFile = new File(rootPath);
        //如果当前搜索的目录是一个文件或者是一个空目录那么报错
        if (!rootFile.isDirectory()){
            System.out.println("当前的输入有误");
        }
        //3：参数rootFile是搜索起始的文件，fileName是要找的文件
        scnnDic(rootFile,fileName);


    }
    private static void scnnDic(File rootFile , String fileName){
        //1:把当前文件的子目录全都列出来
        File[] files = rootFile.listFiles();
        //2:如果当前文件为空则返回
        if(files == null){
            return;
        }
        //3：不为空则遍历当前文件，看该文件下有哪些文件
        for(File file : files){
            System.out.println("当前遍历到的目录是："+file.getAbsolutePath());
            if (file.isFile()){
                if (file.getName().equals(fileName)){
                    System.out.println("找到了符合要求的文件" + file.getAbsolutePath());

                }
            }else if (file.isDirectory()){
                scnnDic(file,fileName);
            }else{
                //这里暂时不用写什么东西
            }
        }

    }

}

 

 

 九：文件的复制

用到了InputStream和OutputStream打开文件的方式

下述复制是二进制复制，可以复制任何照片和文件

import java.io.*;
import java.nio.file.Files;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-05
 * Time: 16:10
 */
public class IODemo16 {
    //复制一个源文件
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你要复制的源文件的所在路径");
        String scrPath = scanner.next();
        System.out.println("请输入复制后的文件目标所在的路径");
        String desPath = scanner.next();

        //1：判断源文件是否存在
        File scrFile = new File(scrPath);
        if (!scrFile.exists()){
            System.out.println("你要找的源文件不存在");
        }
        /*
        * 目标文件的父目录存在即可*/
        File desFile = new File(desPath);
        if (!desFile.getParentFile().exists()){
            System.out.println("目标路径有误");
        }

        /*
        * 分别以读、写的方式打开文件*/
        try(InputStream inputStream = Files.newInputStream(scrFile.toPath());
            OutputStream outputStream = new FileOutputStream(desFile)){
            while(true){
                byte[] buffer = new byte[1024];
                int n = inputStream.read(buffer);
                if (n == -1){
                    break;
                }
                outputStream.write(buffer,0,n);
            }


        } catch (IOException e) {
            throw new RuntimeException(e);
        }


    }
}

十：查询文本内容中包含“word”的文件

在指定文件下查询，包含输入的关键字（word）的文件所在的路径，并打印路径

import jdk.internal.util.xml.impl.Input;

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-10-05
 * Time: 18:47
 */
public class IODemo17 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入在哪个文件下查询（输入路径）");
        String rootPath = scanner.next();
        System.out.println("请输入你要查询的关键字word（查哪些文件中内容包含关键字word）");
        String word = scanner.next();

        //构造文件对象
        File file = new File(rootPath);

        //判断该文件对象是否是一个目录
        if (!file.isDirectory()){
            System.out.println("输入的路径有误");
            return;
        }
        //是一个目录在这个目录中在进行查找//scan扫描
        scanDir(file,word);
    }

    private static void scanDir(File file , String word){
        File[] files = file.listFiles();
        //files数组为null返回，说明递归到最深最里面的文件了
        if (files == null){
            return;
        }
        //遍历该文件中所包含的所有文件
        for(File f : files){
            if (f.isFile()){
                //写一个方法，来判断这个f文件内容中是否包含关键字word
                searchInFile(f,word);
            }else if (f.isDirectory()){
                //继续往下递归
                scanDir(f,word);
            }else {
                //不用写
            }
        }
    }

    private static void searchInFile(File f , String word){
        //用读的方式打开文件
        // 用文件构造的输入流读操作
        try(InputStream inputStream = new FileInputStream(f)){
            StringBuffer stringBuffer = new StringBuffer();
            while(true){
                //一次读取多个字节
                byte[] buffer = new byte[1024];
                int n = inputStream.read(buffer);//读到的放到数组，n为字节数量
                if (n == -1){
                    //说明文件内容读完了,那就跳出循环，非return
                    break;
                }
                //用String字符串接收一下
                String s = new String(buffer , 0 , n);
                //如果一次读不完，我们就用字符串进行拼接
                stringBuffer.append(s);
            }
            if (stringBuffer.indexOf(word) == -1){
                //返回-1的话就是没匹配到这个word关键字
                return;
            }
            //没返回-1就说明在这个文件内容中找到匹配上了word
            System.out.println("找到了，所含" + word + "的文件路径是" + f.getAbsolutePath());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}