【JavaEE】——文件IO
阿华代码，不是逆风，就是我疯
你们的点赞收藏是我前进最大的动力！！
希望本文内容能够帮助到你！！
目录
一：认识文件
1：文件的概念
对于计算机来说，“文件”是一个非常广义的概念，可以指普通的文件，文件夹，一些硬件设备也被抽象成了文件（例如：键盘，耳机，显示器，网卡等）
对于机械硬盘来说它更加擅长顺序读写，不擅长随机读写
比如有一个很大的文件，我们需要把这个文件整体复制一份就是顺序读写
某个目录中有很多的小文件，（数目比较多）需要把整个目录都拷贝一份，就是随机读写。
2：文件的结构
文件系统的结构是按照“树形结构”来组织文件的，是N叉树，一个普通文件（非目录）就是一个叶子节点，对一个目录文件来说，里面又可以有很多的子节点
3：文件路径
形如上述的图片，从树根节点，一级一级的往下走，直到直到目标文件，这个过程中经过的所有文件目录的名字串起来，使用正斜杠——“/”，或者反斜杠——“\”分割，就构成了“路径”
注：此过程并非是遍历树，可以想象成类似于Hash这样的结构
（1）绝对路径
从树根节点 出发，一层一层到达目标文件
（2）相对路径
先指定一个“当前目录”/“基准目录”，从当前目录出发，找到目标文件
（3）举例
二：文件的分类
1：文本文件
文本文件是按照“字符串”的形式来理解文本内容的（文本文件里面的二进制内容，也都表示为字符串，可以理解为——二进制内容都是合法的字符（像字符编码，英文字母用ASCII，汉字用utf8/gbk））
举例：.java .c .cpp 文本文档
2：二进制文件
二进制文件没有上述的限制，储存任何数据都可以。
举例：图片，音频，可执行程序，动态库，.class文件，富文本文件
富文本文件包括不限于：word docx excle xlsx power point pptx
3：如何判断文件的种类
使用记事本打开文本文件，如果看到的是乱码，就是二进制文件
三：Feil类对文件操作
引入：在Java中，对于文件操作的Api这里有两类
针对文件系统的操作：创建，删除，重命名，
针对文件内容的操作：读文件，写文件
1：Feil类
2：File类的构造方法
3：获取属性方法
代码示例一
构造File用绝对路径
import java.io.File;
import java.io.IOException;
public class IO1 {
public static void main(String[] args) throws IOException {
File f = new File("C:/User/1/test.txt");//绝对路径
//File f = new File("./test.txt");
System.out.println(f.exists());//判断文件目录是否存在
System.out.println(f.getParent());
System.out.println(f.getName());//返回file对象的名称
System.out.println(f.getPath());//返回file对象的文件路径
System.out.println(f.getAbsolutePath());//返回绝对路径
System.out.println(f.getCanonicalPath());//返回对象修饰过后的路径canonical规范的
}
}
代码示例二
构造对象用相对路径
.getPath()得到的就是构造方法中的参数
Canonical（读音：克挠你扣）规范的——可以理解为化简路径
import java.io.File;
import java.io.IOException;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-10-01
* Time: 19:28
*/
public class IO1 {
public static void main(String[] args) throws IOException {
//File f = new File("C:/User/1/test.txt");//绝对路径
File f = new File("./test.txt");
System.out.println(f.exists());//判断文件目录是否存在
System.out.println(f.getParent());//返回父目录文件路径
System.out.println(f.getName());//返回file对象的名称
System.out.println(f.getPath());//返回file对象的文件路径
System.out.println(f.getAbsolutePath());//返回绝对路径
System.out.println(f.getCanonicalPath());//返回对象修饰过后的路径canonical规范的
}
}
4：判断方法
我们可以使用file.createNewFile（如下代码），也可以直接手动在当前目录创建一个File文件——名字叫test.txt
import java.io.File;
import java.io.IOException;
public class IODemon2 {
public static void main(String[] args) throws IOException {
File file = new File("./test.txt");
System.out.println(file.exists());//文件存在吗
System.out.println(file.isFile());//是普通文件嘛
System.out.println(file.isDirectory());//是目录吗
boolean ret = file.createNewFile();//创建文件；返回的结果就是创建成功和创建失败
System.out.println("ret:" + ret);
}
}
5：创建删除方法
file.delete删除文件，返回值类型为boolean类型
file.deleteNewFile退出时删除文件，返回值为void
注：删除目录只能一级一级的删除
import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
import java.io.File;
import java.io.IOException;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-10-01
* Time: 20:17
*/
public class IODemon3 {
public static void main(String[] args) throws IOException, InterruptedException {
File file = new File("./test.txt");
//boolean ret = file.delete();//删除文件
//System.out.println(ret);
boolean ret = file.createNewFile();//创建文件
file.deleteOnExit();//返回值为void类型，退出的时候删除文件，测试的时候注意看左边的目录栏
Thread.sleep(5000);
}
}
6：创建移动方法
import java.io.File;
import java.util.Arrays;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-10-01
* Time: 20:44
*/
public class IODemon4 {
public static void main(String[] args) {
File file = new File(".");
//返回的是对象代表的目录下所有的文件
//返回的是一个String[]类型的数组
String[] files = file.list();
System.out.println(Arrays.toString(files));
//返回的file对象代表的目录下所有的文件，不过是以file对象表示
File[] files2 = file.listFiles();
System.out.println(Arrays.toString(files2));
}
}
7：创建File对象代表的目录
import java.io.File;
import java.lang.reflect.Field;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-10-01
* Time: 20:58
*/
public class IODemon5 {
public static void main(String[] args) {
/* File file = new File("./aaa");//创建file为对象的目录
boolean ret = file.mkdir();
System.out.println(ret);*/
/* File file = new File("./bbb");
boolean ret2 = file.mkdirs();//mkdirs（可以用于创建单个目录，也可以用于创建多级目录）
System.out.println(ret2);*/
/*File file = new File("./aaa/bbb/ccc");
boolean ret2 = file.mkdirs();//mkdirs（可以用于创建单个目录，也可以用于创建多级目录）
System.out.println(ret2);*/
File file = new File("./bbb");
boolean ret = file.delete();//删除只能一级目录一级目录的删
System.out.println(ret);
}
}
8：文件改名操作
注意细节：file1文件改名为file2对象
import java.io.File;
public class IODemon6 {
public static void main(String[] args) {
File file1 = new File("./aaa/bbb/ccc/bbb");
File file2 = new File("./bbb");
boolean ret = file2.renameTo(file1);//把bbb这个文件移入"./aaa/bbb/ccc"的/ccc下
System.out.println(ret);
}
}
四：文件流
什么是文件流呢？
举个例子：要写100字节的内容，我们可以分10次写每次写10字节的内容，也可以分5次来写，每次写20字节的内容;当然也可以一次性写完
“流”是操作系统提供的概念，Java标准库中对于“进行了”封装，提供了一组类来负责这些工作
我们把这些类主要分为两种：字节流和字符流
五：字节流
代表类：InputStream——输入流，OutPutStream——输出流
1：InputStream
（0）打开文件
按照读文件的方式打开一个文件
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-10-02
* Time: 11:46
*/
public class IODemon7 {
public static void main(String[] args) throws IOException {
/*
//打开文件
InputStream inputStream = new FileInputStream("./test.txt");
//在中间一定会涉及一些对文件的操作之类的，如果遇到bug或者像return之类的不可控的操作，close操作可能就会执行不到了
//打开了文件最后还要关掉，打开文件操作会抛出FileNotFoundException异常
inputStream.close();
//关闭文件会抛出IOException异常，前后两者为父类子类的关系
*/
/*
//第二种写法
InputStream inputStream = null;
try {
inputStream = new FileInputStream("./test.txt");
}finally{
inputStream.close();
}
*/
/*
//第三种写法，try with resources版本
try (InputStream inputStreeam = new FileInputStream("./test.txt")){
//出了try{}代码块范围后，编译器会自动调用.close方法关闭文件
//FileInputStream继承于InputStream，InputStream又实现了Closeable接口，必须实现了Closeable接口才可以被放到try（）里面
}
*/
}
}
（1）构造方法
注：你给cpu送的信息叫输入，比如读操作。cpu给存储器等这些硬件设备送的信息叫做输出，比如写操作
（2）类/异常解析
（3）文件资源泄露
如果不执行文件关闭.close方法，就会有大问题。这里本质上是释放了文件的相关资源（PCB文件描述符表，不懂得铁子可以看前面写过的文章）这个表本质是一个数组或者顺序表，每打开一个文件，就会占据一个位置，如果不关闭一直打开就会导致表被耗尽，后续再想打开就会报错。
那么提问，文件描述符表不会动态扩容吗？对操作系统的内核来说，需要很高的性能，付出的代价太大了，容易造成系统的卡顿
（4）：read方法
①引入
read读文件就是把硬盘数据读取到内存当中buffer，译为缓冲区
注意点①：offset此处缩写了
注意点②：传入的数组，在方法内部对数组内容修改过后，方法外部也能生效
注意点③：字符流读取文件的时候，
②三种参数代码示例
①*不带参数的读，一个一个字符的读
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-10-02
* Time: 12:18
*/
public class IOStream8 {
public static void main(String[] args) throws IOException {
try(InputStream inputStream = new FileInputStream("./test.txt")){
//读取操作,读到-1的时候就会停止
while(true){
int a = inputStream.read();
if (a == -1){
break;
}
System.out.print(a + " ");//读取的abcdef是ascii码值
}
}
}
}
②*带入数组参数的读取，一次读取多个字符
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-10-02
* Time: 12:56
*/
public class IODemon9 {
public static void main(String[] args) throws IOException {
try(InputStream inputStream = new FileInputStream("./test.txt")){
while (true){
//也可以一次读若干个字节,buffer(缓冲区)
byte[] buffer = new byte[1024];//读的时候会尝试把buffer[1024]填满
int n = inputStream.read(buffer);//传入的参数是buffer数组，方法内部对数组内容进行修改后，方法外部也能生效，实际上填不满1024个字节，
if (n == -1){
break;//读取到最后一个字符，就break
}
for (int i = 0; i < n; i++) {
System.out.printf(" %x " ,buffer[i]);//遍历数组，并打印
}
}
}
}
}
③*构造String从0读到n（利用offset）
offset翻译为抵消补偿
注意看while循环：什么是文件流，假设我们要读取的文件很大，在这个循环中，每次尽可能读取1024个字节（可能读到的字节数比这个要小），这次读不完，我们就先用String给存起来（0到n），下一次while循环就接着读，“特别像字符串拼接 ”
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-10-02
* Time: 13:22
*/
public class IODemon10 {
public static void main(String[] args) throws IOException {
try(InputStream inputStream = new FileInputStream("./test.txt")){
while (true){
//也可以一次读若干个字节,buffer(缓冲区)
byte[] buffer = new byte[1024];//读的时候会尝试把buffer[1024]填满
int n = inputStream.read(buffer);//传入的参数是buffer数组，方法内部对数组内容进行修改后，方法外部也能生效
if (n == -1){
break;
}
String string = new String(buffer , 0 , n);//构造一个String对象，数组前n个字节来构造
System.out.printf(string);//遍历数组，并打印
}
}
}
}
2：OutputStream
按照写的方式打开文件
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-10-05
* Time: 12:06
*/
public class IODemo11 {
public static void main(String[] args) throws FileNotFoundException {
try{
//打开操作会把原有文件中的内容清空，所以罪魁祸首不是Write操作而是打开操作
OutputStream outputStream = new FileOutputStream("./test.txt");
//OutputStream outputStream = new FileOutputStream("./test.txt",true);追加写
byte[] buffer = new byte[]{97,98,99,100,101};
outputStream.write(buffer);
}catch (IOException e) {
throw new RuntimeException(e);
}
}
}
3：Scanner联动
Scanner（System.in）中System.in本质就是一个InputStream
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-10-05
* Time: 13:21
*/
public class IODemo14 {
public static void main(String[] args) throws FileNotFoundException {
try(InputStream inputStream = new FileInputStream("./test.txt")){
Scanner scanner = new Scanner(inputStream);
while(scanner.hasNext()){
String s = scanner.next();
System.out.println(s);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
六：字符流
以字符为单位进行读写，例如：用utf8表示汉字，3个字节就是一个汉字，每次读写都得以3个字节为单位来进行读写，不能一次读半个汉字
在用char类型的数组存储汉字时是把3个字节组成的utf8汉字转化为了Unicode，输出为String类型时在把Unicode转化为字节
代表类：Reader——输入，Writer——输出
1：Reader类
代码示例
把byte换为char测试一下，区别在于打印汉字
import java.io.*;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-10-05
* Time: 12:33
*/
public class IODemo12 {
public static void main(String[] args) {
try{
//Reader和Writer的字符流与OutputStream和InputStream相似
Reader reader= new FileReader("./test.txt");
while(true){
char[] buffer = new char[1024];
int n = reader.read(buffer);
if (n == -1){
break;
}
String s = new String(buffer , 0 , n);
System.out.println(s);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
如果文件中有内容换行操作了，那么有可能会有一些内容打印不到
2：Writer类
记住：要把文件打开操作放到try（）的括号里，要不然不会默认执行close关闭文件操作
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-10-05
* Time: 13:07
*/
public class IODemo13 {
public static void main(String[] args) {
try(Writer writer = new FileWriter("./test.txt",true)) {
String s = "可选择续写操作 或者 清空在写操作";
writer.write(s);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
原文地址：https://blog.csdn.net/2301_80133875/article/details/142670312
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！