Java EE初阶启程记15---文件操作和IO

🔥个人主页： 寻星探路

🎬作者简介：Java研发方向学习者

📖个人专栏： JAVA（SE）----如此简单从青铜到王者，就差这讲数据结构！！数据库那些事！！JavaEE 初阶启程记：跟我走不踩坑测试开发漫谈********

⭐️人生格言：没有人生来就会编程，但我生来倔强！！！

一、认识文件

1、树型结构组织和目录

2、文件路径（Path）

3、其他知识

[二、Java 中操作文件](#二、Java 中操作文件)

[1、InputStream 概述](#1、InputStream 概述)

1.1方法

1.2说明

[2、FileInputStream 概述](#2、FileInputStream 概述)

6、利用OutputStreamWriter进行字符写入

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

七、小程序练习

一、认识文件

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

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

1、树型结构组织和目录

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

2、文件路径（Path）

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

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

3、其他知识

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

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

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

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

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

二、Java 中操作文件

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

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

1、File概述

我们先来看看 File 类中的常见属性、构造方法和方法

1.1属性

1.2构造方法

1.3方法

2、代码示例

示例1

观察get系列的特点和差异

java 复制代码

import java.io.File;
import java.io.IOException;
public class Main {
   public static void main(String[] args) throws IOException {
        File file = new File("..\\hello-world.txt");        // 并不要求该⽂件真实存在       
        System.out.println(file.getParent());
        System.out.println(file.getName());
        System.out.println(file.getPath());
        System.out.println(file.getAbsolutePath());
        System.out.println(file.getCanonicalPath());
    }
}

运行结果

java 复制代码

 ..
 hello-world.txt
 ..\hello-world.txt
 D:\代码练习\⽂件⽰例1\..\hello-world.txt
 D:\代码练习\hello-world.txt

示例2

普通文件的创建、删除

java 复制代码

 import java.io.File;
 import java.io.IOException;
 public class Main {
     public static void main(String[] args) throws IOException {
         File file = new File("hello-world.txt");    
         System.out.println(file.exists());
         System.out.println(file.isDirectory());
         System.out.println(file.isFile());
         System.out.println(file.createNewFile());
         System.out.println(file.exists());
         System.out.println(file.isDirectory());
         System.out.println(file.isFile());
         System.out.println(file.createNewFile());
     }
 }

运行结果

java 复制代码

 false
 false
 false
 true
 true
 false
 true
 false

示例3

普通文件的删除

java 复制代码

 import java.io.File;
 import java.io.IOException;
 public class Main {
     public static void main(String[] args) throws IOException {
         File file = new File("some-file.txt");    
         System.out.println(file.exists());
         System.out.println(file.createNewFile());
         System.out.println(file.exists());
         System.out.println(file.delete());
         System.out.println(file.exists());    
     }
 }

运行结果

java 复制代码

 false
 true
 true
 true
 false

示例4

观察deleteOnExit的现象

java 复制代码

 import java.io.File;
 import java.io.IOException;
 public class Main {
     public static void main(String[] args) throws IOException {
         File file = new File("some-file.txt");        
         System.out.println(file.exists());
         System.out.println(file.createNewFile());
         System.out.println(file.exists());
         file.deleteOnExit();
         System.out.println(file.exists());
     }
 }

运行结果

java 复制代码

false
true
true
true

程序运行结束后，文件还是被删除了

示例5

观察目录的创建

java 复制代码

 import java.io.File;
 import java.io.IOException;
 public class Main {
     public static void main(String[] args) throws IOException {
         File dir = new File("some-dir");    
         System.out.println(dir.isDirectory());
         System.out.println(dir.isFile());
         System.out.println(dir.mkdir());
         System.out.println(dir.isDirectory());
         System.out.println(dir.isFile());    
     }
 }

运行结果

java 复制代码

 false
 false
 true
 true
 false

示例6

观察目录创建2

java 复制代码

 import java.io.File;
 import java.io.IOException;
 public class Main {
     public static void main(String[] args) throws IOException {
         File dir = new File("some-parent\\some-dir");
         System.out.println(dir.isDirectory());
         System.out.println(dir.isFile());
         System.out.println(dir.mkdir());
         System.out.println(dir.isDirectory());
         System.out.println(dir.isFile());        
     }
 }

运行结果

java 复制代码

 false
 false
 false
 false
 false

mkdir() 的时候，如果中间目录不存在，则无法创建成功；mkdirs()可以解决这个问题。

java 复制代码

 import java.io.File;
 import java.io.IOException;
 public class Main {
     public static void main(String[] args) throws IOException {
         File dir = new File("some-parent\\some-dir");  
         System.out.println(dir.isDirectory());
         System.out.println(dir.isFile());
         System.out.println(dir.mkdirs());
         System.out.println(dir.isDirectory());
         System.out.println(dir.isFile());      
     }
 }

运行结果

java 复制代码

 false
 false
 true
 true
 false

示例7

观察文件重命名

java 复制代码

 import java.io.File;
 import java.io.IOException;
 public class Main {
     public static void main(String[] args) throws IOException {
         File file = new File("some-file.txt");
         File dest = new File("dest.txt");   // 要求 dest.txt 不存在 
         System.out.println(file.exists());
         System.out.println(dest.exists());
         System.out.println(file.renameTo(dest));
         System.out.println(file.exists());
         System.out.println(dest.exists());        
     }
 }

运行结果

java 复制代码

 true
 false
 true
 false
 true

三、文件内容的读写⸺数据流

1、InputStream 概述

1.1方法

1.2说明

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

2、FileInputStream 概述

2.1构造方法

3、代码示例

示例1

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

java 复制代码

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

java 复制代码

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

java 复制代码

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

4、利用Scanner进行字符读取

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

示例1

java 复制代码

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

5、OutputStream概述

5.1方法

5.2说明

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

6、利用OutputStreamWriter进行字符写入

示例1

java 复制代码

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

java 复制代码

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

java 复制代码

 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', (byte)'B', (byte)'a'
            };
            os.write(b, 0, 4);
          
            // 不要忘记 flush 
            os.flush();
        }
    }
 }

java 复制代码

 import java.io.*;
 public class Main {
    public static void main(String[] args) throws IOException {
        try (OutputStream os = new FileOutputStream("output.txt")) {
                   String s = "Nothing";
            byte[] b = s.getBytes();
            os.write(b);
          
            // 不要忘记 flush 
            os.flush();
         }
     }
 }

java 复制代码

 import java.io.*;

 public class Main {
     public static void main(String[] args) throws IOException {
         try (OutputStream os = new FileOutputStream("output.txt")) {
             String s = "你好中国";
             byte[] b = s.getBytes("utf-8");
                 os.write(b);

             // 不要忘记 flush 
             os.flush();
         }
     }
 }

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

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

java 复制代码

 OutputStream os = ...;
 OutputStreamWriter osWriter = new OutputStreamWriter(os, "utf-8");        
 PrintWriter writer = new PrintWriter(osWriter);

 // 接下来我们就可以⽅便的使⽤ writer 提供的各种⽅法了 
 writer.print("Hello");
 writer.println("你好");
 writer.printf("%d: %s\n", 1, "没什么");

 // 不要忘记 flush 
 writer.flush();

示例1

java 复制代码

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

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

java 复制代码

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

public class Main {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输⼊要扫描的根⽬录（绝对路径 OR 相对路径): ");
        String rootDirPath = scanner.next();
        File rootDir = new File(rootDirPath);
        if (!rootDir.isDirectory()) {
            System.out.println("您输⼊的根⽬录不存在或者不是⽬录，退出");
            return;
        }

        System.out.print("请输⼊要找出的⽂件名中的字符: ");
        String token = scanner.next();
        List<File> result = new ArrayList<>();
        // 因为⽂件系统是树形结构，所以我们使⽤深度优先遍历（递归）完成遍历
        scanDir(rootDir, token, result);
        System.out.println("共找到了符合条件的⽂件 " + result.size() );
        for (File file : result) {
            System.out.println(file.getCanonicalPath() + "请问您是否要删除该⽂件");
            String in = scanner.next();
            if (in.toLowerCase().equals("y")) {
                file.delete();
            }
        }
    }

    private static void scanDir(File rootDir, String token, List<File> result) {
        File[] files = rootDir.listFiles();
        if (files == null || files.length == 0) {
            return;
        }

        for (File file : files) {
            if (file.isDirectory()) {
                scanDir(file, token, result);
            } else {
                if (file.getName().contains(token)) {
                    result.add(file.getAbsoluteFile());
                }
            }
        }
    }
 }

示例2

进行普通文件的复制

java 复制代码

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

public class Main {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输⼊要复制的⽂件（绝对路径 OR 相对路径): ");
        String sourcePath = scanner.next();
        File sourceFile = new File(sourcePath);
        if (!sourceFile.exists()) {
            System.out.println("⽂件不存在，请确认路径是否正确");
            return;
        }
        
        if (!sourceFile.isFile()) {
            System.out.println("⽂件不是普通⽂件，请确认路径是否正确");
            return;
        }

        System.out.print("请输⼊要复制到的⽬标路径（绝对路径 OR 相对路径): ");
        String destPath = scanner.next();
        File destFile = new File(destPath);
        if (destFile.exists()) {
            if (destFile.isDirectory()) {
                System.out.println("⽬标路径已经存在，并且是⼀个⽬录，请确认路径是否正确");
                return;
            }
            
            if (destFile.isFile()) {
                System.out.println("⽬录路径已经存在，是否要进⾏覆盖？y/n");
                String ans = scanner.next();
                if (!ans.toLowerCase().equals("y")) {
                    System.out.println("停⽌复制");
                    return;
                }
            }
        }
        
        try (InputStream is = new FileInputStream(sourceFile)) {
            try (OutputStream os = new FileOutputStream(destFile)) {
                byte[] buf = new byte[1024];
                int len;
                
                while (true) {
                    len = is.read(buf);
                    if (len == -1) {
                        break;
                    }
                    
                    os.write(buf, 0, len);
                }
                
                os.flush();
            }
        }
        System.out.println("复制已完成");
    }
 }

示例3

扫描指定目录，并找到名称或者内容中包含指定字符的所有普通文件（不包含目录）

#注：我们现在的方案性能较差，所以尽量不要在太复杂的目录下或者大文件下实验

java 复制代码

 import java.io.*;
 import java.util.*;
 public class Main {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输⼊要扫描的根⽬录（绝对路径 OR 相对路径): ");
        String rootDirPath = scanner.next();
        File rootDir = new File(rootDirPath);
        if (!rootDir.isDirectory()) {
            System.out.println("您输⼊的根⽬录不存在或者不是⽬录，退出");
            return;
        }
        System.out.print("请输⼊要找出的⽂件名中的字符: ");
        String token = scanner.next();
        List<File> result = new ArrayList<>();
        // 因为⽂件系统是树形结构，所以我们使⽤深度优先遍历（递归）完成遍历
 
        scanDirWithContent(rootDir, token, result);
        System.out.println("共找到了符合条件的⽂件 " + result.size());
        for (File file : result) {
            System.out.println(file.getCanonicalPath());
        }
    }
    private static void scanDirWithContent(File rootDir, String token, List<File
        File[] files = rootDir.listFiles();
        if (files == null || files.length == 0) {
            return;
        }
        for (File file : files) {
            if (file.isDirectory()) {
                scanDirWithContent(file, token, result);
           } else {
                if (isContentContains(file, token)) {
                    result.add(file.getAbsoluteFile());
                }
            }
        }
    }

    // 我们全部按照utf-8的字符⽂件来处理 
    private static boolean isContentContains(File file, String token) throws IOE
        StringBuilder sb = new StringBuilder();
        try (InputStream is = new FileInputStream(file)) {
            try (Scanner scanner = new Scanner(is, "UTF-8")) {
                while (scanner.hasNextLine()) {
                    sb.append(scanner.nextLine());
                    sb.append("\r\n");
                }
            }
        }
        
        return sb.indexOf(token) != -1;
    }
 }

代码参考

如何按字节进行数据读

java 复制代码

try (InputStream is = ...) {
    byte[] buf = new byte[1024];
    while (true) {
        int n = is.read(buf);
        if (n == -1) {
            break;
        }
        
        // buf 的 [0, n) 表⽰读到的数据，按业务进⾏处理 
    }
 }

如何按字节进行数据写

java 复制代码

try (OutputStream os = ...) {
    byte[] buf = new byte[1024];
    while (/* 还有未完成的业务数据 */) { 
        // 将业务数据填⼊ buf 中，⻓度为 n 
        int n = ...;
        os.write(buf, 0, n);
    }
    os.flush();        // 进⾏数据刷新操作
}

如何按字符进行数据读

java 复制代码

try (InputStream is = ...) {
    try (Scanner scanner = new Scanner(is, "UTF-8")) {
        while (scanner.hasNextLine()) {
            String line = scanner.nextLine();
            
            // 根据 line 做业务处理
 
        }
    }
 }

如何按字符进行数据写

java 复制代码

try (OutputStream os = ...) {
    try (OutputStreamWriter osWriter = new OutputStreamWriter(os, "UTF-8")) {
        try (PrintWriter writer = new PrintWriter(osWriter)) {
            while (/* 还有未完成的业务数据 */) { 
                writer.println(...);
            }
            writer.flush(); // 进⾏数据刷新操作 
        }
    }
 }