Java笔记035-IO流/文件、常用的文件操作、IO流原理及流的分类、IO流体系图-常用的类
目录
IO流
文件
什么是文件
文件流
常用的文件操作
创建文件对象相关构造器的方法
创建文件对象相关构造器和方法
获取文件的相关信息
应用案例
目录的操作和文件删除
应用案例
IO流原理及流的分类
Java IO流原理
流的分类
IO流体系图-常用的类
IO流体系图
InputStream：字节输入流
FileInputStream介绍
FileInputStream应用实例
FileOutputStream介绍
FileOutputStream应用实例1
FileOutputStream应用实例2
编辑FileReader和FileWriter介绍
FileReader相关方法：
FileWriter常用方法
FileReader和FileWriter应用案例
IO流
文件
什么是文件
文件是保存数据的地方，比如word文档，txt文本，excel表格...都是文件，它既可以保存一张图片，也可以保存视频，声音等
文件流
文件在程序中是以流的形式来操作的
流：数据在数据源(文件)和程序(内存)之间经历的路径
输入流：数据从数据源(文件)到程序(内存)的路径
输出流：数据从程序(内存)到数据源(文件)的路径
常用的文件操作
创建文件对象相关构造器的方法
相关方法
new File(String pathname);//根据路径构建一个File对象
new File(File parent, String child);//根据父目录文件+子路径构建
new File(String parent, String child);//根据父目录+子路径构建
createNewFile//创建新文件创建文件对象相关构造器和方法
应用案例演示
- 请在E盘下，创建文件news1.txt、news2.txt、news3.txt，用三种不同的方式创建
package com19.file;
import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.IOException;
/**
* @author 甲柒
* @version 1.0
* @title FileCreate
* @package com19.file
* @time 2023/3/31 9:37
* 演示创建文件
*/
public class FileCreate {
public static void main(String[] args) {
}
//方式1 new File(String pathname);//根据路径构建一个File对象
@Test
public void create01() {
String filePath = "E:\\news1.txt";
File file = new File(filePath);
try {
file.createNewFile();
System.out.println("文件 news1.txt 创建成功~~~");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
//方式2 new File(File parent, String child);//根据父目录文件+子路径构建
//E:\\news.txt
@Test
public void create02() {
File parentFile = new File("E:\\");
String fileName = "news2.txt";
//这里的file对象，在Java程序中，只是一个对象
//只有执行了createNewFile 方法，才会真正的，在磁盘创建该文件
File file = new File(parentFile, fileName);
try {
file.createNewFile();
System.out.println("文件 news2.txt 创建成功~~~");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
//方式3 new File(String parent, String child);//根据父目录+子路径构建
@Test
public void create03() {
String parentPath = "E:\\";
String filePath = "news3.txt";
File file = new File(parentPath, filePath);
try {
file.createNewFile();
System.out.println("文件 news3.txt 创建成功~~~");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
获取文件的相关信息
getName、getAbsolutePath、getParent、length、exists、isFile、isDirectory
应用案例
如何获取文件的大小，文件名，路径，父File，是文件还是目录(目录本质也是文件，一种特殊的文件)，是否存在
package com19.file;
import org.junit.jupiter.api.Test;
import java.io.File;
/**
* @author 甲柒
* @version 1.0
* @title FileInformation
* @package com19.file
* @time 2023/3/31 10:06
*/
public class FileInformation {
public static void main(String[] args) {
}
//获取文件的信息
@Test
public void info() {
//先创建文件对象
File file = new File("E:\\news1.txt");
//调用相应的方法，得到对应信息
System.out.println("文件名=" + file.getName());
//getName、getAbsolutePath、getParent、length、exists、isFile、isDirectory
System.out.println("文件绝对路径=" + file.getAbsolutePath());
System.out.println("文件父级路径=" + file.getParent());
System.out.println("文件大小(字节)=" + file.length());//hello甲柒 11个字节
System.out.println("文件是否存在=" + file.exists());//true
System.out.println("文件是否是一个文件=" + file.isFile());//true
System.out.println("文件是否是一个目录=" + file.isDirectory());//false
}
}
目录的操作和文件删除
mkdir创建一级目录、mkdirs创建多级目录、delete删除空目录或文件
应用案例
- 判断E:\\news1.txt 是否存在，如果存在就删除
- 判断E:\\demo02 是否存在，存在就删除，否则提示不存在
- 判断E:\\demo\\a\\b\\c 目录是否存在，如果存在就提示已经存在，否则就创建
package com19.file;
import org.junit.jupiter.api.Test;
import java.io.File;
/**
* @author 甲柒
* @version 1.0
* @title Directory
* @package com19.file
* @time 2023/3/31 10:22
*/
public class Directory {
public static void main(String[] args) {
}
//判断E:\\news1.txt 是否存在，如果存在就删除
@Test
public void m1() {
String filePath = "E:\\news1.txt";
File file = new File(filePath);
if (file.exists()) {//如果文件存在
if (file.delete()) {//删除该文件并提示
System.out.println(filePath + " 删除成功~~~");
} else {
System.out.println(filePath + " 删除失败！！！");
}
} else {
System.out.println(filePath + " 文件不存在~~~");
}
}
//判断E:\\ 是否存在，存在就删除，否则提示不存在
//在Java编程中，目录也被当成文件
@Test
public void m2() {
String filePath = "E:\\demo02";
File file = new File(filePath);
if (file.exists()) {//如果文件存在
if (file.delete()) {//删除该文件并提示
System.out.println(filePath + " 删除成功~~~");
} else {
System.out.println(filePath + " 删除失败！！！");
}
} else {
System.out.println(filePath + " 目录不存在~~~");
}
}
//判断E:\\demo\\a\\b\\c 目录是否存在，如果存在就提示已经存在，否则就创建
@Test
public void m3() {
String directoryPath = "E:\\demo\\a\\b\\c";
File file = new File(directoryPath);
if (file.exists()) {//如果文件存在
//提示该文件存在
System.out.println(directoryPath + " 文件存在~~~");
} else {//创建该文件
if (file.mkdirs()) {
System.out.println(directoryPath + " 文件创建成功~~~");
} else {
System.out.println(directoryPath + " 文件创建失败~~~");
}
}
}
}
IO流原理及流的分类
Java IO流原理
- I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理数据传输。
如读/写文件，网路通讯等。 - Java程序中，对于数据的输入/输出操作以"流(stream)"的方式进行。
- java.io包下提供了各种"流"类和接口，用以获取不同种类的数据，并通过方法输入或输出数据
- 输入input：读取外部数据(磁盘、光盘等存储设备的数据)到程序(内存)中。
- 输出output：将程序(内存)数据输出到磁盘、光盘等存储设备中。
流的分类
- 按操作数据单位不同分为：字节流(8 bit)，字符流(按字符)
- 按数据流的流向不同分为：输入流，输出流
- 按流的角色的不同分为：节点流，处理流/包装流
| 抽象基类 |
字节流 | 字符流 |
| 输入流 | InputStream | Reader |
| 输出流 | OutputStream | Writer |
- Java的IO流共涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的
- 由这四个类派生出来的子类名称都是以其父类名作为子类名后缀
IO流体系图-常用的类
-
IO流体系图
- 文件VS流
InputStream：字节输入流
InputStream抽象类是所有类字节输入流的超类
InputStream常用的子类
- FileInputStream：文件输入流
- BufferedInputStream：缓冲字节输入流
- ObjectInputStream：对象字节输入流
FileInputStream介绍
FileInputStream应用实例
要求：请使用FileInputStream读取hello.txt文件，并将文件内容显示到控制台
package com19.inputstream_;
import org.junit.jupiter.api.Test;
import java.io.FileInputStream;
import java.io.IOException;
/**
* @author 甲柒
* @version 1.0
* @title FileInputStream_
* @package com19.inputstream_
* @time 2023/3/31 18:55
* 演示FileInputStream的使用(字节输入流 文件--》程序)
*/
public class FileInputStream_ {
public static void main(String[] args) {
}
/**
* 演示读取文件~~~
* 单个字节的读取，效率比较低
* 优化-》使用read(byte[] b)
*/
@Test
public void readFile01() {
String filePath = "E:\\hello.txt";
int readData = 0;
FileInputStream fileInputStream = null;
try {
//创建FileInputStream 对象，用于读取 文件
fileInputStream = new FileInputStream(filePath);
//从该输入流读取一个字节的数据。如果没有输入可用，此方法将阻止
//如果返回-1，表示读取完毕
while ((readData = fileInputStream.read()) != -1) {
System.out.print((char) readData);//转成char显示
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//关闭文件流，释放资源
try {
fileInputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
/**
* 使用read(byte[] b) 读取文件，提高效率
*/
@Test
public void readFile02() {
String filePath = "E:\\hello.txt";
//字节数组
byte[] buf = new byte[8];//一次读8个字节
int readLen = 0;
FileInputStream fileInputStream = null;
try {
//创建FileInputStream 对象，用于读取 文件
fileInputStream = new FileInputStream(filePath);
//从该输入流读取最多b.length字节的数据到字节数组。此方法将阻塞，直到某些输入可用。
//如果返回-1，表示读取完毕
//如果读取正常，返回实际读取的字节数
while ((readLen = fileInputStream.read(buf)) != -1) {
System.out.print(new String(buf, 0, readLen));//显示
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//关闭文件流，释放资源
try {
fileInputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
FileOutputStream介绍
FileOutputStream应用实例1
要求：请使用FileOutputStream在a.txt文件中写入"hello,world"，如果文件不存在，会创建文件(注意：前提是目录已经存在)
package com19.outputstream_;
import org.junit.jupiter.api.Test;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @author 甲柒
* @version 1.0
* @title FileOutputStream01
* @package com19.outputstream_
* @time 2023/3/31 19:56
*/
public class FileOutputStream01 {
public static void main(String[] args) {
}
/**
* 演示使用FileOutputStream 将数据写到文件中，
* 如果文件不存在，则创建该文件
*/
@Test
public void writeFile() {
//创建FileOutputStream对象
String filePath = "E:\\a.txt";
FileOutputStream fileOutputStream = null;
try {
//得到FileOutputStream对象
//说明
//1. new FileOutputStream(filePath); 创建方式，当写入内容是，会覆盖原来的内容
//2. new FileOutputStream(filePath, true); 创建方式，当写入内容是，会追加到文件后面
fileOutputStream = new FileOutputStream(filePath, true);
//写入一个字节
// fileOutputStream.write('H');//
//写入字符串
String str = "hello,world!";
//str.getBytes() 可以把 字符串 -> 字节数组
// fileOutputStream.write(str.getBytes());
/*
public void write(byte[] b,
int off,
int len)
throws IOException
//将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
*/
fileOutputStream.write(str.getBytes(), 0, 4);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
try {
fileOutputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
FileOutputStream应用实例2
要求：编程完成图片/音乐的拷贝
package com19.outputstream_;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @author 甲柒
* @version 1.0
* @title FileCopy
* @package com19.outputstream_
* @time 2023/3/31 21:57
*/
public class FileCopy {
public static void main(String[] args) {
//完成 文件拷贝，将 E:\\钢铁侠0.jpg 拷贝 E:\\钢铁侠1.jpg
//思路分析
//1. 创建文件的输入流，将文件读取到程序
//2. 创建文件的输出流，将读取到的文件数据，写入到指定的文件
String srcFilePath = "E:\\钢铁侠0.jpg";
String destFilePath = "E:\\钢铁侠1.jpg";
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
fileInputStream = new FileInputStream(srcFilePath);
fileOutputStream = new FileOutputStream(destFilePath);
//定义一个字节数组，提高读取效果
byte[] buf = new byte[1024];
int readLen = 0;
while ((readLen = fileInputStream.read(buf)) != -1) {
//读取到后，就写入到文件 通过 fileOutputStream
//即 是一边读 一边写
fileOutputStream.write(buf, 0, readLen);
}
System.out.println("拷贝成功~~~");
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
try {
//关闭输入流和输出流释放资源
if (fileInputStream != null) {
fileInputStream.close();
}
if (fileOutputStream != null) {
fileOutputStream.close();
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
FileReader和FileWriter介绍
FileReader和FileWriter是字符流，即按照字符来操作IO
FileReader相关方法：
- new FileReader(File/String)
- read; //每次读取单个字符，返回该字符，如果到文件末尾返回-1
- read(char[]); //批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1
相关API：
- new String(char[]); //将char[]抓换成String
- new String(char[], off, len); //将char[]的指定部分转换成String
FileWriter常用方法
- new FileWriter(File/String); //覆盖模式，相当于流的指针在首段
- new FileWriter(File/String, true); //追加模式，相当于流的指针在尾端
- write(int); //写入单个字符
- write(char[]); //写入指定数组
- write(char[], off, len); //写入指定数组的指定部分
- write(string); //写入整个字符串
- write(string, off, len); //写入字符串的指定部分
相关API：String类：toCharArray：将String转换成char[]
注意：
FileWriter使用后，必须要关闭(close)或刷新(flush)，否则写入不到指定的文件
FileReader和FileWriter应用案例
要求：
1、使用FileReader从story.txt读取内容，并显示
package com19.reader_;
import org.junit.jupiter.api.Test;
import java.io.FileReader;
import java.io.IOException;
/**
* @author 甲柒
* @version 1.0
* @title FileReader_
* @package com19.reader_
* @time 2023/4/1 14:21
*/
public class FileReader_ {
public static void main(String[] args) {
}
/**
* 单个字符读取文件
*/
@Test
public void readFile01() {
System.out.println("========readFile01=========");
String filePath = "E:\\story.txt";
FileReader fileReader = null;
int data = 0;
//1. 创建FileReader对象
try {
fileReader = new FileReader(filePath);
//循环读取
while ((data = fileReader.read()) != -1) {
System.out.print((char) data);
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
if (fileReader != null) {
try {
fileReader.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
/**
* 字符数组读取文件
*/
@Test
public void readFile02() {
System.out.println("========readFile02=========");
String filePath = "E:\\story.txt";
FileReader fileReader = null;
int readLen = 0;
char[] buff = new char[8];
//1. 创建FileReader对象
try {
fileReader = new FileReader(filePath);
//循环读取 使用read(buff) 返回的是实际读取到的字符数
while ((readLen = fileReader.read(buff)) != -1) {
System.out.print(new String(buff, 0, readLen));
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
if (fileReader != null) {
try {
fileReader.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
}
2、使用FileWriter将"风雨过后，定见彩虹"写入到note.txt文件中，注意细节
package com19.writer_;
import java.io.FileWriter;
import java.io.IOException;
/**
* @author 甲柒
* @version 1.0
* @title FileWriter_
* @package com19.writer_
* @time 2023/4/1 14:41
*/
public class FileWriter_ {
public static void main(String[] args) {
String filePath = "E:\\note.txt";
FileWriter fileWriter = null;
char[] chars = {'a', 'b', 'c'};
try {
fileWriter = new FileWriter(filePath);
//write(int); //写入单个字符
fileWriter.write('Q');
//write(char[]); //写入指定数组
fileWriter.write(chars);
//write(char[], off, len); //写入指定数组的指定部分
fileWriter.write("甲柒".toCharArray(), 0, 1);
//write(string); //写入整个字符串
fileWriter.write(" hello,world!你好");
fileWriter.write("风雨过后，定见彩虹");
//write(string, off, len); //写入字符串的指定部分
fileWriter.write("北京郑州", 0, 2);
//在数据量大的情况下，可以用循环操作
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//对应FileWriter，一定要关闭流，或者flush才能真正的把数据写入到文件
//看源码分析
/*
private void writeBytes() throws IOException {
this.bb.flip();
int var1 = this.bb.limit();
int var2 = this.bb.position();
assert var2 <= var1;
int var3 = var2 <= var1 ? var1 - var2 : 0;
if (var3 > 0) {
if (this.ch != null) {
assert this.ch.write(this.bb) == var3 : var3;
} else {
this.out.write(this.bb.array(), this.bb.arrayOffset() + var2, var3);
}
}
this.bb.clear();
}
*/
try {
// fileWriter.flush();
//关闭文件流 等价于 flush() + 关闭
fileWriter.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
System.out.println("程序结束~~~~");
}
}
