JavaEE 文件操作&IO

文件操作&IO

文章目录

文件操作&IO
- [1. 认识文件](#1. 认识文件)
- [2. 文件操作](#2. 文件操作)
- - [2.1 File 类](#2.1 File 类)
  - [2.2 文件读写](#2.2 文件读写)
  - - [2.2.1 FileInputStream](#2.2.1 FileInputStream)
    - [2.2.2 FileOutputStream](#2.2.2 FileOutputStream)
    - [2.2.3 FileReader](#2.2.3 FileReader)
    - [2.2.4 FileWriter](#2.2.4 FileWriter)
    - [2.2.5 Scanner读取文件](#2.2.5 Scanner读取文件)
  - [3. 案例练习](#3. 案例练习)
  - - [3.1 案例一](#3.1 案例一)
    - [3.2 案例二](#3.2 案例二)
    - [3.3 案例三](#3.3 案例三)

在进行文件操作之前，我们先简单了解一些文件的基本概念

1. 认识文件

对于计算机来说，文件是一个相对广义的概念，在硬盘上，我们可以将存储着一定数据的独立个体抽象为文件，同时，文件除了有数据内容之外，还有一部分信息，例如文件名、文件类型、文件大小等并不作为文件的数据而存在，我们把这部分信息称为文件的元信息。

同时，随着文件数量的增加，我们也需要对文件进行一定的组织管理, 对此，我们使用层级结构来对文件进行组织 ，也就是我们数据结构学习过的树型结构。

同时也诞生了一种用来存储管理文件信息的特殊文件--文件夹(folder) /目录(directory)。

注：这里提到的树不是"二叉树"，而是N叉树，每一个普通文件(非目录)就是叶子节点，一个目录文件中又可以有很多的子节点

在操作系统中，我们通过路径来定位我们的文件，并将路径分为以下两种：

绝对路径(absolute path) : 从树型结构的角度来看，树种的每个节点都可以被一条从根开始一直到目标文件节点的结束路径所描述，而这种描述方式就被称为绝对路径。
相对路径(relative path): 除了可以从根开始进行路径的描述，我们可以从任意节点出发，进行路径的描述，而这种描述方式就被称为相对路径，相当于当前所在节点的一条路径。

一般我们会将文件分为两类：文本文件 和二进制文件

文本文件：指代保存被字符集编码的文本
二进制文件：指代按照标志格式保存的非本字符集编码过的文件

对于我们来说，如何判定一个文件是文本文件还是二进制文件？

这里可以通过记事本来打开这个文件，打开后看到的如果是正常内容不是乱码就说明是文本文件，而如果是乱码就证明是二进制文件

了解了以上内容之后，我们就可以来进行文件操作了~

2. 文件操作

2.1 File 类

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

属性

修饰符及类型	属性	说明
static String	pathSeparator	依赖于系统的路径分隔符，String 类型的表示
static char	pathSeparator	依赖于系统的路径分隔符，char类型的表示

构造方法

签名	说明
File(File parent, String child)	根据父目录 + 孩子文件路径，创建⼀个新的 File 实例
File(String pathname)	根据文件路径创建⼀个新的 File 实例，路径可以是绝对路径或者相对路径
File(String parent, String child)	根据父目录 + 孩子文件路径，创建⼀个新的 File 实例，父目录用路径表示

方法

修饰符及返回值类型	方法签名	说明
String	getParent()	返回File对象的父目录文件路径
String	getName()	返回File对象的纯文件名称
String	getPath()	返回File对象的文件路径
String	getAbsolutePath()	返回File对象的绝对路径
String	getCanonicalPath()	返回File对象的修饰过的绝对路径
boolean	exists()	判断File对象描述的文件是否真实存在
boolean	isDirectory()	判断File对象代表的文件是否是一个目录
boolean	isFile()	判断File对象代表的文件是否是一个普通文件
boolean	createNewFile()	根据File对象，自动创建一个空文件。成功创建后返回true
boolean	delete()	根据File对象，删除该文件。成功删除后返回true
void	deleteOnExit()	根据File对象，标注文件将被删除，删除动作会到JVM运行结束时才会结束
String[]	list()	返回File对象代表的目录下的所有文件名
File[]	listFiles()	返回File对象代表的目录下的所有文件，以File对象表示
boolean	mkdir()	创建File对象代表的目录
boolean	mkdirs()	创建File对象代表的目录，如果必要，会创建中间目录
boolean	renameTo(Filedest)	进行文件改名，也可以视为我们平时的剪切、粘贴操作
boolean	canRead()	判断用户是否对文件有可读权限
boolean	canWrite()	判断用户是否对文件有可写权限

创建文件

java 复制代码

package demo1;

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

public class Test1 {
    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()); // 判断是否为目录
        System.out.println(file.createNewFile()); // 创建文件 文件不存在时自动创建并返回true

    }
}

删除文件

java 复制代码

package demo1;

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

public class Test1 {
    public static void main(String[] args) throws IOException {
        File file = new File("./test.txt");
        boolean ret = file.delete(); // 删除文件
        System.out.println(ret);
        /*file.deleteOnExit(); // 线程结束后再删除文件*/

    }
}

创建目录

java 复制代码

package demo1;

import java.io.File;

public class Test3 {
    public static void main(String[] args) {
        File f = new File("./aaa/bbb/ccc");
        boolean ret = f.mkdirs(); // 创建目录
        System.out.println(ret);
    }
}

2.2 文件读写

对于文件，我们一般有以下两种读取文件的文件流方式：

字节流: 每次读写的最小单位是一个字节；

代表类：InputStream 输入(读取文件)； OutputStream 输出(写入文件)；
字符流: 每次读写的最小单位是一个字符(一个字符可能有多个字节构成，同时字符流可以内部处理字符编码)；

代表类：Reader 输入； Writer 输出；

2.2.1 FileInputStream

这里我们引入FileInputStream 而不是前面提到的InputStream, 原因是InputStream只是一个抽象类 ，要使用还需要具体的实现类，在这里我们只需要从文件中进行读取 ，所有使用FileInputStream(字节流)

构造方法

签名	说明
FileInputStream(File file)	利用File构造文件输入流
FileInputStream(String name)	利用文件路径构造文件输入流

代码示例

java 复制代码

package demo2;

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

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

        try (InputStream inputStream = new FileInputStream("./test.txt")) {
            // 字节流读文件
            // 不知道文件有多少字节，用while来完成
            while(true) {
                byte[] buffer = new byte[1024]; // 缓冲区
                int n = inputStream.read(buffer); // 返回值为读取的字节数,并将读取的值存放到缓冲区中
                if (n == -1) {
                    break; // n = -1 表示字节已全部读取完毕
                }
                String s = new String(buffer, 0, n);
                System.out.println(s);
            }
        }catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
}

注：我们要认识到，读文件就是把硬盘数据读取到内存中，所以我们以内存为对象，使用"input"将数据从硬盘中输入给自己，反之，写文件用"output"就是将内存中的数据输出给硬盘对硬盘上的数据进行修改

2.2.2 FileOutputStream

OutputStream 同样只是一个抽象类，要使用还需要具体的实现类，这里我们使用FileOutputStream 来完成写入文件操作 (字节流)

构造方法

签名	说明
FileOutputStream(File file)	利用File构造文件输出流
FileOutputStream(String name, boolean append)	利用文件路径构造文件输出流, 传入参数true代表当前为追加模式

代码示例

java 复制代码

package demo2;

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

public class Test2 {
    public static void main(String[] args) {
        // 使用OutputStream写文件 true为追加模式
        try(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);
        }
    }
}

注：在构造方法中传入参数true代表当前为追加模式

2.2.3 FileReader

Reader是一个抽象类，要使用还需要具体的实现类，这里我们使用FileReader来完成读取文件操作 (字节流)

代码示例

java 复制代码

package demo2;

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

public class Test3 {
    public static void main(String[] args) {
        // 字符流读文件
        try (Reader reader = new FileReader("test.txt")) {
            while (true) {
                char[] buffer = new char[1024]; // 此处以char为单位进行操作
                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.2.4 FileWriter

Writer是一个抽象类，要使用还需要具体的实现类，这里我们使用FileWriter来完成写入文件操作 (字节流)

代码示例

java 复制代码

package demo2;

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

public class Test4 {
    public static void main(String[] args) {
        // 使用字符流修改文件
        try (Writer writer = new FileWriter("test.txt", true)) {
            String s = "\n你也好";
            writer.write(s);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

2.2.5 Scanner读取文件

Scanner 也可以辅助我们读取文件

代码示例

java 复制代码

package demo2;

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

public class Test5 {
    public static void main(String[] args) {
        try (InputStream inputStream = new FileInputStream("test.txt")) {
            Scanner scanner = new Scanner(inputStream);
            while (scanner.hasNext()) {
                String s = scanner.next(); // next无法读取空格
                System.out.println(s);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

3. 案例练习

3.1 案例一

扫描指定目录，并找到名称中包含指定字符的所有普通文件(不包含目录)

代码示例

java 复制代码

package demo3;

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

public class Test1 {
    public static void main(String[] args) {
        // 1. 输入必要的信息
        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("输入的路径有误");
            return;
        }

        // 2. 有了要搜索的路径之后，就可以按照 递归 的方式来搜索
        scanDir(rootFile, fileName);
    }

    private static void scanDir(File rootFile, String fileName) {
        // 1. 把当前目录中的文件和子目录都列出来
        File[] files = rootFile.listFiles();
        if (files == null) {
            // 空的目录，直接返回即可
            return;
        }
        // 2. 遍历上述files，判断每一个file是目录还是文件
        for (File f : files) {
            System.out.println("当前遍历到：" + f.getAbsolutePath());
            if (f.isFile()) {
                // 普通文件，判定文件名是否是搜索的文件
                if (fileName.equals(f.getName())) {
                    System.out.println("找到了符合要求的文件！" + f.getAbsolutePath());
                }
            }else if (f.isDirectory()) {
                // 目录文件，需要进一步递归
                scanDir(f, fileName);
            }
        }
    }
}

3.2 案例二

对普通文件进行复制

代码示例

java 复制代码

package demo3;

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

public class Test2 {
    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();

        // 合法性判定
        // 1 srcPath 对应的文件是否存在
        File srcFile = new File(srcPath);
        if (!srcFile.isFile()) {
            System.out.println("源文件路径有误！");
            return;
        }
        // 2 destPath 不要求对应的文件存在，但目录得存在
        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[] buffer = new byte[1024];
                int n = inputStream.read(buffer);
                if (n == -1) {
                    break;
                }
                // 把读到的内容写入到 outputStream 中
                outputStream.write(buffer, 0, n);
            }

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

3.3 案例三

扫描指定目录，并找到内容中包含指定字符的所有普通文件

代码示例

java 复制代码

package demo3;

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

public class Test3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要搜索的路径："); // 从哪个目录开始搜索
        String rootPath = scanner.next();
        System.out.println("请输入要查询的词：");
        String word = scanner.next();

        File rootFile = new File(rootPath);
        if (!rootFile.isDirectory()) {
            System.out.println("输入的要搜索的路径不正确！");
            return;
        }

        scanDir(rootFile, word);
    }

    private static void scanDir(File rootFile, String word) {
        File[] files = rootFile.listFiles();
        if (files == null) {
            return;
        }
        for (File f : files) {
            System.out.println("当前遍历到： " + f.getAbsolutePath());
            if (f.isFile()) {
                // 在文件内容中搜索
                searchInFile(f, word);
            }
            else if (f.isDirectory()) {
                scanDir(f, word);
            }
        }
    }

    private static void searchInFile(File f, String word) {
        // 通过这个方法在文件内部进行搜索
        // 1. 把文件内容都读取出来
        try (InputStream inputStream = new FileInputStream(f)) {
            StringBuilder stringBuilder = new StringBuilder();
            while (true) {
                byte[] buffer = new byte[1024];
                int n = inputStream.read(buffer);
                if (n == -1) {
                    break;
                }
                // 此处只是读取出文件的一部分，需要把文件内容整体拼接在一起
                String s = new String(buffer, 0, n);
                stringBuilder.append(s);
            }

            if (stringBuilder.indexOf(word) == -1) {
                // 没有找到要返回
                return;
            }
            System.out.println("找到了! " + word + "存在于" + f.getAbsolutePath());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}