Java——文件操作IO

汪汪miao~

已于 2024-03-29 22:40:51 修改

阅读量145

点赞数

分类专栏： JavaEE 文章标签： java IO

于 2023-09-18 16:30:01 首次发布

本文链接：https://blog.csdn.net/qq_45559559/article/details/131205239

版权

JavaEE 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1. 文件的概念

1.1 文件的定义：一个个独立的数据单位

狭义的文件：
指硬盘上的文件和目录。

广义的文件：
泛指计算机中的很多软硬件资源。

Java中的文件:
对于硬盘这种持久化存储的I/O设备，当进行数据保存时，往往不是保存成一个整体，而是独立成一个个的单位进行保存，这个独立的单位就被抽象成文件的概念，就类似办公桌上的一份份真实的文件一般。

操作系统中把很多软硬件资源都抽象成了文件，按照文件得形式统一管理。

1.2 文件的构成：数据+元信息

文件中有数据内容，还有一部分文件属性信息，例如文件名、文件类型、文件大小等，并不作为文件中的数据而存在，我们把这部分信息可以视为文件的元信息。
在这里插入图片描述

1.3 文件的组织方式——目录

按照层级结构（树形结构）进行组织，形成了文件夹或者目录。
这是一种专门用来存放管理文件元信息的特殊文件。
在这里插入图片描述

1.4 文件的路径

每个文件在硬盘上都有一个具体的“路径”，可以使用 / 来分隔不同的目录级别。
有两种路径表示风格：

绝对路径
树中的每个结点都可以被一条从根开始，一直到达的结点的路径所描述，这种描述方式就被称为文件的绝对路径。
相对路径
从任意结点出发，进行路径的描述，这种描述方式就被称为相对路径（relative path），相对于当前所在结点的一条路径。

1.5 文件的类型

文本文件：
经过字符集编码的文本，存的是文本，字符串。由字符串构成，每个字符串都是通过一个数组表示。

二进制文件：
按照标准格式保存的没有被字符集编码过的文件，存的是二进制数据，不一定是字符串，存储内容没有限制，可以存储任何数据。

（了解：）

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

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

2. File类

Java 中通过 java.io.File 类来对一个文件包括目录进行抽象的描述。

有 File 对象并不代表真实存在该文件。

2.1 File类的属性

parent：表示当前文件所在的目录。
child：自身的文件名
在这里插入图片描述

2.2 构造方法

在这里插入图片描述

2.3 常用方法：

在这里插入图片描述

2.4 案例综合

2.4.1 观察 get 系列的特点和差异

// 观察 get 系列的特点和差异

public class IODemo1 {
    public static void main(String[] args) throws IOException {
        File file = new File("./test.txt");
        System.out.println(file.getName()); // File对象的纯文件名称
        System.out.println(file.getParent()); // File对象的父文件路径
        System.out.println(file.getPath()); // File对象的文件路径
        System.out.println(file.getAbsolutePath()); // File对象的绝对路径
        System.out.println(file.getCanonicalPath()); // File对象修饰过的绝对路径
    }
}


------------------------------------------------
// 运行结果
test.txt   // File对象的纯文件名称
.			// File对象的父文件路径
.\test.txt		// File对象的文件路径
D:\code\test_java\java-0628-1\.\test.txt  // File对象的绝对路径
D:\code\test_java\java-0628-1\test.txt   // File对象修饰过的绝对路径

Process finished with exit code 0

2.4.2 普通文件的创建、删除


 // 普通文件的创建、删除

 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());		// 判断File对象描述的文件是否真实存在 false
        System.out.println(file.isDirectory());		// 判断File对象代表的文件是否是一个目录 false
        System.out.println(file.isFile());		// 判断File对象代表的文件是否是一个普通文件  false
        System.out.println(file.createNewFile());		// 根据File对象创建一个空文件，成功后返回true   true
        System.out.println(file.exists());   true
        System.out.println(file.isDirectory());  false
        System.out.println(file.isFile());  true
        System.out.println(file.createNewFile());  // 已经存在了，创建失败
    }
}

--------------------------------------------------------------------------

false
false
false
true
true
false
true
false

2.4.3 普通文件的删除

  
  // 普通文件的删除
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());   // false
        System.out.println(file.createNewFile());   // true
        System.out.println(file.exists());   // true
        System.out.println(file.delete());  // 根据File对象删除该文件，成功后返回true    true
        System.out.println(file.exists());   // false  文件已删除不存在（但是这个File对象依然存在）
    }
 }

-----------------------------------------------
false
true
true
true
false

### 2.4.4 观察 deleteOnExit 的现象
 // 观察 deleteOnExit 的现象
 
  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());  // false
        System.out.println(file.createNewFile());		// true
        System.out.println(file.exists());		// true
        file.deleteOnExit();		// 根据File对象，标注文件将被删除，删除动作在JVM运行结束时才会进行
        System.out.println(file.exists());  // true  此时JVM还在运行
    }
}


-------------------------------------------------------------
// 运行结果
false
true
true
true

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

2.4.5 观察目录的创建

 
 // 观察目录的创建
 
 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()); // false
        System.out.println(dir.isFile()); // false
        System.out.println(dir.mkdir());  // 创建File对象代表的目录，成功后返回true    true
        System.out.println(dir.isDirectory()); // true
        System.out.println(dir.isFile());   // false
    }
}

------------------------------------------------------------------

// 运行结果
false
false
true
true
false

2.4.6 观察目录创建2

  //观察目录创建2

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");   // some-parent 和 some-
dir 都不存在
        System.out.println(dir.isDirectory()); // false
        System.out.println(dir.isFile());	// fasle
        System.out.println(dir.mkdir());  // 创建File对象代表的目录，但是不会创建中间目录
        System.out.println(dir.isDirectory()); // false
        System.out.println(dir.isFile());  // false
    }
}

--------------------------------------------------------
// 运行结果
false
false
false
false
false


*************************************************************

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

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");   // some-parent 和 some-
dir 都不存在
        System.out.println(dir.isDirectory());  // false
        System.out.println(dir.isFile());   // false
        System.out.println(dir.mkdirs());  // 创建File对象代表的目录，会创建中间目录
        System.out.println(dir.isDirectory());  // false
        System.out.println(dir.isFile());  // fasle
    }
}

----------------------------------------------------------------
// 运行结果

false
false
true
true
false

2.4.7 观察文件重命名


// 观察文件重命名
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");  // 要求 some-file.txt 得存在，可以是普通文件，可以是目录
        File dest = new File("dest.txt");   // 要求 dest.txt 不存在
        System.out.println(file.exists());  // true
        System.out.println(dest.exists());  // false
        System.out.println(file.renameTo(dest)); // 进行文件改名,成功后返回true
        System.out.println(file.exists()); // true
        System.out.println(dest.exists()); // true
    }
}

-----------------------------------------------------------------
// 运行结果
true
false
true
false
true

3. 字节流

Java用流实现了输入与输出操作，并提供了统一的接口，使程序设计更为简单。

在这里插入图片描述

输入还是输出是相对于内存的。
把数据读到内存中称为输入，即input，进行数据的read操作。
从内存往外部设备写数据，称为输出，即output，即数据的write操作。

3.1 读取文件——InputStream 类

InputStream 只是一个抽象类，要使用还需要具体的实现类，InputStream 的实现类有很多，我们只关心从文件中读取所以使用FileInputStream类。

3.1.2 FileInputStream

3.1.2.1 常用方法

在这里插入图片描述

3.1.2.2 构造方法

在这里插入图片描述

3.1.2.1 按字节进行数据读

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

3.1.2.2 按字符进行数据读

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

3.1.2.3 代码案例

读取文件

 // 方式一：
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(); // 一次最多读取8个byte
                if (b == -1) { // 代表文件已经全部读完
                    break;
                }  
                System.out.printf("%c", b);
            }
        }
    }
}


// 方式二：

// 相比较而言，这一种的 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")) {
            byte[] buf = new byte[1024];
            int len;
            
            while (true) {
                len = is.read(buf); // 一次最多读取1024个byte放在字节数组buf中，返回的是读取到byte的个数
                if (len == -1) {
                    // 代表文件已经全部读完
                    break;
                }
                
                for (int i = 0; i < len; i++) {
                    System.out.printf("%c", buf[i]);
                }
            }
        }
    }
}

这里我们把文件内容中填充中文看看，注意，写中文的时候使用 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);
                }
            }
        }
    }
}

3.1.2.4 利用 Scanner 进行字符读取

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

// 示例：
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")) { // 创建一个FileInputStream对象
           try (Scanner scanner = new Scanner(is, "UTF-8")) { // 用Scanner类对象对FileInputStream对象进行读取
               while (scanner.hasNext()) {
                   String s = scanner.next();
                   System.out.print(s);
               }
           }
        }
    }
}

3.2 输出文件——OutputStream 类

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

3.2.1 OutputStreamWriter

3.2.1.1 常用方法

在这里插入图片描述

3.2.1.2 代码示例

// 示例一：
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();
        }
    }
}

// 示例三：
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', (byte)'d'
            };
            os.write(b, 0, 4);
          
            // 不要忘记 flush
            os.flush();
        }
    }
}

// 示例四：
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();
        }
    }
}

// 示例五：
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();
        }
    }
}

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

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

3.2.1.4 按字符进行数据写

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

3.2.1.5 按字节进行数据写

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

4. 小程序练习

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

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

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() + " 请问您是否要删除该文件？y/n");
            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());
                }
            }
        }
    }
}

进行普通文件的复制

// 示例：进行普通文件的复制
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("复制已完成");
    }
}

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

// 示例：扫描指定目录，并找到名称或者内容中包含指定字符的所有普通文件（不包含目录）。
// 注意：我们现在的方案性能较差，所以尽量不要在太复杂的目录下或者大文件下实验。
        
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> result) throws IOException {
        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 IOException {
        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;
    }
}

汪汪miao~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java——文件操作IO

狭义的文件：指硬盘上的文件和目录。广义的文件：泛指计算机中的很多软硬件资源。针对硬盘这种持久化存储的I/O设备，当我们想要进行数据保存时，往往不是保存成一个整体，而是独立成一个个的单位进行保存，这个独立的单位就被抽象成文件的概念，就类似办公桌上的一份份真实的文件一般。操作系统中把很多软硬件资源都抽象成了文件，按照文件得形式统一管理。文件除了有数据内容之外，还有一部分信息。例如文件名、文件类型、文件大小等并不作为文件的数据而存在，我们把这部分信息可以视为。
复制链接

扫一扫