Java的文件操作和IO

目录

一、认识文件

树型结构组织 和 目录

文件路径（Path）

其他知识

二、Java 中操作文件

File 概述

属性

构造方法

文件内容的读写 —— 数据流

InputStream 概述

FileInputStream 概述

构造方法

代码示例

利用 Scanner 进行字符读取

OutputStream 概述

方法

说明

利用 OutputStreamWriter 进行字符写入

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

三、小程序练习

示例1

---

一、认识文件

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

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

树型结构组织 和 目录

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

文件路径（Path）

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

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

其他知识

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

 

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

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

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

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

二、Java 中操作文件

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

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

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 实例，父目录用路径表示

文件内容的读写 —— 数据流

InputStream 概述

方法

修饰符及 返回值类 型	方法签名	说明
int	read()	读取一个字节的数据，返回 -1 代表已经完全读完了
int	read(byte[] b)	最多读取 b.length 字节的数据到 b 中，返回实际读到的数量；-1代表已经读完了
int	read(byte[] b, int off, int len)	最多读取 len - off 字节的数据到 b 中，放在从 off 开始，返回实际读到的数量；-1 代表以及读完了
void	close()	关闭字节流

说明

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

FileInputStream 概述

构造方法

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

代码示例

示例 1

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

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

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

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

利用 Scanner 进行字符读取

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

构造方法	说明
Scanner(InputStream is, String charset)	使用 charset 字符集进行 is 的扫描读取

示例1

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

OutputStream 概述

方法

修饰 符及 返回 值类 型	方法签名	说明
void	write(int b)	写入要给字节的数据
void	write(byte[] b)	将 b 这个字符数组中的数据全部写入 os 中
int	write(byte[] b, int off, int len)	将 b 这个字符数组中从 off 开始的数据写入 os 中，一共写 len 个
void	close()	关闭字节流
void	flush()	重要：我们知道 I/O 的速度是很慢的，所以，大多的 OutputStream 为了减少设备操作的次数，在写数据的时候都会将数据先暂时写入内存的 一个指定区域里，直到该区域满了或者其他指定条件时才真正将数据写入设备中，这个区域一般称为缓冲区。但造成一个结果，就是我们写的 数据，很可能会遗留一部分在缓冲区中。需要在最后或者合适的位置,调用 flush （刷新）操作，将数据刷到设备中。

说明

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

利用 OutputStreamWriter 进行字符写入

示例1

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

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

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

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

OutputStream os = ...;
OutputStreamWriter osWriter = new OutputStreamWriter(os, "utf-8"); // 告诉它，我
们的字符集编码是 utf-8 的
PrintWriter writer = new PrintWriter(osWriter);
// 接下来我们就可以方便的使用 writer 提供的各种方法了
writer.print("Hello");
writer.println("你好");
writer.printf("%d: %s\n", 1, "没什么");
// 不要忘记 flush
writer.flush();

 示例1

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

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

public class Exe01 {
    public static void main(String[] args) throws IOException {
        // 1. 接收用户输入的扫描路径
        System.out.println("请输入要扫描的路径(绝对路径):");
        Scanner scanner = new Scanner(System.in);
        String rootPath = scanner.next();
        // 2. 判断路径是否有效
        File root = new File(rootPath);
        // 2.1 路径是否存在
        if (!root.exists()) {
            System.out.println("路径不存在");
            return;
        }
        // 2.2 判断File是不是一个目录
        if (!root.isDirectory()) {
            System.out.println("指定的路径不是一个有效目录");
            return;
        }
        // 3. 接收关键字
        System.out.println("请输入关键字");
        String key = scanner.next();
        if (key == null || "".equals(key)) {
            System.out.println("关键字不能为为");
            return;
        }
        // 4. 扫描目录下的所有文件
        scan(root, key);
    }

    private static void scan(File root, String key) throws IOException {
        // 1. 先获取root下的所有文件，包括目录
        File[] files = root.listFiles();
        // 递归的终止条件
        if (files == null || files.length == 0) {
            return;
        }
        // 遍历数组中的每个文件
        for (int i = 0; i < files.length; i++) {
            // 取出每一个文件
            File tempFile = files[i];
            // 判断是文件还是目录
            if (tempFile.isFile()) {
                // 如果是文件，判断文件名中是否包含关键字
                String fileName = tempFile.getName();
                // 如果在文件名中找到关键字
                if (fileName.contains(key)) {
                    System.out.println("找到文件：" + tempFile.getCanonicalPath() + ", 是否删除(Y/N)");
                    // 接收用户的输入，根据输入判断是否删除
                    Scanner scanner = new Scanner(System.in);
                    String order = scanner.next();
                    // 删除操作
                    if (order.equalsIgnoreCase("y")) {
                        tempFile.delete();
                        System.out.println(tempFile.getCanonicalPath() + " 删除成功.");
                    }
                }
            } else {
                // 如果是目录则递归
                scan(tempFile, key);
            }
        }
    }
}

示例2

进行普通文件的复制

public class Ext02 {
    public static void main(String[] args) {
        // 1 . 接收用户输入的源文件路径
        System.out.println("请输入源文件路径(绝对路径)：");
        Scanner scanner = new Scanner(System.in);
        String sourcePath = scanner.next();
        // 2. 判断源文件路径是否有效
        File sourceFile = new File(sourcePath);
        // 2.1 文件是否存在
        if (!sourceFile.exists()) {
            System.out.println("源文件不存在");
            return;
        }
        // 2.2 判断是不是一个文件
        if (!sourceFile.isFile()) {
            System.out.println("源文件不是一个有效的文件");
            return;
        }
        // 3. 接收用户输入的目标文件路径
        System.out.println("请输入目标文件路径(绝对路径)");
        String destPath = scanner.next();
        File destFile = new File(destPath);
        // 3.1 判断目标文件是否存在
        if (destFile.exists()) {
            System.out.println("目标文件已存在");
            return;
        }
        // 3.2 判断目标文件的父目录是否存在
        if (!destFile.getParentFile().exists()) {
            System.out.println("目标文件的父目录不存在");
            return;
        }
        // 循环读取源文件的内容并写到目标文件中
        try (FileInputStream inputStream = new FileInputStream(sourceFile);
            FileOutputStream outputStream = new FileOutputStream(destFile)) {
            // 定义一个byte数组用来做为输出型参数，保存每次读到的文件内容
            byte [] bytes = new byte[1024];
            // 循环读取内容
            while (true) {
                int len = inputStream.read(bytes);
                if (len == -1) {
                    break;
                }
                // 写义目标文件
                outputStream.write(bytes);
                // 强制刷新缓冲区
                outputStream.flush();
            }
            System.out.println("复制成功");

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

    }
}

---