文件操作和IO详解

文件操作 和 IO

文件,File 这个概念,在计算机里,也是“一词多用”.

文件的狭义和广义

狭义的文件: 指的是硬盘上的文件和目录(文件夹)
广义的文件: 泛指计算机中很多的软硬件资源.操作系统中,把很多的硬件设备和软件设备都抽象成了文件.按照文件的方式来统一管理.例如网卡,操作系统就是把网卡当成了一个文件.
注: 平时谈到的“文件”,指的都是狭义的文件,也就是硬盘上的文件.

硬盘(外存)和内存相比

速度: 内存比硬盘快很多.
空间: 内存空间比硬盘小.
成本: 内存比硬盘快.
持久化: 内存掉电后数据丢失,外存掉电后数据还在.

文件路径

每个文件,在硬盘上都有一个具体的“路径”.

\ => 反斜杠 (使用 \ ,写代码的时候很不方便)
/ => 斜杠 (建议大家优先使用)

表示一个文件的具体位置路径是,就可以使用 / 来分割不同的目录级别.

在路径这里,有两种表示路径的风格.

1. 绝对路径.以c: d:盘符开头的路径.

2. 相对路径.以当前所在的目录为基准,以 . 或者 … 开头(. 有时候可以省略),找到指定的路径.

   当前所在的目录称为工作目录.每个程序运行的时候,都有一个工作目录(在控制台里通过命令操作的时候,是特别明显的,后来进化到图形化界面了,工作目录就不那么直观了).

工作目录不同,定位到同一个文件,相对路径写法是不同的.

同样是定位到 java_code 这里
如果工作目录是 d:/ ,相对路径写作 ./code/java_code
如果工作目录是 d:/code ,相对路径写作 ./java_code
如果工作目录是 d:/code/python_code ,相对路径写作 …/java_code (… 表示当前目录的上级目录)
如果工作目录是 d:/code/python_code/2023 ,相对路径写作 …/…/java_code
注: 我们日常写java代码一般都会使用IDEA,当我们打开IDEA之后,IDEA的默认工作路径就是你的当前项目的所在目录. 如果代码中写了一些相对路径的代码,工作路径就是以上述路径为基准的!!!

在 Windows 电脑,命令行下,直接输入某个程序的名字,本质上是操作系统去PATH环境变量里查找的. calc (Windows自带的计算器) 本身就在 PATH 下,所以可以直接运行.自己装的程序,比如 qq 之类的,默认不行.但是如果把 qq.exe 的路径也加入到 PATH 就可以了.
注: Linux没有盘符的概念,统一是使用 cd 切换. Windows 有盘符,先定位盘符,再 cd 在当前盘符下切换.

文件的类型

文件分类: 文本 vs 二进制
word,exe,图片,视频,音频,源代码,动态库……这些不同的文件,整体可以归纳到两类中,文本文件和二进制文件.

文本文件

文本文件: 存的是文本,字符串.
字符串,是由字符构成的,每个字符,都是通过一个数字来表示的.
这个文本文件里存的数据,—定是合法的字符,都是在你指定字符编码的码表之内的数据.

二进制文件

二进制文件: 存的是二进制数据,不一定是字符串了,没有任何限制,可以存储任何你想要你想要的数据.

随便给你个文件,如何区分文本还是二进制?
直接使用记事本打开.如果乱码了,说明就是二进制.如果没乱说明就是文本.

Java 对于文件的操作

1. 针对文件系统操作(创建文件,删除文件,重命)
2. 针对文件内容操作(文件的读和写)

File 类

Java 标准库,提供了一个 File 这个类(java.io.File), 这个 FIle 类,封装了文件系统操作.
注: 有 File 对象，并不代表真实存在该文件.

属性

注: pathSeparator => File 里的一个静态变量, 它是 / 还是 \ , 取决于操作系统.

构造方法

在 new File 对象的时候,构造方法参数中,可以指定一个路径,此时 File 对象就代表这个路径对应的文件了(指定一个路径 => 这里绝对路径和相对路径都行).
parent 表示当前文件所在的目录, child 自身的文件名.例如: d:/fly.jpg => parent d:/ , child fly.jpg

方法

**方法 **~~ 不需要死记,了解有印象即可

代码示例1 ~~ 文件路径

import java.io.File;import java.io.IOException;public class IODemo1 {    public static void main(String[] args) throws IOException {        File file = new File("d:/test.txt");// 不要求在 d:/ 这里真的有个 test.txt        //      File file=new File("./test.txt"); 第二类写法,使用相对路径,当前目录是项目所在路径        System.out.println(file.getName());// 获取到文件名        System.out.println(file.getParent());// 获取父级路径        System.out.println(file.getPath());// 获取到完整路径        System.out.println(file.getAbsolutePath());// 获取绝对路径        System.out.println(file.getCanonicalFile());// 获取绝对路径的简化路径    }}

运行结果
第一类写法的运行结果

第二类写法的运行结果

代码示例2 ~~ 文件创建

import java.io.File;import java.io.IOException;public class IODemo2 {    public static void main(String[] args) throws IOException {//      File file = new File("d:/test.txt");        File file = new File("./test.txt");        file.createNewFile();// 创建文件        System.out.println(file.exists());// 判断是否存在        System.out.println(file.isFile());// 判断是否是文件        System.out.println(file.isDirectory());// 判断是否是目录    }}

运行结果

代码示例3 ~~ 文件删除

import java.io.File;public class IODemo3 {    public static void main(String[] args) {        File file = new File("./test.txt");        file.delete();// 文件删除    }}

deleteOnExit 程序退出的时候,自动删除.程序中需要使用到一些"临时文件”的时候,需要用到.

代码示例4 ~~ 创建目录

import java.io.File;public class IODemo4 {    public static void main(String[] args) {        File dir=new File("./test");//      File dir=new File("./test/aaa/bbb");        // mkdir 只能创建一直目录        // mkdirs 才能创建多级目录        // mk => make (制造,创建), dir => directory (目录)        dir.mkdirs();    }}

运行结果

代码示例5 ~~ 文件重命名

import java.io.File;public class IODemo5 {    public static void main(String[] args) {        File file = new File("./test.txt");        File dest = new File("./testAAA");        file.renameTo(dest);        file.delete();    }}

运行结果

文件内容的操作

针对文件内容,使用**“流对象”**进行操作.

流对象 => 形象的比喻
计算机里的很多概念,都使用了一定的修辞手法.比喻是一种常见的方式.
使用一个链表头结点/二叉树根节点,表示整个链表/二叉树,这也是一个修辞手法借代也是一种常见的方式,用局部表示整体.
比如白居易的<<长恨歌>>:“六军不发无奈何,宛转蛾眉马前死.”
峨眉,古代女子纹的眉毛,用眉毛代替杨贵妃.

Java标准库的流对象.从类型上,分成两个大类:

1. 字节流: 以字节为单位,读写数据(操作二进制数据)
   InputStream => FileInputStream
OutputStream => FileOutputStream

2. 字符流: 以字符为单位,读写数据(操作文本数据)
   Reader => FileReader
Writer => FileWriter

注: 这里虽然涉及的类很多,但是规律性很强.
InputStream,OutputStream,Reader,Writer 都是抽象类,不能直接实例化.

抽象类和接口,有什么区别

抽象类和接口的区别 ~~ [经典面试题]

(1)接口比抽象类更抽象,但是抽象类的功能是比接口更多的.
(2)抽象类和普通的类,差别就不大.只不过抽象类不能new实例,带有抽象方法.抽象类,可以有普通方法,也可以有普通的属性.
(3)接口里面都是抽象方法&不能有普通的成员.

注: 抽象类,大部分的东西都是确定.有几个属性,有几个方法,大部分都是明确的,只要一小部分是抽象方法
接口,大部分都是不确定.有什么属性,也不知道,方法也都是抽象方法(不考虑default的情况)
因此接口提供的信息量更少,视为接口比抽象类更抽象.

这些类的使用方式是非常固定的 ~~ 核心操作(四个)
(1)打开文件(构造对象)
(2)关闭文件(close)
(3)读文件(read) => 针对 InputSream/Reader
(4)写文件(write) => 针对``OutputStream/Writer`

字节流

InputStream 概述

方法

read无参数版本: 一次读一个字节.
read一个参数版本: 把读到的内容填充到参数的这个字节数组中.(此处的参数是个“输出型参数")―返回值是实际读取的字节数.
read三个参数版本: 和2类似,只不过是往数组的一部分区间里尽可能填充.

read()返回值为什么是int?
read读取的是一个字节,按理说,返回一个byte就行了,但是实际上返回是int.
除了要表示 byte 里的0 ->255 (-128->127)这样的情况之外,还需要表示一个特殊情况,-1这个情况表示读取文件结束了(读到文件末尾了)

代码示例 ~~ 读取文件

import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;import java.io.InputStream;public class IODemo6 {    // 使用字节流来读取文件    public static void main(String[] args) throws IOException {        // 创建 InputStream 对象的时候,使用绝对路径或者相对路径,都是可以的,也可以使用 File 对象        InputStream inputStream = new FileInputStream("d:/cat.jpg");        // 一次读取若干个字节        while (true) {            byte[] buffer = new byte[1024];// read的第二个版本,需要调用者提前准备好一个数组.            int len = inputStream.read(buffer);            System.out.println("len: "+len);            if (len == -1) {                break;            }            // 此时读取的结果就被放到 byte 数组中.        }        inputStream.close();// 关闭文件    }}

buffer(缓存区)

buffer存在的意义,就是为了提高IО操作的效率.
单次IO操作,是要访问硬盘/IO设备,单次操作是比较消耗时间的,如果频繁进行这样的IO操作,耗时肯定就更多了.
单次IO时间是一定的,如果能缩短IO的次数,此时就可以提高程序整体的效率了.
第一个版本的代码,是一次读一个字节.循环次数就比较高. read次数也很高.
第二个版本的代码,是一次读1024个字节,循环次数就降低了很多.read次数变少了.
缓冲区,“缓和了一下冲突”,减少冲击的次数.

FileInputStream 概述

构造方法

OutputStream 概述

方法

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

代码示例 ~~ 写文件

使用了InputStream来读文件.还可以使用OutputStream来写文件.

import java.io.FileOutputStream;import java.io.IOException;import java.io.OutputStream;public class IODemo7 {    // 进行写文件    public static void main(String[] args) throws IOException {        OutputStream outputStream = new FileOutputStream("d:/test.txt");        outputStream.write(97);        outputStream.write(98);        outputStream.write(99);        outputStream.write(100);        outputStream.close();                    }}

outputStream.close;=> 这里的close操作,含义是,关闭文件.

进程 -> 在内核里,使用PCB这样的数据结构来表示进程.
一个线程对应一个PCB
一个进程可以对应一个PCB也可以对应多个…
PCB中有一个重要的属性，文件描述符表.(相当于一个数组)记录了该进程打开了哪些文件
(即使一个进程里有多个线程多个PCB,也没关系,这些PCB共用同一个文件描述符表

---

字符流

字符流用法和字节流基本差不多

示例代码 ~~ 字符读操作

import java.io.FileReader;import java.io.IOException;import java.io.Reader;public class IODemo8 {    // 字符流的操作    public static void main(String[] args) {        try (Reader reader = new FileReader("d:/test.txt")) {            while (true) {                int ch = reader.read();                if (ch == -1) {                    break;                }                System.out.print("" + (char) ch);            }        } catch (IOException e) {            throw new RuntimeException(e);        }    }}

运行结果

示例代码 ~~ 字符写操作

import java.io.FileWriter;import java.io.IOException;import java.io.Writer;public class IODemo9 {    public static void main(String[] args) {        try (Writer writer= new FileWriter("d:/test.txt")){            writer.write("fly in the sky! -- from: 0213");            // 手动刷新缓冲区            writer.flush();        } catch (IOException e) {            throw new RuntimeException(e);        }    }}

运行结果

writer.write("fly in the sky! -- from: 0213");
像这样的写操作,其实是先写到缓冲区里(缓冲区存在很多种形态.咱们自己的代码里可以有缓冲区;标准库里也可以有缓冲区∵操作系统内核里也可以有缓冲区…).
写操作执行完了,内容可能在缓冲区里,还没有真的进入硬盘.
close操作,就会触发缓冲区的刷新(刷新操作,就是把缓冲区里的内容写到硬盘里)
除了close之外,还可以通过 flush(推荐) 方法,也能起到刷新缓冲区的效果.

Scanner

Scanner 是搭配流对象进行使用的.

利用 Scanner 进行字符读取

Scanner scanner = new Scanner(System.in); => System.in 其实就是一个输入流对象

示例代码

import java.io.FileInputStream;import java.io.IOException;import java.io.InputStream;import java.util.Scanner;public class IODemo10 {    public static void main(String[] args) {        //Scanner scanner = new Scanner(System.in);        try (InputStream inputStream=new FileInputStream("d:/test.txt")){            Scanner scanner = new Scanner(inputStream);            // 此时读取的内容就是从 文件 进行读取了.            scanner.next();        }catch (IOException e){            e.printStackTrace();        }        // 此时,内部的 inputStream 对象已经被 try() 关闭了.里面的这个 Scanner 不关闭,也没事    }}

小工具程序练习

练习一

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

练习一题目

给定一个目录,目录里会包含很多的文件和子目录…
用户输入一个要查询的词,看看当前目录下(以及子目录里)是否有匹配的结果.如果有匹配结果,就进行删除.

代码实现

import java.io.File;import java.util.Scanner;public class IODemo11 {    private static Scanner scanner = new Scanner(System.in);    public static void main(String[] args) {        // 让用户输入一个指定搜索        Scanner scanner = new Scanner(System.in);        System.out.println("请输入要搜索的路径: ");        String basePath = scanner.next();        // 针对用户输入进行简单判定        File root = new File(basePath);        if (!root.isDirectory()) {            // 路径不存在,或者只是一个普通文件,此时无法进行搜索            System.out.println("输入的目录有误!");            return;        }        // 再让用户输入一个要删除的文件名        System.out.println("请输入要删除的文件名:");        // 此处要使用 next, 而不是使用 nextLine!!!        String nameToDelete = scanner.next();        // 针对指定的路径进行扫描 => 递归操作        // 先从根目录出发.(root)        // 先判定一下,当前这个目录里,看看是否包含我们要删除的文件.如果是,就删除;否则,就调过下一个.        // 如果当前这里包含了一些目录,再针对子目录进行递归.        scanDir(root, nameToDelete);    }    private static void scanDir(File root, String nameToDelete) {        System.out.println("[scanDir]"+root.getAbsolutePath());        // 1.先列出当前路径下包含的内容        File[] files = root.listFiles();        if (files == null) {            // 当前 root 目录下没东西,是一个空目录            // 结束继续递归            return;        }        // 2.遍历当前的列出结果        for (File f : files) {            if (f.isDirectory()) {                // 如果是目录,就进一步递归                scanDir(f, nameToDelete);            } else {                // 如果是普通文件,则判定是否要删除                if (f.getName().contains(nameToDelete)) {                    System.out.println("确认是否要删除 " + f.getAbsolutePath() + " 嘛?");                    String choice = scanner.next();                    if (choice.equals("y")||choice.equals("Y")){                        f.delete();                        System.out.println("删除成功!");                    }else {                        System.out.println("删除成功!");                    }                }            }        }    }}

运行结果

---

练习二

进行普通文件的复制

练习二题目

把一个文件拷贝成另一个文件,就是把第一个文件按照字节依次读取,把结果写入到另一个文件中.

代码实现

import java.io.*;import java.util.Date;import java.util.Scanner;public class IODemo12 {    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.isFile()){            // 如果已经存在,认为也不能拷贝            System.out.println("您当前输入的目标路径有误!");            return;        }        // 进行拷贝操作        try (InputStream inputStream= new FileInputStream(srcFile);             OutputStream outputStream=new FileOutputStream(destFile)){            // try()语法,支持包含多个流对象,多个流对象之间使用 ; 分割开就行了            // 进行读文件操作            while (true){                int b = inputStream.read();                if (b==-1){                    break;                }                outputStream.write(b);            }        } catch (IOException e) {            throw new RuntimeException(e);        }    }}

注: (1)由于这里的文件都是一个一个字节来进行读取的,所以无论哪种类型的文件都可以拷贝的.
(2)这里的代码只能进行文件的拷贝,如果需要拷贝目录的话,就需要按照上一个例子一样,递归的拷贝.

运行结果

来源地址：https://blog.csdn.net/m0_73740682/article/details/133860217