目录
一、File类
1、File类概述
- java.io.File类：一个java.io.File类的对象，表示文件和文件目录路径（就是文件夹）
- File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。
- 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对 象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。
- 经典应用场景：File对象可以作为参数传递给流的构造器。
2、File类实例化
- 构造器
路径
- 绝对路径：是一个固定的路径,从盘符开始
- 相对路径：是相对于某个位置开始。在IDEA中是相对于当前的module
路径分隔符
- windows和DOS系统默认使用“\”来表示
- UNIX和URL使用“/”来表示
- Java程序支持跨平台运行，因此路径分隔符要慎用。为了解决这个隐患，File类提供了一个常量：
public static final String separator，根据操作系统，动态的提供分隔符。 - 举例
File file1 = new File("d:\\atguigu\\info.txt"); File file2 = new File("d:" + File.separator + "atguigu" + File.separator + "info.txt"); File file3 = new File("d:/atguigu");
3、File类常用方法
- **获取
- 重命名
public boolean renameTo(File dest)：把文件重命名为指定的文件路径。（实际上就是把file1的内容复制到file2，并把file1删除）
对于 file1.renameTo(file2)要求：file1存在，file2不存在
- 判断
- 创建和删除
如果你创建文件或者 文件 目录没有写盘符路径 ， 那么 ，默认在项目路径下。
二、IO流的原理
1、IO流的原理
- I/O是input/output的缩写，IO技术用于设备之间的数据传输。（如。读/写文件、网络通讯）
- Java程序中，数据的输入/输出操作以“流(stream)” 的方式进行。
- java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
2、input和output的理解
- 首先对于入和出，我们是站在程序的角度来说的，想象自己身处程序内部。
- input：磁盘、光盘等存储设备的数据----->程序、内存
- output：程序、内存中的数据----->磁盘、光盘等存储设备
三、IO流的分类
1、分类
√√√按操作的数据单位不同分为：字节流（8bit）、字符流（16bit）。字节流适合操作图片、视频等文件，字符流适合操作文本文件。
按数据流的流向不同分为：输入流、输出流。
按流的角色不同分为：**节点流、处理流。
节点流：直接从数据源或目的地读写数据。也叫文件流
处理流：不直接连接到数据源或目的地，而是“连接”在已存 在的流（节点流或处理流）之上，通过对数据的处理为程序提 供更为强大的读写功能
2、图示
3、四个抽象基类
4、IO流体系
四、FileReader和FileWriter
1、IDEA中单元测试方法和main()下相对路径对比
- 单元测试方法下的相对路径是：相较于当前module而言
- main()下的相对路径：相较于当前工程而言
2、使用FileReader读入数据
- 最初的代码实现
public void test1() throws IOException {
//1.实例化File类,指明要操作的对象.这一步的目的是建立硬盘中的文件和Java中类的对应关系.
File file = new File("hello1.txt");
//2.提供具体的流.参数的作用就是帮助我们并连接上文件这个"大水库"
FileReader fileReader = new FileReader(file);
//3.用流读取到内存
//read():返回读入的字符,是int需要转换为char.到了文件结尾返回-1
int read = fileReader.read();
while (read != -1) {
System.out.print((char) read);
read = fileReader.read();
}
//4.关闭流
fileReader.close();
}
//整个过程结合图示去理解很合理
- 改进后的代码实现
/*
优化:
1.第三部可以在语法上的优化,但是效率其实是一样的
2.为了保证关闭操作一定执行,使用try-catch-finally
3.读入的文件一定要存在,否则会出现:FileNotFoundException
*/
public void test2() {
FileReader fileReader = null;
try {
File file = new File("hello1.txt");
fileReader = new FileReader(file);
//改进1
int read;
while ((read = fileReader.read()) != -1){
System.out.print((char) read);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fileReader != null)
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
- 使用缓冲流改进（这个是用的最多的★★★★★）
//使用数组
char[] charBuffer = new char[5];
int len;//记录每次读入到charBuffer数组中的字符个数
while ((len = fileReader.read(charBuffer)) != -1){
for (int i = 0; i < len; i++) {//这里要用len(读取的字符数)二不是数组的长度
System.out.print(charBuffer[i]);
}
}
//当然for循环也可以换位String的构造器来把字符串数组转换为String
String string = new String(charBuffer, 0, len);
System.out.print(string);
3、使用FileWriter写出数据
- 代码实现
File file = new File("hello2.txt");
FileWriter fw = new FileWriter(file);
fw.write("i have a dream!");
fw.close();
//最后用try-catch处理一下异常，上面的步骤更清晰一些
- 说明
- 输出时，File可以不存在，不会报异常。
- File对应的硬盘的文件如果不存在，自动创建
- File对应的硬盘的文件如果存在
- 如果流使用的构造器是FileWriter(file, false)/FileWriter(file)，对原有的文件进行覆盖
- 如果流使用的构造器是FileWriter(file, true)，对原有的文件进行追加
4、使用FileReader和FileWriter复制文本文件
- 代码实现
public void test5() throws IOException {
File srcFile = new File("hello2.txt");
File destFile = new File("hello3.txt");
FileReader fr = new FileReader(srcFile);
FileWriter fw = new FileWriter(destFile);
char[] charBuffer = new char[5];
int len;
while ((len = fr.read(charBuffer)) != -1) {
fw.write(charBuffer, 0, len);//和用String来取是类似的★★★★★
}
fw.close();
fr.close();
}
//最后用try-catch处理一下异常，上面的步骤更清晰一些
5、使用FileReader和FileWriter不能处理图片的复制的测试
- 当把hello.txt文本文件改为图片文件时，发现代码是可以正常运行，但是复制结果并不对，新图片打不开。
- 这是因为，图片是用字节来存储的。用字符流来处理显然不行。
五、FileInputStream和FileOutputStream
1、用FileInputStream和FileOutputStream处理文本文件会怎样？
- 结论
- 输出到控制台时：英文不乱码，中文可能会乱码
- 单纯复制，而不在内存层面查看：不会乱码，是可以的。
- 解释
- 对于英文，utf-8和gbk都是用一个字节（4bit位）来存一个字母，因此每个字母都是完完整整的存入byte数组，从而能完整的复制过去。
- 对于中文，utf-8中用的是三个字节来存一个汉字，那么字节数组中的数据在输出时，不确定在哪里截断，就会出现一部分字的乱码。
2、确定使用字符流还是字节流
- 对于文本文件（.txt, .java, .cpp），使用字符流
- 对于非文本文件（.jpg, .mp3, .mp4, .avi, .doc, .ppt...），使用字节流
3、用FileInputStream和FileOutputStream复制图片
- 同“使用FileReader和FileWriter复制文本文件”，只要
- 使用FileInputStream和FileOutputStream
- 把数组改为byte数组
六、缓冲流
1、缓冲流有哪些
BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter
2、作用
- 提高读写速度
3、原因
- 在使用这些流类时，会创建一个内部缓冲区数组，缺省使用8192个字节(8Kb)的缓冲区。
- 当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区。
- 当使用BufferedInputStream读取字节文件时，BufferedInputStream会一次性从文件中读取8192个(8Kb)，存在缓冲区中，直到缓冲区装满了，才重新从文件中读取下一个8192个字节数组。
- 向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满， BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。
- 使用方法 flush()可以强制将缓冲区的内容全部写入输出流。
- 如果是带缓冲区的流对象的close()方法，不但会关闭流，还会在关闭流之前刷 新缓冲区，关闭后不能再写出。
- 填坑：自己写代码的时候忘记关闭流操作，导致复制的图片打不开的原因就是，没有关闭流，缓冲区内还有一部分数据没能复制过去。
4、使用缓冲流复制图片
public void test() throws IOException {
//1.创建File
File srcFile = new File("img1.png");
File destFile = new File("img2.png");
//2.创建流
//2.1创建文件流
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
//2.2创建字节流
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
//3.复制
byte[] bytes = new byte[10];
int len;
while ((len = bis.read(bytes)) != -1){
bos.write(bytes,0,len);
}
//4.关闭流
bis.close();
bos.close();
}
- 关闭外层的流的同时，会自动关闭内层的流。所以只写外层的关闭操作就可以。
5、使用缓冲流复制文本文件
public void test1() throws IOException {
//1.创建文件和流
BufferedReader br = new BufferedReader(new FileReader(new File("hello1.txt")));
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("hello4.txt")));
// //2.复制
// char[] chars = new char[10];
// int len;
// while ((len = br.read(chars)) != -1) {
// bw.write(chars, 0, len);
// }
// 复制:用String来实现★★★★★★★★★★★
String data;//但是是不带换行的,可以用一以下两种方法实现
while ((data = br.readLine()) != null) {
// //方法一★★★★★★★★
// bw.write(data + "\n");
//方法二★★★★★★★★
bw.write(data);
bw.newLine();
}
//3.关闭
br.close();
bw.close();
}
6、练习：统计文本每个字符出现次数
七、转换流
1、什么是转换流
- 转换流提供了在字节流和字符流之间的转换
- 转换流属于字符流
- Java API提供了两个转换流
- InputStreamReader：将InputStream转换为Reader
- 构造器一：
public InputStreamReader(InputStream in)默认使用utf-8字符集 - 构造器二：
public InputSreamReader(InputStream in,String charsetName)可以自己选择字符集。
- 构造器一：
- OutputStreamWriter：将Writer转换为OutputStream
- 构造器和上面类似
- InputStreamReader：将InputStream转换为Reader
- 字节流中的数据都是字符时，转成字符流操作更高效。
- 很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能。
2、编码与解码
- 编码：字节、字节数组--->字符数组、字符串
- 解码：字符数组、字符串--->字节、字节数组
3、字符集
- 什么是编码表：计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识 别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。 这就是编码表。
- 常见编码表
4、转换流的作用示意图
5、练习题
- 综合使用：将文本文件从utf-8转换为gbk编码
- 代码实现
@Test
public void test2() throws Exception {
//1.造文件、造流
File file1 = new File("dbcp.txt");
File file2 = new File("dbcp_gbk.txt");
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
InputStreamReader isr = new InputStreamReader(fis,"utf-8");
OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
//2.读写过程
char[] cbuf = new char[20];
int len;
while((len = isr.read(cbuf)) != -1){
osw.write(cbuf,0,len);
}
//3.关闭资源
isr.close();
osw.close();
}
八、标准输入输出流（了解）
1、简介
- 标准输入流：System.in。默认输入设备是键盘。类型是InputStream。
- 标准输出流：System.out。默认输出设备是控制台。类型是PrintStream，是OutputStream的子类。
2.练习
- 题目：从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续 进行输入操作，直至当输入“e”或者“exit”时，退出程序。
- 代码实现
public class Exercise {
public static void main(String[] args) {//idea不支持在单元测试中输入内容,所以改用main()来测试
BufferedReader br = null;
try {
InputStreamReader isr = new InputStreamReader(System.in);
br = new BufferedReader(isr);
while (true) {
System.out.println("请输入字符串: ");
String data = br.readLine();
if ("e".equalsIgnoreCase(data)||"exit".equalsIgnoreCase(data)){
System.out.println("程序结束");
break;
}
String upperCase = data.toUpperCase();
System.out.println(upperCase);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (br != null) {
br.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
九、打印流（了解）
1、打印流简介
- 实现将基本数据类型的数据格式转化为字符串来输出
- 包含两个：PrintStream和PrintWriter
- 提供了一系列重载的print()和println()方法，用于多种数据类型的输出
- System.out返回的是PrintStream的实例
2、代码演示
- 把标准输出流(控制台输出)改成文件
PrintStream ps = null;
try {
FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt")); // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
ps = new PrintStream(fos, true);
if (ps != null) {// 把标准输出流(控制台输出)改成文件
System.setOut(ps);
}
for (int i = 0; i <= 255; i++) { // 输出ASCII字符
System.out.print((char) i);
if (i % 50 == 0) { // 每50个数据一行
System.out.println(); // 换行
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
if (ps != null) {
ps.close();
}
}
十、数据流（了解）
1、简介
引入：为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流
数据流有两个类：(用于读取和写出基本数据类型、String类的数据，方便持久化）
DataInputStream 和 DataOutputStream
DataInputStream中的方法
boolean readBoolean()
char readChar()
double readDouble()
long readLong()
String readUTF()
byte readByte()
float readFloat()
short readShort()
int readInt() void
readFully(byte[] b)
DataOutputStream中的方法
将上述的方法的read改为相应的write即可
2、练习
练习：将内存中的字符串、基本数据类型的变量写出到文件中。
注意：处理异常的话，仍然应该使用try-catch-finally.
*/
@Test
public void test3() throws IOException {
//1.
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
//2.
dos.writeUTF("刘建辰");
dos.flush();//刷新操作，将内存中的数据写入文件
dos.writeInt(23);
dos.flush();
dos.writeBoolean(true);
dos.flush();
//3.
dos.close();
}
/*
将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。
注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！
*/
@Test
public void test4() throws IOException {
//1.
DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
//2.
String name = dis.readUTF();
int age = dis.readInt();
boolean isMale = dis.readBoolean();
System.out.println("name = " + name);
System.out.println("age = " + age);
System.out.println("isMale = " + isMale);
//3.
dis.close();
}
十一、对象流
1、简介
- 包含：两个类ObjectInputStream和ObjectOutputStream
- 是：用于存储和读取基本数据类型数据或对象的处理流
- 强大之处：可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
2、对象的序列化★★★★★
什么是对象的序列化机制（面试题）
- 一方面，对象的序列化机制允许内存中的Java对象转换为平台无关的二进制流。从而允许吧二进制流持久化到磁盘，或，通过网络传给另一个网络节点；
- 另一方面，其他程序获取了二进制流，就可以恢复成原来的Java对象。
序列化的好处：可将任何实现了Serializable接 使其在保存和传输时可被还原。
3、代码实现String类的对象的序列化和反序列化
public class ObjectInputOutputStream {
/*
代码实现String类的对象的序列化和反序列化
*/
@Test//序列化
public void testObjectOutputStream(){
ObjectOutputStream oos = null;
try {
//1.造流和文件
oos = new ObjectOutputStream(new FileOutputStream(new File("objectString.dat")));
//2.写出
oos.writeObject(new String("我爱你中国"));
} catch (IOException e) {
e.printStackTrace();
} finally {
//3.关闭流
try {
if (oos != null) {
oos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
public void testObjectInputStream(){
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream(new File("objectString.dat")));
Object readObject = ois.readObject();
System.out.println(readObject);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
try {
if (ois != null) {
ois.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
4、自定义类的序列化
- 要求
- 实现Serializable接口（这是一个标识接口，内部没有方法）
- 提供一个全局常量
public static final long serialVersionUID = xxxxxxxxL;- 如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自 动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。故建议， 显式声明。
- 还要保证类的所以属性也是可序列化的。
- 基本数据类型是可序列化的
- 注意：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
- 因为static修饰的变量是类所有的
- 不想序列化的就可以用transient
5、面试题
- 谈谈你对java.io.Serializable接口的理解，我们知道它用于序列化， 是空方法接口，还有其它认识吗？
- 实现了Serializable接口的对象，可将它们转换成一系列字节，并可在以后 完全恢复回原来的样子。这一过程亦可通过网络进行。这意味着序列化机 制能自动补偿操作系统间的差异。换句话说，可以先在Windows机器上创 建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里 准确无误地重新“装配”。不必关心数据在不同机器上如何表示，也不必 关心字节的顺序或者其他任何细节。
- 由于大部分作为参数的类如String、Integer等都实现了 java.io.Serializable的接口，也可以利用多态的性质，作为参数使接口更 灵活。
十二、RandomAccessFile
1、简介
- RandomAccessFile，随机存取文件流，直接继承于java.lang.Object类。
- 随机：RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。 RandomAccessFile 类对象可以自由移动记录指针
- long getFilePointer()：获取文件记录指针的当前位置
- void seek(long pos)：将文件记录指针定位到 pos 位置（这是他的灵魂所在）
- 应用场景：可以多线程断点下载同一文件再拼接起来；下载不完，下次接着下载。
- 存取：实现了DataInput、DataOutput两个接口，所以这个类既可以读也可以写**。
- 可以用构造器里的参数决定是输出流还是输入流。
- public RandomAccessFile(File file, String mode)
- public RandomAccessFile(String name, String mode)
- mode参数指定了访问模式
- r: 以只读方式打开 （常用）
- rw：打开以便读取和写入 （常用）
- rwd:打开以便读取和写入；同步文件内容的更新
- rws:打开以便读取和写入；同步文件内容和元数据的更新
- 可以用构造器里的参数决定是输出流还是输入流。
2、用RandomAccessFile类实现文本文件的复制
@Test
public void test1() throws IOException {
//用参数mode标识,让类代表输入
RandomAccessFile r = new RandomAccessFile(new File("hello1.txt"), "r");
//用参数mode标识,让类代表输出
RandomAccessFile rw = new RandomAccessFile(new File("hello5.txt"), "rw");
byte[] bytes = new byte[1024];
int len;
while ((len=r.read(bytes)) != -1){
rw.write(bytes,0,len);
}
r.close();
rw.close();
}
3、用 RandomAccessFile作为输出流时的特点
- 如果写出到的文件不存在，就创建
- 如果写出到的文件存在，会对原文从头开始进行覆盖，能覆盖多少算多少。
4、如何使用 RandomAccessFile对文本文件实现插入效果
/*
使用RandomAccessFile实现数据的插入效果
*/
@Test
public void test3() throws IOException {
RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");
raf1.seek(3);//将指针调到角标为3的位置
//保存指针3后面的所有数据到StringBuilder中
StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
byte[] buffer = new byte[20];
int len;
while((len = raf1.read(buffer)) != -1){
builder.append(new String(buffer,0,len)) ;
}
//调回指针，写入“xyz”
raf1.seek(3);
raf1.write("xyz".getBytes());
//将StringBuilder中的数据写入到文件中
raf1.write(builder.toString().getBytes());
raf1.close();
}
十三、第三方jar包的使用
1、为什么使用
- 第三方jar包提供了很多方便高效的API，方便我们开发中使用，实际开发中也是用这些jar包来提高工作效率，而不只是根据JDK提供的API，因为有些不够简练。
2、IDEA中导入第三方jar包
- 当前module下创建名为lib或libs的directory
- 复制第三方jar包到lib目录
- 右键jar包，选择 add as library
- 搞定
3、用第三方jar包实现文件复制
public class JarTest {
public static void main(String[] args) throws IOException {
File srcFile = new File("s6_IO/hello1.txt");
File destFile = new File("s6_IO/hello6.txt");
FileUtils.copyFile(srcFile,destFile);
}
}