JAVA中的文件操作

---

一、文件认识

 普通文件通常保存在机械硬盘（HDD）上，机械硬盘的读写速率要比内存慢很多（3-4个数量级），机械硬盘的盘片转速越快，读写速度就越快，但因为工艺限制，盘片的转速不可能无限高，大多数都朝着扩大容量的方法发展；固态硬盘（SSD）的读写速度要比机械硬盘高很多，这里主要讨论机械硬盘中的文件

（一）文件的分类

1. 文本文件，文件中存储的是字符，文本文件中本质上也是存字节的，但是文本文件中相邻的字节在一起正好能构成一个个字符
2. 二进制文件，文件中存储的是字节，字节和字节之间就完全关系

• 判断文件类型可以通过.txt方式打开，乱码的情况为二进制文件，一般来说.txt、.c、.java的文件都属于文本文件；.doc、.ppt、.exe、.zip、.class都属于二进制文件

（二）目录结构

 计算机中通过操作系统中的“文件系统”这样的模块来负责保存和管理文件，一般通过 N 叉树的结构来组织磁盘上的目录和文件。如果是一个普通文件，就是树的叶子节点，如果是一个目录文件，就可以包含子树，每个节点上的子树都可以有N个。

 在操作系统中，可以通过路径来表述一个具体文件/目录的位置，路径有两种描述风格

1. 绝对路径，以盘符开头
2. 相对路径，以 “ . ” 或者 “ … ” 开头的路径，其中 “ . ” 表示当前路径，“ … ” 表示当前路径的父目录(上级路径)，相对路径需要从基准出发，按照该基准查找对应的文件。如果通过命令行的方式 ( java.Demo ) 此时执行命令所在的目录就是基准路径；如果通过 IDEA 方式来运行程序，当前 JAVA 项目所在的路径就是基准路径；如果是把JAVA程序打包成war包，放到 tomcat 上运行时，此时 tomcat 的 bin 目录就是基准路径

二、文件操作

&emps;JAVA中操作文件，主要包含两类文件操作

1. 文件系统相关的操作：该操作C语言没有，C语言标准库不支持文件系统操作，指通过 “文件资源管理器” 能够完成的一些功能（列出目录中有那些文件、创建文件、创建目录、删除文件、重命名文件…）
2. 文件内容的相关操作（文件内容的增删改查）

（一）File类

1.属性

修饰符及类型	属性	说明
static String	pathSeparator	依赖于系统的路径分隔符，String类型的表示
static cahr	pathSeparator	依赖于系统的路径分隔符，char类型的表示

2.构造方法

 构造方法能够传入一个路径来指定一个文件，这个路径可以是绝对路径或者相对路径

签名	说明
public File(String parent, String child)	根据父目录+孩子文件路径，创建一个新的 File 实例
public File(String pathname)	根据文件路径创建一个新的File实例，路径可以是绝对路径或者相对路径
private File(String child, File parent)	根据父目录+孩子文件路径，创建一个新的 File 实例，父目录用路径表示

3.方法

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

（二）File类的具体使用

1.文件路径的查看

package file;
import java.io.File;
import java.io.IOException;//File的构造
public class Demo {public static void main(String[] args) throws IOException {File f1 = new File("D:/Code/JAVA_Learing/Study_EE/test.txt");System.out.println(f1.getParent());        //获取到文件的父目录System.out.println(f1.getName());          //获取文件名System.out.println(f1.getPath());          //获取到文件路径（构造File时候指定的路径）System.out.println(f1.getAbsolutePath());  //获取到绝对路径System.out.println(f1.getCanonicalPath()); //获取到绝对路径File f2 = new File("./test.txt");System.out.println(f2.getParent());        //获取到文件的父目录System.out.println(f2.getName());          //获取文件名System.out.println(f2.getPath());          //获取到文件路径（构造File时候指定的路径）System.out.println(f2.getAbsolutePath());  //获取到绝对路径System.out.println(f2.getCanonicalPath()); //获取到绝对路径}
}

f1得到的的结果如下

f2得到的的结果如下

 getAbsolutePath() 方法仅仅是在基准路径的基础上把相对路径拼接上了，getCanonicalPath() 则是一个化简过后的绝对路径。
 一般来说路径的分隔符都是斜杠“ / ”，但是对于Windows来说，使用的是“ \ ”

2.文件的基本操作

（1） 文件的创建和删除

 文件信息的查看

import java.io.File;public class Demo {public static void main(String[] args) {File f1 = new File("./test.txt");System.out.println(f1.exists());       //文件是否存在System.out.println(f1.isDirectory());  //文件是否是目录System.out.println(f1.isFile());       //文件是否是一个普通文件}
}

 文件的创建和删除

import java.io.File;
import java.io.IOException;public class Demo {public static void main(String[] args) throws IOException {File f1 = new File("./test.txt");System.out.println(f1.exists());//创建文件f1.createNewFile();System.out.println(f1.exists());//删除文件f1.delete();System.out.println(f1.exists());}
}

 创建目录文件，其中mkdir() 只能创建一级目录，想一次创建多级需要使用 mkdirs()

import java.io.File;public class Demo {public static void main(String[] args) {File f1 = new File("./aaa");f1.mkdir();//创建目录文件System.out.println(f1.isDirectory());File f2 = new File("./bbb/ccc");f2.mkdirs();//创建目录文件System.out.println(f2.isDirectory());}
}

 罗列不同的文件

import java.io.File;
import java.util.Arrays;public class Demo5 {public static void main(String[] args) {File f1 = new File("./bbb");System.out.println(Arrays.toString(f1.list()));//[ccc]System.out.println(Arrays.toString(f1.listFiles()));//[.\bbb\ccc]File f2 = new File("./");System.out.println(Arrays.toString(f2.list()));//[.idea, aaa, bbb, out, src, Study_EE.iml]System.out.println(Arrays.toString(f2.listFiles()));//[.\.idea, .\aaa, .\bbb, .\out, .\src, .\Study_EE.iml]}
}

 给文件重命名

import java.io.File;public class Demo {public static void main(String[] args) {File f1 = new File("./aaa");File f2 = new File("./zzz");f1.renameTo(f2);//文件重命名}
}

（2）文件内容的读写

 根据文件内容的读写，JAVA标准库提供了一组类，首先按照文件的内容分成了两个系列，

1. 字节流对象，针对二进制文件，是以字节为单位进行读写的，读 InputStream，写 OutStream
2. 字符流对象，针对文本文件，是以字节为单位进行读写的，读 Reader，写 Writer

 读InputStream，写OutStream，读Reader，写Writer都是抽象类，既可以对普通文件进行读写，也可以针对特殊文件（网卡、socket文件）进行读写，实际使用的往往都是这些类的子类：FileInputStream、FileOutputStream、FileReader、FileWriter，这一组类都针对普通文件进行读写的。

a.通过字节读写文件

 读取文件read()提供了三个版本的重载，

1. 无参数版本，一次读一个字节，返回值是读到的字节，返回值是-1时表示文件读完，又 Byte 的取值范围是 [-128,127] 之间，为了区分非法状态和正常读状态，因此选取一个更大的 int 范围设定返回值在 [-1,255]
2. 一个参数版本，一次读若干个字节，把读的结果放到参数中指定的数组中，返回值就是读到的字节数，相当于是使用参数的方式来表示方法的返回值，是一种 “输出型参数” 的方式
3. 三个参数版本，一次读若干个字节，把读的结果放到参数中指定的数组中，返回值就是读到的字节数，不是从数组的起始位置放置，而是从off下标的中间位置放置，len表示最多能放多少个元素
   

 通过 read() 循环读取一个一个文件的的代码示例如下，为防止在文件读取过程中抛出异常而导致文件关闭操作没有进行的问题，需要将释放资源的语句放到 finally 语句中，close() 操作也可能存在IO异常，因此这样得到的代码冗长，可以通过 try-with-resource 自动关闭在 try 语句块中使用的资源，从而避免资源泄露问题.

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;public class Demo {public static void main(String[] args) {//构造方法中需要指定打开文件的路径//此处的路径可以是绝对路径，也可以是相对路径，还可以是File对象InputStream inputStream = null;try {//1.创建对象，同时也是在打开文件inputStream = new FileInputStream("./test.txt");//2.尝试一个一个字节的读，把整个文件都读完while (true){int b = inputStream.read();if(b == -1){//读到文件末尾break;}System.out.println(b);}} catch (IOException e) {e.printStackTrace();}finally {//3.读完后需要关闭文件，释放资源try {inputStream.close();} catch (IOException e) {e.printStackTrace();}}}
}

 try() 括号中的类要实现了 Closeable 这个 interface 之后，才能自动关闭，而对于IO流对象来说，所有对象都实现了 Closeable，所以可以直接关闭流对象，简化后的代码如下

public class Demo {public static void main(String[] args) {//当代码执行完 try 语句块之后会自动调用 closetry(InputStream inputStream = new FileInputStream("./test.txt")){while (true){int b = inputStream.read();if(b == -1){//读到文件末尾break;}System.out.println(b);}} catch (IOException e) {e.printStackTrace();}}
}

 通过 read( byte[ ]) 方法一次读取若干个字节

public class Demo {public static void main(String[] args) {try(InputStream inputStream = new FileInputStream("./test.txt")){//一次读取若干个字节while (true){byte[] buffer = new byte[1024];int len = inputStream.read(buffer);//读出的结果放到buffer中if(len == -1){break;}
//                for(int i =0;i<len;i++){
//                    System.out.println(buffer[i]);
//                }String s = new String(buffer,0,len);System.out.println(s);}} catch (IOException e) {e.printStackTrace();}}

 通过字节进行写操作时，可以一次写一个，可以一次性写多个，每次写操作会清空原有文件的内容

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;public class Demo {public static void main(String[] args) {//每次写操作会清空原有文件的内容try(OutputStream outputStream = new FileOutputStream("./test.txt")){outputStream.write(97);outputStream.write(98);outputStream.write(99);//文件内容为abcbyte[] buffer = new byte[]{97,98,99};outputStream.write(buffer);} catch (IOException e) {e.printStackTrace();}}
}

---

b.通过字符读写文件

import java.io.*;public class Demo {public static void main(String[] args) {try(Reader reader = new FileReader("./test.txt")){//按照字符来读while(true){char[] buffer= new char[1024];int len = reader.read(buffer);if(len == -1){break;}
//                for(int i=0; i<len;i++){
//                    System.out.println(buffer[i]);
//                }//如果传入代表是byte数组，可以通过指定utf-8字符集避免乱码String s = new String(buffer,0,len);System.out.println(s);}} catch (IOException e) {e.printStackTrace();}}
}

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;public class Demo10 {public static void main(String[] args) {try(Writer writer = new FileWriter("./test.txt")){writer.write("aaa");} catch (IOException e) {e.printStackTrace();}}
}

c.通过Scanner进行字符读取

 Scanner存在下面的构造方法，可以使用 charsetName 字符集进行 source 的扫描读取

public Scanner(InputStream source, String charsetName)

import java.io.*;
import java.util.Scanner;public class Demo11 {public static void main(String[] args) throws IOException {try(InputStream is = new FileInputStream("./test.txt")){try(Scanner scanner = new Scanner(is,"utf-8")){while(scanner.hasNext()){String s = scanner.next();System.out.print(s);}}}}
}

3.具体示例

 扫描指定目录，查找包含指定字符的普通文件，并询问后删除指定文件

import java.io.File;
import java.io.IOException;
import java.util.Scanner;public class Demo {public static void main(String[] args) {//1.先输入要扫描的目录，以及要删除的文件Scanner scanner = new Scanner(System.in);System.out.println("请输入要扫描的路径：");String rootDitrPath = scanner.next();System.out.println("请输入要删除的文件名：");String toDeleteName = scanner.next();File rootDir = new File(rootDitrPath);if(!rootDir.isDirectory()){System.out.println("输入的扫描路径有误");return;}//2.遍历目录，把指定目录中的所有文件和子目录都遍历一遍，找到要删除的文件scanDir(rootDir,toDeleteName);}private static void scanDir(File rootDor,String toDeleteName){//1.先列处 rootDir 目录下有哪些内容File[] files = rootDor.listFiles();if(files == null){//rootDir 是一个空目录return;}for(File f:files){if(f.isFile()){if(f.getName().contains(toDeleteName))  //文件名中包含了关键字即可删除deleteFile(f);}else if(f.isDirectory()){  //如果是目录文件，就递归进行遍历scanDir(f,toDeleteName);}}}private static void deleteFile(File f){try{System.out.println(f.getCanonicalPath()+"确定要删除吗？(Y,N)");Scanner scanner = new Scanner(System.in);String choice = scanner.next();if(choice.equals("y") || choice.equals("Y")){f.delete();System.out.println("文件删除成功！");}elseSystem.out.println("文件取消删除！");} catch (IOException e) {e.printStackTrace();}}
}

 文件的复制：用户指定两个文件路径，一个是原路径（被复制的文件），一个是目标路径（复制之后生成的文件）

import java.io.*;
import java.util.Scanner;public class Demo {public static void main(String[] args) {//1.输入两个文件路径Scanner scanner = new Scanner(System.in);System.out.println("请输入要拷贝的源路径：");String src = scanner.next();System.out.println("请输入要拷贝的目标路径：");String dest = scanner.next();File srcFile = new File(src);if(!srcFile.isFile()){System.out.println("输入的源路径不正确");return;}//不需要检查目标文件dest是否存在，OutputStream 写文件的时候能够自动创建不存在的文件//2.读取源文件，拷贝到目标文件中try(InputStream inputStream = new FileInputStream(src)){try(OutputStream outputStream = new FileOutputStream(dest)){byte[] buffer = new byte[1024];while(true){int len = inputStream.read(buffer);if(len == -1)break;//写入指定长度的buffer,可能存在一部分有效数据outputStream.write(buffer,0,len);}}} catch (IOException e) {e.printStackTrace();}}
}

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

import java.io.*;
import java.util.Scanner;public class Demo14 {public static void main(String[] args) throws IOException {//1.输入要扫描的文件路径Scanner scanner = new Scanner(System.in);System.out.println("请输入要扫描的路径：");String rootDirPath = scanner.next();System.out.println("亲输入要查询的关键词：");String word = scanner.next();File rootDir = new File(rootDirPath);if(!rootDir.isDirectory()){System.out.println("输入的源路径不正确");return;}//2.递归进行遍历scanDir(rootDir,word);}private static void scanDir(File rootDir, String word) throws IOException {//1.列出rootDir中有哪些内容File[] files = rootDir.listFiles();if(files==null)return;//2.遍历每个元素，针对普通文件和目录文件分别进行处理for(File f:files){if(f.isFile()){//对文件内容进行查找if(containsWord(f,word)){System.out.println(f.getCanonicalPath());}}else if(f.isDirectory())//针对目录文件进行遍历scanDir(f,word);}}private static boolean containsWord(File f, String word) {//把文件中的内容都读取到一个String中，放到一个StringBuilder中StringBuilder stringBuffer = new StringBuilder();try (Reader reader = new FileReader(f)){char[] buffer = new char[1024];while(true){int len = reader.read(buffer);if(len == -1)break;//结果转化到StringBulider中stringBuffer.append(buffer,0,len);}} catch (IOException e) {e.printStackTrace();}//index返回字串的下下标，若不存在则返回-1return stringBuffer.indexOf(word)!=-1;}
}