文件操作详解-IO

r囧r小猫 2023-10-10 16:03 18阅读 0赞

![2d8b044c9aa74626af93f6da7df31ef7.png][]

**目录**

1.认识文件

2.文件的类型

3.java对文件的操作

针对文件系统操作

针对文件内容操作

字节流

字符流

字节流的使用

字符流的使用

4.文件IO小程序练习

示例1

示例2

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

## 1.认识文件 ##

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

广义的文件泛指计算机中的很多的软硬件资源,操作系统中,把很多的硬件设备和软件资源抽象成了文件,按照文件的方式来统一管理

这里我们只讨论狭义的文件,就是硬盘上的数据

代码中存储数据是靠变量,变量是存储在内存中的,现在的文件是存储在硬盘上的

树形结构组织和目录

文件很多的情况下,在对文件进行管理的时候,采用了我们学过的数据结构--树形结构.

![7fbedaf6288d41e99753aa09757873a8.png][]

文件夹(folder)和目录(directory)中保存的就是我们所说的关于文件的元信息,通过一个个文件夹将文件组织起来,方便使用

![45079bbe3b5c4c3ab2e654328c797183.png][]

文件路径

绝对路径

每个文件在硬盘上都有一个具体的"路径",从树型结构的角度来看,树的每个节点都可以从一条根开始,一直到达的节点的路径所描述,这种描述方式就是文件的绝对路径(absolute path)

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

![ccafe4a299fc43c6ae1aa988d84ecfb9.png][]

我们查看.png文件的路径

![b807e1b695ae47afa5fafb18f30dd571.png][]

这里的路径是用\\来分割的路径

(/)斜杠和(\\)反斜杠有什么区别呢

建议使用斜杠来分割目录级别.String path = "d:\\epic",此时\\c就会被当成转义字符了,就不是\\本身了,得写成"d:\\\\epic",如果写正斜杠,就不会出现问题,并且各种系统都支持.

![e245134aa20a4e8f98702d901801ab23.png][]

可以用D:/Epic Games来描述位置,能识别出来,但是我们查看路径是反斜杠

![b70ecc8a83fc418d953cb3fe75f2ff8f.png][]

CDE这样的盘符是通过"硬盘分区"来的,每个盘符可以是一个单独的硬盘,也可以是若干个盘符对应一个硬盘

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

当前所在的目录称为工作目录,每个程序运行的时候,都有一个工作目录,(在控制台里通过命令操作的时候是很明显的)

我们在命令行下直接输入某个程序的名字,本质上是操作系统去PATH环境变量里查找的.calc本身就在PATH下,可有直接运行,我们自己装的程序,需要把路径加到PATH中后就可以运行了

![f18dc88562074faf93622bf8d03f9009.png][]

![e7508c0e61724559aade62e4ea7451ca.png][]

现在我们都是使用图形界面,工作目录就不太直观了

![f26d8d580ee044bb8088bfe469505c39.png][]

这就是默认的工作路径

![a6be37205bc642c1a4a831724114daf0.png][]

切换成D盘为工作路径

相对路径就是由工作路径为基准

![71357d7f8d9b43608647024fb9ce9c77.png][]

我们假设当前的工作目录为D:/tmp,那么定位到aaa这个目录,就可以表示为./aaa(./就表示当前的目录),定位到bbb就是./bbb

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

> 同样定位到aaa
> 
> 如果工作目录是D:/,相对路径写作./tmp/aaa
> 
> 如果工作目录是D:/tmp,相对路径写作./aaa
> 
> 如果工作目录是D:/tmp/bbb,相对路径写作../aaa(..表示当前目录的上级目录)

Linux没有盘符的概念,统一使用cd切换.windows需要先定位到盘符,再cd在当前盘符下切换

我们使用的IDEA的工作路径就是当前项目所在的目录,如果代码中写了一些相对路径的代码,工作路径就是以项目路径为基准的

![3b1589dacaa54c40857200eb17ec956d.png][]

## 2.文件的类型 ##

不同的文件整体可以归类为两类:

文本文件

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

二进制文件

没有任何限制,可以存储任何数据

给一个文件,如何区分是文本还是二进制文件呢?

可以使用记事本打开,如果是乱码,就是二进制文件,没乱就是文本文件,因为记事本是默认文本打开的

实际写代码中,这两类文件的处理方式略有差别

## 3.java对文件的操作 ##

### 针对文件系统操作 ###

Java提供了一个File类

属性

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>修饰符及类型</td> 
   <td style="width:99px;">属性</td> 
   <td style="width:298px;">说明</td> 
  </tr> 
  <tr> 
   <td>static String</td> 
   <td style="width:99px;">pathSeparator</td> 
   <td style="width:298px;">依赖于系统的路径分隔符，String 类型的表示</td> 
  </tr> 
  <tr> 
   <td>static char</td> 
   <td style="width:99px;">pathSeparator</td> 
   <td style="width:298px;">依赖于系统的路径分隔符，char 类型的表示</td> 
  </tr> 
 </tbody> 
</table>

pathSeparator是File中的一个静态变量,就是相当于/或者\\,用来分割的,方便多平台使用

构造方法

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>签名</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>File(File parent,String child)</td> 
   <td>根据父目录+孩子文件路径创建一个新的 File 实例</td> 
  </tr> 
  <tr> 
   <td>File(String pathname)</td> 
   <td>根据文件路径创建一个新的 File 实例，路径可以是绝对路径或者 相对路径</td> 
  </tr> 
  <tr> 
   <td>File(String parent, String child)</td> 
   <td>根据父目录 + 孩子文件路径，创建一个新的 File 实例，父目录用 路径表示</td> 
  </tr> 
 </tbody> 
</table>

这里传入绝对路径或者相对路径都可以

> parent表示当前文件所在目录,child表示自身的文件名
> 
> 例如D:/tmp
> 
> parent:D:/
> 
> child:tmp
> 
> 第二个比较常用File(String pathname),直接传入路径创建文件

方法

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

我们来看几组方法的使用:

File file = new File("d:/test.txt");

构造的这个文件对象的路径不一定要真实存在,不存在,file会有相关方法创建出来(createNewFile)

public static void main(String[] args) throws IOException {
            File file = new File("d:/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.getCanonicalPath());
        }

![2e021450dc1547f5a1754ba624a04953.png][]

这里看不出什么差异

将d:/换成./,就不同了.因为./是相对路径,这里的工作路径就是我们IDEA中项目的路径

![3882b8ae27b2481d85d1c65100cba7fe.png][]

看结果

![12e0c668ba224d2186c08d04f528b2a6.png][]

我们可以看出来绝对路径是在相对路径的基础上拼接了工作路径

getCanonicalPath()得到的是化简后的绝对路径,./省略了

public class IO2 {
        public static void main(String[] args) {
            File file = new File("d:/test.txt");
            //文件是否存在
            System.out.println(file.exists());
            //是否是文件
            System.out.println(file.isFile());
            //判断 File 对象代表的文件是否是一个目录
            System.out.println(file.isDirectory());
        }
    }

我们在D盘下创建test文件后运行程序

![3bd07aea8e6346e2b8d9b5580d0f2453.png][]

将d:/换成./,就不同了.因为该项目路径下没有这个文件,既不是文件也没有目录

![e4ab267c22e14cf0b0c83d6bb23381b3.png][]

但是我们可以创建文件,创建文件后执行程序

![f863a9c9a54940b88b72ae67d65a04df.png][]

![febca551bd9742de83d79df14a533179.png][]

在项目目录下也能找到我们创建的文件

![5377bf63300e4a38971a74191c36488d.png][]

我们使用方法删除test文件

public class IO3 {
        public static void main(String[] args) {
            File file = new File("./test.txt");
            file.delete();
        }
    }

删除成功

![0ca9a9dcb9404ae18ad12fda12dc0019.png][]

deleteOnExit()这个方法是程序退出后删除

适用于临时文件,程序退出后就删除了

public class IO4 {
        public static void main(String[] args) {
            File file = new File("./test");
            //创建目录
            file.mkdir();
            //创建多级目录
            //file.mkdirs();
        }
    }

![b8af84091811462089b170d6b28fac32.png][]

file.mkdirs()创建多级目录,mkdir只能创建一级目录

![5f6e7e8458074086920bb10a55a352a6.png][]

public class IO5 {
        public static void main(String[] args) {
            File file = new File("./test");
            File dest = new File("./testAA");
            file.renameTo(dest);
        }
    }

![d3cbd8d7eb304bc8aa95dcd8edeb816f.png][]

renameTo更改了文件名

### 针对文件内容操作 ###

针对文件内容,我们使用"流对象"进行操作的,这个比喻并非是Java独有的,操作系统api就是这样设定的,进一步的各种编程语言,操作文件也继承了这个概念

Java标准库的流对象从类型上分为两类,每个类又有几个不同的功能的类

#### 字节流 ####

字节流是操作二进制文件的

InputStream

FileInputStream

OutputStream

FileOutputStream

#### 字符流 ####

字符流是操作文本文件的

Reader FileReader

Writer FileWriter

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

#### 字节流的使用 ####

我们来看这个代码,使用字节流读取文本文件:

public class IO6 {
        public static void main(String[] args) throws IOException {
            //绝对路径,相对路径,File对象都可以
            //FileNotFoundException是IOException的子类,如果想要打开一个文件去读
            //但是必须保证这个文件是存在的,否则会出异常
            InputStream inputStream = new FileInputStream("d:test.txt");
            //进行操作
            while(true){
    
                int b = inputStream.read();
                if(b == -1){
                    //读取完毕
                    break;
                }
                System.out.println(""+(byte)b);
            }
            inputStream.close();
        }
    }

![3266a7d656714dc79f06cb3aa9c40016.png][]

InputStream /OutputStream /Reader/Writer 这几个类都是抽象类,不能直接实例化

![f2f3584bfc3f4447bd8ab5af15327d7f.png][]

read有三个版本,无参版本一次读一个字节.一个参数版本:把读到的内容填充到参数的这个字节数组中(此处的参数是输出型参数,返回值是实际读取的字节数)

三个参数版本:和一个参数版本类似,只不过往数组的一部分区间里尽可能填充

![b461c7fe30204d60a16488a13c8a780f.png][]

返回值为int, read读的是一个字节,返回一个byte就可以,但是实际上返回的是int,除了要表示byte的0~255(-128~127)这样的情况,还要表示一个特殊情况,-1表示读取文件结束了(读到文件末尾了),但是byte就没有多余空间表示这个非法值了,所以需要用int作为返回值,拿到的int可以强转byte

运行程序,结果

![afcea2615b3c42589534579f9e1336c6.png][]

可以看到读的每个字节都是数字,这些数字就是美国信息交换标准代码(ASCII),对照后就是hello .

如果将test中内容改为中文

![623acd0c74f6430485a22734d9e3a891.png][]

这些数字就表示"你好"这两个字的编码方式,如果按十六进制打印,

![80c77aab0dcd4ec78f0990054bb70e9e.png][]

这里使用的是utf8的,对照utf8码表

![663e53a2706444e58d1eb62a1305efa3.png][]

这里的txt文件是文本文件,使用字节流也能读,但是不方便,更希望使用字符流读,就更方便了

上述使用的是read的第一个版本,无参的.接下来使用一个参数的版本

while(true){
                byte[] buffer = new byte[1024];
                int len = inputStream.read(buffer);
                System.out.println("len = "+len);
                if(len == -1){
                    break;
                }
                for (int i = 0; i < len; i++) {
                    System.out.printf("%x\n",buffer[i]);
                }
            }

![58997adb63394505a4b79754e5cc6bd7.png][]

read的第二个版本需要提前准备一个数组,传参操作就相当于把刚才准备好的数组交给read来填充,此处参数相当于"输出型参数",Java中习惯使用输入的信息作为参数,输出的信息作为返回值,但是也有少数情况,使用参数来返回内容.

要注意理解read的行为和返回值.read会尽可能的把传进来的数组给填满,上面给到的数组是1024,read就会尽可能的读取1024个字节,如果文件的剩余长度超过1024,此时1024个字节都会被填满,返回值就是1024,如果当前的文件不足1024,那么读取多少就会返回多少.read方法就是返回当前实际读取的长度.

如果超过1024了,就会循环下一轮继续读,我们把test文件中多放点内容然后运行程序

![2d236565754549b2947f47f6c572c2be.png][]

![c2a3761155a142f083a5ee0cd5e58b78.png][]

整个文件是13k,因此需要多次循环read,由于数组长度是1024,所以前面每次read读到的长度都是1024,最后一轮只剩122字节了.数据不足1024了,实际能读到多少字节,就读多少字节,不同的文件最后一次剩余的也不同,读完122就是文件末尾了,再下一轮循环,没有内容可读,返回-1,循环结束.

文件是在磁盘上的,有的文件内容可能会很多,甚至超出内存的上限,有时想把整个文件读取到内存在处理不一定行,一般都是一边读一边处理,处理好了一部分,再处理下一个部分..

再来看一个问题

byte[] buffer

我们为啥起名叫buffer

buffer叫做"缓冲区",存在的意义就是提高IO的效率,单次IO操作,是要访问硬盘/IO设备,单次操作是比较消耗时间的,如果频繁的IO操作,耗时肯定就多了.

单次IO时间是一定的,如果能缩短IO的次数,此时就可以提高程序整体的效率了,第一个版本的代码是一次读一个字节,循环次数比较多,read次数也多,第二个版本是一次读1024个字节,循环次数降低很多,read次数也变少了..缓冲区就是缓和了冲突,减小访问的次数.

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

![2d1df9fae0c04274afd283a27562e97d.png][]

写方法有三个版本,第一个版本是一次写一个字节,范围是0~255,和read是相同的.

第二个版本是准备一个数组,然后一次写到数组中去

第三个版本是从数组的off下标开始写到len结束

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

执行程序后打开文件

![9513bdb0c9044a14ba353c43001084b8.png][]

> 我们之前写进去的内容已经被清空了,然后写入了abcd
> 
> 对于OutputStream默认情况下,打开一个文件,会先清空文件原有的内容,这样的话,之前我们放进去的内容就没有了
> 
> 如果不希望清空,流对象还提供了一个"追加写"对象,通过这个对象可以不清空文件,把新内容追加到后面

还要注意:input和output的方向,input不应该是输入的意思吗,那应该对应的是写文件啊,为什么是读文件呢..

这里input和output是基于CPU的方向

![ed3df3045dda4fbb8a35e63dbe03ec6e.png][]

内存更接近CPU,硬盘离CPU更远,CPU是一台计算机最核心的部分,相当于人的大脑

以CPU为中心,朝着CPU的方向流向,就是输入.所以把数据从硬盘到内存这个过程称为读,input

数据远离CPU方向流向,就是输出,所以把数据从CPU到硬盘这个过程称为写,output.

outputStream.close();

这里的close操作,含义是关闭文件

之前所说的进程,在内核里,使用PCB这样的数据结构来表示进程,一个线程对应一个PCB,一个进程可以对应一个或多个PCB

PCB中有一个重要的属性,文件描述符表(相当于一个数组)记录了该进程打开了哪些文件

即使一个进程有多个线程,多个PCB,这些PCB还是共用一个文件描述符表

![ddda528b462742deac0d50c795d76bb7.png][]

文件描述符表中的每个元素,都是内核里的一个file\_struct对象,这个对象就表示一个打开了的文件

每次打开文件操作,就会在文件描述符表中申请一个位置,把这个信息记录进去,每次关闭文件,就会把这个文件描述符表对应的表项给释放掉

outputStream.close();起到的作用就是释放对应的表项,如果这个代码没写或者没执行到

那么文件描述符表中的表项就没有及时释放,GC操作会在回收这个outputStream对象的时候去完成这个释放操作,虽然GC会完成操作,但是不一定及时释放,因此如果不手动释放,当使用文件很多的情况下,文件描述符表会很快被占满,这个数组是不能扩容,存在上限的,如果被占满了,再次打开文件,就会打开失败!!文件描述符表最大长度对于不同的系统不太一样,但是基本都是几百至几千左右

close一般来说是要执行的,但是如果一个程序,这里的文件自始至终都要用,不关闭问题也不大,因为程序一结束,整个进程都会结束,对应的资源都会被操作系统回收了,也就是说,如果close之后程序就结束了,那么不手动释放资源也没事!

当然我们一般写代码中还是要close的,那么如何保证close一定被执行呢?

这是推荐写法

public static void main(String[] args) throws IOException {
            try(OutputStream outputStream = new FileOutputStream("d:/test.txt");){
                outputStream.write(97);
                outputStream.write(98);
                outputStream.write(99);
                outputStream.write(100);
            }
        }

这个写法虽然没有显式的写close.但是实际上是会执行的,只要try语句执行完毕,就可以自动执行到close!!

这个语法叫做:try with resources

那么这个语法能针对锁执行完了就释放吗?显然不是的,这个语法不是随便一个对象放到try()中就可以自动释放的!需要满足一定的要求

![cb0bb937b25a40648adfcc63437d6ce4.png][]

可以看到这个outputstream实现了closeable类,所以只有实现了这个接口的类才能自动释放,这个接口提供的方法就是close方法

以上是关于字节流的使用

#### 字符流的使用 ####

字符流的使用和字节流是相似的,我们演示一下方法

![a0d15004048d408c8d2abc6a106c2602.png][]

第一个版本是一次返回一个char类型字符,第二个版本是返回一个字符数组,第三个版本是相当于对第二个字符数组封装了,最后一个版本是返回一个从off到len 的字符数组

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.println(""+(char) ch);
                }
            } catch (FileNotFoundException e) {
                throw new RuntimeException(e);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

结果:

![623a0df6d5384438adaab40868215ea8.png][]

我们把test内容换成中文"你好"后运行程序

![3ae990af0a68433ba3958f2bcc775629.png][]

也是一次打印一个字符

写操作也是类似的

public class IO9 {
        public static void main(String[] args) {
            try(Writer writer = new FileWriter("d:/test.txt")){
                writer.write("hello");
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

![5baee558402e46269c69b78e9ec18040.png][]

有时候我们发现写的内容没在真的文件中存在,很大可能是缓冲区的问题

writer.write("hello");

像这样的写操作是先写到缓冲区,缓冲区是有很多的形态(代码中,操作系统内核,标准库),写操作执行完了,内容可能在缓冲区里,还没真正进入硬盘,close操作就会触发缓冲区的冲刷(flush),刷新操作其实就是把缓冲区的操作写到硬盘中..除了close之外,还能通过flush方法,也能起到刷新缓冲区的效果

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

Scanner也是搭配流对象使用的

Scanner scanner = new Scanner(System.in);

System.in

其实就是一个输入流对象,字节流,看看源码

![1bd66f8a52914b2cb492aaa25034839e.png][]

这里Scanner scanner = new Scanner(System.in);的System.in是指向标准输入的流对象,就从键盘读取,如果指向的是一个文件流对象,就从文件读

public class IO10 {
        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 (FileNotFoundException e) {
                throw new RuntimeException(e);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

Scanner的close本质上是要关闭内部包含的这个流对象,此时,内部的inputStream对象已经被try()关闭了,里面的Scanner不关闭也没事,但是如果 内部的inputStream对象没有关闭,那么就要关闭内部包含的这个流对象

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

## 4.文件IO小程序练习 ##

接下来我们写几个小程序,练习文件的基本操作 + 文件内容读写操作

### 示例1 ###

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

也就是给定一个目录,目录里包含很多的文件和子目录,用户输入一个要查询的词,如果目录下(包含子目录)有匹配的结果(文件名)就进行删除

import java.io.File;
    import java.util.Scanner;
    
    public class IO11 {
        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) {
            //列出当前目录包含的内容
            File[] f = root.listFiles();//相当于打开文件资源管理器,打开了一个目录一样
            if(f == null){
                //空目录
                return;
            }
            //遍历当前的列出结果
            for (File files: f) {
                if(files.isDirectory()){
                    //是目录就进一步递归
                    scanDir(files,nameToDelete);
                }else {
                    //不是目录,判定是否删除
                    if(files.getName().contains(nameToDelete)){
                        System.out.println("是否要删除: "+files.getName()+"?");
                        String choice = scanner.next();
                        if(choice.equals("y")||choice.equals("Y")){
                            files.delete();
                            System.out.println("删除成功");
                        }else {
                            System.out.println("删除取消");
                        }
                    }
                }
            }
        }
    }

![240c94d3beae4e298ceac44e14b63c42.png][]

执行程序后

![dc7d2736b3af4522a2df0f30676d054a.png][]

![da12d64fa075475a8f6e1fa4ede80b3b.png][]

在函数中加上扫描路径的打印

![3ae0b33ba69546da944015d89342380e.png][] ![70ec6909f7544ceea812fca8eb9bc0c1.png][]

### 示例2 ###

进行普通文件的复制

把一个文件拷贝成另一个文件

import java.io.*;
    import java.util.Scanner;
    
    public class IO12 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            //输入两个路径
            System.out.println("输入要拷贝的文件:");
            String srcPath = sc.next();
            System.out.println("输入要拷贝的路径:");
            String destPath = sc.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)) {
                while(true){
                    int b = inputStream.read();
                    if(b ==-1){
                        return;
                    }
                    outputStream.write(b);
                }
            } catch (FileNotFoundException e) {
                throw new RuntimeException(e);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

![a786ff8840c9421ca0b9e75fd36e2559.png][]

try with resources语法支持包含多个流对象,多个流对象之间用分号隔开就行

我们将d:/tmp/aaa的文件111拷贝到d:/tmp/bbb中去

源路径

![a9785cfbe28a4c8fbec09b90cf53756a.png][] 目标路径

![a1dcf940fd5d43c099d88ef62ffe45f2.png][]

执行程序后

![56720ff4d0284330935160f16b1d45db.png][]

拷贝成功![5b3bb02bf9c442b69040d1434aab04d0.png][]

文件章节到这里就结束了

祝各位大佬新年快乐!新年胜旧年,兔年"兔飞猛进"~~

[2d8b044c9aa74626af93f6da7df31ef7.png]: https://img-blog.csdnimg.cn/img_convert/2d8b044c9aa74626af93f6da7df31ef7.png
[7fbedaf6288d41e99753aa09757873a8.png]: https://img-blog.csdnimg.cn/7fbedaf6288d41e99753aa09757873a8.png
[45079bbe3b5c4c3ab2e654328c797183.png]: https://img-blog.csdnimg.cn/45079bbe3b5c4c3ab2e654328c797183.png
[ccafe4a299fc43c6ae1aa988d84ecfb9.png]: https://img-blog.csdnimg.cn/ccafe4a299fc43c6ae1aa988d84ecfb9.png
[b807e1b695ae47afa5fafb18f30dd571.png]: https://img-blog.csdnimg.cn/b807e1b695ae47afa5fafb18f30dd571.png
[e245134aa20a4e8f98702d901801ab23.png]: https://img-blog.csdnimg.cn/e245134aa20a4e8f98702d901801ab23.png
[b70ecc8a83fc418d953cb3fe75f2ff8f.png]: https://img-blog.csdnimg.cn/b70ecc8a83fc418d953cb3fe75f2ff8f.png
[f18dc88562074faf93622bf8d03f9009.png]: https://img-blog.csdnimg.cn/f18dc88562074faf93622bf8d03f9009.png
[e7508c0e61724559aade62e4ea7451ca.png]: https://img-blog.csdnimg.cn/e7508c0e61724559aade62e4ea7451ca.png
[f26d8d580ee044bb8088bfe469505c39.png]: https://img-blog.csdnimg.cn/f26d8d580ee044bb8088bfe469505c39.png
[a6be37205bc642c1a4a831724114daf0.png]: https://img-blog.csdnimg.cn/a6be37205bc642c1a4a831724114daf0.png
[71357d7f8d9b43608647024fb9ce9c77.png]: https://img-blog.csdnimg.cn/71357d7f8d9b43608647024fb9ce9c77.png
[3b1589dacaa54c40857200eb17ec956d.png]: https://img-blog.csdnimg.cn/3b1589dacaa54c40857200eb17ec956d.png
[2e021450dc1547f5a1754ba624a04953.png]: https://img-blog.csdnimg.cn/2e021450dc1547f5a1754ba624a04953.png
[3882b8ae27b2481d85d1c65100cba7fe.png]: https://img-blog.csdnimg.cn/3882b8ae27b2481d85d1c65100cba7fe.png
[12e0c668ba224d2186c08d04f528b2a6.png]: https://img-blog.csdnimg.cn/12e0c668ba224d2186c08d04f528b2a6.png
[3bd07aea8e6346e2b8d9b5580d0f2453.png]: https://img-blog.csdnimg.cn/3bd07aea8e6346e2b8d9b5580d0f2453.png
[e4ab267c22e14cf0b0c83d6bb23381b3.png]: https://img-blog.csdnimg.cn/e4ab267c22e14cf0b0c83d6bb23381b3.png
[f863a9c9a54940b88b72ae67d65a04df.png]: https://img-blog.csdnimg.cn/f863a9c9a54940b88b72ae67d65a04df.png
[febca551bd9742de83d79df14a533179.png]: https://img-blog.csdnimg.cn/febca551bd9742de83d79df14a533179.png
[5377bf63300e4a38971a74191c36488d.png]: https://img-blog.csdnimg.cn/5377bf63300e4a38971a74191c36488d.png
[0ca9a9dcb9404ae18ad12fda12dc0019.png]: https://img-blog.csdnimg.cn/0ca9a9dcb9404ae18ad12fda12dc0019.png
[b8af84091811462089b170d6b28fac32.png]: https://img-blog.csdnimg.cn/b8af84091811462089b170d6b28fac32.png
[5f6e7e8458074086920bb10a55a352a6.png]: https://img-blog.csdnimg.cn/5f6e7e8458074086920bb10a55a352a6.png
[d3cbd8d7eb304bc8aa95dcd8edeb816f.png]: https://img-blog.csdnimg.cn/d3cbd8d7eb304bc8aa95dcd8edeb816f.png
[3266a7d656714dc79f06cb3aa9c40016.png]: https://img-blog.csdnimg.cn/3266a7d656714dc79f06cb3aa9c40016.png
[f2f3584bfc3f4447bd8ab5af15327d7f.png]: https://img-blog.csdnimg.cn/f2f3584bfc3f4447bd8ab5af15327d7f.png
[b461c7fe30204d60a16488a13c8a780f.png]: https://img-blog.csdnimg.cn/b461c7fe30204d60a16488a13c8a780f.png
[afcea2615b3c42589534579f9e1336c6.png]: https://img-blog.csdnimg.cn/afcea2615b3c42589534579f9e1336c6.png
[623acd0c74f6430485a22734d9e3a891.png]: https://img-blog.csdnimg.cn/623acd0c74f6430485a22734d9e3a891.png
[80c77aab0dcd4ec78f0990054bb70e9e.png]: https://img-blog.csdnimg.cn/80c77aab0dcd4ec78f0990054bb70e9e.png
[663e53a2706444e58d1eb62a1305efa3.png]: https://img-blog.csdnimg.cn/663e53a2706444e58d1eb62a1305efa3.png
[58997adb63394505a4b79754e5cc6bd7.png]: https://img-blog.csdnimg.cn/58997adb63394505a4b79754e5cc6bd7.png
[2d236565754549b2947f47f6c572c2be.png]: https://img-blog.csdnimg.cn/2d236565754549b2947f47f6c572c2be.png
[c2a3761155a142f083a5ee0cd5e58b78.png]: https://img-blog.csdnimg.cn/c2a3761155a142f083a5ee0cd5e58b78.png
[2d1df9fae0c04274afd283a27562e97d.png]: https://img-blog.csdnimg.cn/2d1df9fae0c04274afd283a27562e97d.png
[9513bdb0c9044a14ba353c43001084b8.png]: https://img-blog.csdnimg.cn/9513bdb0c9044a14ba353c43001084b8.png
[ed3df3045dda4fbb8a35e63dbe03ec6e.png]: https://img-blog.csdnimg.cn/ed3df3045dda4fbb8a35e63dbe03ec6e.png
[ddda528b462742deac0d50c795d76bb7.png]: https://img-blog.csdnimg.cn/ddda528b462742deac0d50c795d76bb7.png
[cb0bb937b25a40648adfcc63437d6ce4.png]: https://img-blog.csdnimg.cn/cb0bb937b25a40648adfcc63437d6ce4.png
[a0d15004048d408c8d2abc6a106c2602.png]: https://img-blog.csdnimg.cn/a0d15004048d408c8d2abc6a106c2602.png
[623a0df6d5384438adaab40868215ea8.png]: https://img-blog.csdnimg.cn/623a0df6d5384438adaab40868215ea8.png
[3ae990af0a68433ba3958f2bcc775629.png]: https://img-blog.csdnimg.cn/3ae990af0a68433ba3958f2bcc775629.png
[5baee558402e46269c69b78e9ec18040.png]: https://img-blog.csdnimg.cn/5baee558402e46269c69b78e9ec18040.png
[1bd66f8a52914b2cb492aaa25034839e.png]: https://img-blog.csdnimg.cn/1bd66f8a52914b2cb492aaa25034839e.png
[240c94d3beae4e298ceac44e14b63c42.png]: https://img-blog.csdnimg.cn/240c94d3beae4e298ceac44e14b63c42.png
[dc7d2736b3af4522a2df0f30676d054a.png]: https://img-blog.csdnimg.cn/dc7d2736b3af4522a2df0f30676d054a.png
[da12d64fa075475a8f6e1fa4ede80b3b.png]: https://img-blog.csdnimg.cn/da12d64fa075475a8f6e1fa4ede80b3b.png
[3ae0b33ba69546da944015d89342380e.png]: https://img-blog.csdnimg.cn/3ae0b33ba69546da944015d89342380e.png
[70ec6909f7544ceea812fca8eb9bc0c1.png]: https://img-blog.csdnimg.cn/70ec6909f7544ceea812fca8eb9bc0c1.png
[a786ff8840c9421ca0b9e75fd36e2559.png]: https://img-blog.csdnimg.cn/a786ff8840c9421ca0b9e75fd36e2559.png
[a9785cfbe28a4c8fbec09b90cf53756a.png]: https://img-blog.csdnimg.cn/a9785cfbe28a4c8fbec09b90cf53756a.png
[a1dcf940fd5d43c099d88ef62ffe45f2.png]: https://img-blog.csdnimg.cn/a1dcf940fd5d43c099d88ef62ffe45f2.png
[56720ff4d0284330935160f16b1d45db.png]: https://img-blog.csdnimg.cn/56720ff4d0284330935160f16b1d45db.png
[5b3bb02bf9c442b69040d1434aab04d0.png]: https://img-blog.csdnimg.cn/5b3bb02bf9c442b69040d1434aab04d0.png