【Java EE初阶 --- 文件】文件操作和IO

optimistic_chen

发布于 2026-01-14 19:45:06

1000

前言

至此，以创建多线程到多线程安全就到此为止了。这篇博客将介绍计算机输入输出的相关知识，我任务这块内容主要以计算机硬件为主，如果要理解大部分IO，就要对计算机硬件有较为深刻的认识。

文件

狭义上，文件就是保存在硬件上的文件。广义上，文件是支持系统进行资源管理的一种机制，很多的软件硬件资源，都会被抽象为“文件”来进行表示。这里我们主要针对狭义中的文件来进行阐述。首先，先解释一下各种存储组件各自的优越性：

组件	速度	大小	价格
机械硬盘	几百MB每秒	几个T	200左右
固态硬盘	几个GB每秒	几个T	400左右
内存	比固态硬盘快上千倍	16\32GB	600左右
CPU寄存器	比内存快上千倍	1KB	不单卖，很贵

路径

一个计算机中，能保存超级多的文件，那么如何去查找一个文件？

通过路径：定位文件的一系列过程。从根目录（此电脑）开始,到锁查找文件的过程中，需要经过哪些目录，把这些目录以‘/’分割，这样记录下来的目录就形成了”路径“。

绝对路径：从根目录开始，逐级表示出来。相对路径：先明确一个”基准路径“，其中，”.“表示当前所在目录位置，”…“表示当前路径的上一层路径。

找test.txt文件 设基准：F::User\1 ( 当前路径) .\test.txt .表示在1路径下 设基准：F::User\1\Desktop (当前路径) . .\test.txt . .表示在1路径下

操作文件

站在开发角度上讲，文件分为文本文件和二进制文件。打开能看懂的是文本文件，看不懂的就是二进制文件了。 Java标准库中有一系列关于操作文件的类

File类中有很丰富的方法，我们用的时候只需要去操作手册查询即可。

文件流

以CPU为参考系，从硬盘到CPU是输入，从CPU到硬盘是输出

字节流

读写文件时，以字节为单位，针对二进制文件使用。 InputStream 输入 OutputStream 输出

文件资源必须要手动释放，否则会引起很多问题。为了解决释放文件资源问题，使用try(){}的方法

InputStream 输入

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

public class Demo24 {
    public static void main(String[] args) throws IOException {
        //InputStream inputStream=new FileInputStream("./test.txt");//先打开文件
        try(InputStream inputStream=new FileInputStream("./test.txt")){
            int n=inputStream.read();
            while(true) {
                if(n==-1){
                    break;
                }
                System.out.printf("%x\n",n);
            }
            inputStream.close();//只要出了try代码块，就会触发close
        }

    }
}

OutputStream 输出

与读文件向类似，写操作也有好几个方法。

写操作表示，如果这个文件不存在，那就创建这个文件，并写进去数据。注意，这里如果再次运行程序，会返发现只有一个abc,明明运行了两次程序，为什么只有一次结果，之前的数去哪了？其实，按照操作系统的规定，写操作打开文件，会清除上一次文件，为了避免这一情况，给写操作加一个参数，确定追加，避免内容被清空。

字符流

读写文件时，以字符为单位，针对文本文件使用。

Reader 输入

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class Demo26 {
    public static void main(String[] args) {
        try(Reader reader=new FileReader("E:\\test\\src\\test.txt")){
            while(true){
                //int a=reader.read();
                char[] buf=new char[1024];
                int a=reader.read(buf);
                if(a==-1){
                    break;
                }
                for (int i = 0; i < a; i++) {
                    System.out.println(buf[i]);//自动转码 字符流读到三个字节 utf8 得到汉字 unicode 返回char a
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Writer 输出

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

public interface Demo27 {
    public static void main(String[] args) {
        try(Writer writer=new FileWriter("./output.txt",true)){
            writer.write("hello");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

总结：

1. 流对象的使用：先打开，再读写，最后关闭 2. 先区分文件是文本还是二进制，再区分读写

案例

扫描指定目录，并找到名称中包含指定字符的所有普通文件，并询问用户是否要删除此文件。

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

public class Demo28 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入要搜索的目录：");
        String rootDir=scanner.next();
        File file=new File(rootDir);
        if(!file.isDirectory()){
            System.out.println("输入的不是目录");
            return ;
        }
        System.out.println("请输入要删除的关键字：");
        String keyWord=scanner.next();
        scanDir(file,keyWord);
    }

    //遍历目录
    private static void scanDir(File file,String keyWord){
        //列出当前目录中所包含内容
        File[] files=file.listFiles();
        if(files==null){
            //当前目录为空
            return;
        }
        for (File file1:files) {
            if(file1.isFile()){//是普通文件，则判断是否包含关键字
                dealFile(file1,keyWord);
            }else{//不是文件，那就是目录，递归调用该目录
                scanDir(file1,keyWord);
            }
        }
    }

    private static void dealFile(File file,String keyWord){
        if(file.getName().contains(keyWord)){
            System.out.println("发现文件"+file.getAbsolutePath()+",包含关键字!是否删除？Y|N");
            Scanner scanner=new Scanner(System.in);
            String input=scanner.next();
            if(input.equalsIgnoreCase("Y")){
                file.delete();
                System.out.println("文件已删除");
            }
        }
    }
}

复制文件

import java.io.*;
import java.util.Scanner;

public class Demo29 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入源文件路径");
        String srcPath= scanner.next();
        System.out.println("请输入目标文件路径");
        String destPath=scanner.next();
        File srcFile=new File(srcPath);
        if(!srcFile.isFile()){
            System.out.println("源文件不存在或者不是文件");
            return;
        }
        File destFile=new File(destPath);
        if(!destFile.getParentFile().isDirectory()){
            System.out.println("目标文件所在目录不存在");
            return;
        }
        try(InputStream inputStream=new FileInputStream(srcFile);
            OutputStream outputStream=new FileOutputStream(destFile)){
            while(true){
                byte[] b=new byte[1024];
                int n=inputStream.read(b);
                if(n==-1){
                    break;
                }
                outputStream.write(b,0,n);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}