目录
缓冲流
缓冲字节输入流：
缓冲字节输出流：
缓冲字符输入流：
缓冲字符输出流：
转换流
转换流字符输入：
转换流字符输出：
练习案例：
打印流
字节打印流：
字符打印流：
数据流
数据输入流：
数据输出流：
序列化流（对象流）
对象输入流：
输入多个对象：
对象输出流：
IO框架
常用方法：
FileUtils：
IOUtils：
缓冲流
缓冲字节输入流：
读数据时：它先用原始字节输入流一次性读取8KB的数据存入缓冲流内部的数组中（ps: 先一次多囤点货），再从8KB的字节数组中读取一个字节或者多个字节（把消耗屯的货）。
案例：
BufferedInputStream bufferedInputStream = new BufferedInputStream(FileInputStream fis);
获取字节缓冲输入流对象。
sif：字节输入流对象，用来获取文件的位置。
package com.zsh.day2.字节缓冲流;
import java.io.*;
/**
* 字节缓冲输入流
*/
public class BufferedInputStreamDemo {
public static void main(String[] args) {
try (
// 获取字节缓冲输入流对象
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("abc\\1.txt"));
) {
// 缓冲字节流：循环读取文件中的所有内容
// 读取文件中的内容
byte[] buf = new byte[1024 * 8];
// 每次读取的字节数量
int len;
// 循环读取文件中的所有内容
while ((len = bufferedInputStream.read(buf)) != -1) {
// 输出读到的内容
System.out.println(new String(buf));
}
}catch (IOException e) {
throw new RuntimeException(e);
}
}
}
缓冲字节输出流：
写数据时： 它是先把数据写到缓冲流内部的8BK的数组中（ps: 先攒一车货），等数组存满了，再通过原始的字节输出流，一次性写到目标文件中去（把囤好的货，一次性运走）。
案例：
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(FileOutputStream() fos);
获取字节缓冲流输出对象。
fos：用来设置字节缓冲流输出后保存文件的路径地址。
package com.zsh.day2.字节缓冲流;
import java.io.*;
/**
* 字节缓冲输出流
*/
public class BufferedOutputStreamDemo {
public static void main(String[] args) {
try (
// 获取字节缓冲输出流对象
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("abc\\1.txt",true));
) {
// 定义写入内容
byte[] buf = new byte[]{99,100};
// 写入
bufferedOutputStream.write(buf);
}catch (IOException e) {
throw new RuntimeException(e);
}
}
}缓冲字符输入流：
BufferedReader读数据时：它先原始字符输入流一次性读取8KB的数据存入缓冲流内部的数组中（ps: 先一次多囤点货），再从8KB的字符数组中读取一个字符或者多个字符（把消耗屯的货）。
案例：
BufferedReader bufferedReader = new BufferedReader(FileReader(String str) fr);
获取字符输入流对象。
fr：字符输入流对象，用来获取文件的位置。
int ch = bufferedReader.read();
每次读取一个字符，返回int，没有数据返回-1。
String line = bufferedReader.readLine()
每次读取一行字符，返回String，没有数据返回null。
package com.zsh.day2.字符缓冲流;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/**
* 字符缓冲输入流
*/
public class BufferedReaderDemo {
public static void main(String[] args) {
// 获取字符缓冲输入流对象
try (
BufferedReader bufferedReader = new BufferedReader(new FileReader("abc\\1.txt"));
) {
// 每次读一个字符
int ch = bufferedReader.read();
System.out.println((char) ch);
// 定义字符串接收读到的数据
String line;
// 循环读取全部内容,每次读一行，不读到返回null
while ((line = bufferedReader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
缓冲字符输出流：
BufferedWriter写数据时： 它是先把数据写到字符缓冲流内部的8BK的数组中（ps: 先攒一车货），等数组存满了，再通过原始的字符输出流，一次性写到目标文件中去（把囤好的货，一次性运走）。如下图所示
案例：
BufferedWriter bufferedWriter = new BufferedWriter(FileWriter fw);
获取字符输出流对象
fw：用来设置字节缓冲流输出后保存文件的路径地址。
bufferedWriter.write(String str);
写入字符的方法。
bufferedWriter.newLine();
换行方法。
package com.zsh.day2.字符缓冲流;
import java.io.*;
/**
* 缓冲字符输出流
*/
public class BufferWriterDemo {
public static void main(String[] args) {
try (
// 获取缓冲字符输出流对象
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("abc\\FileWriter3.txt"));
) {
// 写入字符
bufferedWriter.write("你好！");
// 换行
bufferedWriter.newLine();
// 写入字符
bufferedWriter.write("你也好！");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
转换流
FileReader默认只能读取UTF-8编码格式的文件。如果使用FileReader读取GBK格式的文件，可能存在乱码，因为FileReader它遇到汉字默认是按照3个字节来读取的，而GBK格式的文件一个汉字是占2个字节，这样就会导致乱码。
Java给我们提供了另外两种流InputStreamReader，OutputStreamWriter，这两个流我们把它叫做转换流。它们可以将字节流转换为字符流，并且可以指定编码方案。
转换流字符输入：
InputStreamReader类
案例：
InputStreamReader inputStreamReader = new InputStreamReader(FileInputStream fis,String str);
获取字符转换流输入对象。
fis：获取读取文件的地址路径。
str：字符串，用来定义读取文件的规则，如：utf-8、gbk等。会按照指定编码格式读取文件内容。
package com.zsh.day2.字符转换流;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* 字符输入转换流
*/
public class InputStreamReaderDemo {
public static void main(String[] args) {
// 获取字符输入转换流对象
try (
InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("abc\\gbk.txt"),"gbk");
) {
// 数组接收读取内容
char[] buf = new char[2];
// 读取文件中的内容
int len;
// 循环读取文件内容
while ((len = inputStreamReader.read(buf)) != -1) {
System.out.println(new String(buf));
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
转换流字符输出：
OutputStreamWriter类
案例：
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(String str,boolean append),String str2);
获取字符转换流输出对象
str：文件写出保存路径。
append：是否追加内容，默认false直接覆盖。
str2：写出文件的编码格式，如utf-8、gbk等。
BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
缓冲字符流对象，可以将转换流包装进缓冲流对象中。
package com.zsh.day2.字符转换流;
import java.io.*;
/**
* 字符输出转换流
*/
public class OutPutStreamWriterDemo {
public static void main(String[] args) {
try (
// 获取字符输出转换流对象
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("abc\\gbk2.txt",true),"gbk");
// 获取字符缓冲流对象
BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
) {
// 写入内容，写入的编码格式为gbk
bufferedWriter.write("这段文字的编码格式是gbk");
// 换行
bufferedWriter.newLine();
// 写入内容，写入的编码格式为gbk
bufferedWriter.write("会则不难，难则不会，哈哈哈哈！！！");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
练习案例：
将gbk文件读取出来，放到utf-8文件中
package com.zsh.day2.字符转换流;
import java.io.*;
/**
* 将gbk文件读取出来，放到utf-8文件中
*/
public class Demo {
public static void main(String[] args) {
try (
// 获取输入转换流对象（当前读取格式为gbk）
InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("abc\\gbk2.txt"), "gbk");
// 获取缓存流读对象
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
// 获取输出转换流对象（当前写入格式为utf-8）
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("abc\\gbk3.txt",true),"utf-8");
// 获取输入缓存流对象
BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
) {
// 循环读取一行
String line;
while ((line = bufferedReader.readLine()) != null){
System.out.println(line);
// 把读到的数据写入到新文件中
bufferedWriter.write(line);
// 换行
bufferedWriter.newLine();
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
打印流
打印流，这里所说的打印其实就是写数据的意思，它和普通的write方法写数据还不太一样，一般会使用打印流特有的方法叫print(数据)或者println(数据)，它打印啥就输出啥。
打印流有两个，一个是字节打印流PrintStream，一个是字符打印流PrintWriter，如下图所示
字节打印流：
PrintStream类
案例：
PrintStream printStream = new PrintStream(String str);
获取字节打印流对象。
str：用来设置字节打印流输出后保存文件的路径地址。
printStream.println(10);
打印并换行（打印什么文件中就显示什么）。
printStream.write(99);
写入字节到文件（写入之后的内容会按照编码格式转换）。
package com.zsh.day2.字节打印流;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintStream;
/**
* 字节打印流
*/
public class PrintStreamDemo {
public static void main(String[] args) {
try (
// 获取字节打印流对象
PrintStream printStream = new PrintStream("abc\\BytePrint.txt");
) {
// 打印字节到文件（打印什么文件中就显示什么）
printStream.println(10);
// 打印字节到文件
printStream.print("这是一句话");
// 打印字节到文件
printStream.println("！！！");
// 写入字节到文件（写入之后的内容会按照编码格式转换）
printStream.write(99);
// 换行
printStream.write("\t\n".getBytes());
// 写入字节到文件
byte[] buf = new byte[]{100,101,102,103};
printStream.write(buf);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
字符打印流：
PrintWriter类
案例：
PrintWriter printWriter = new PrintWriter(String str);
获取字符打印流对象。
str：用来设置字符打印流输出后保存文件的路径地址。
printWriter.println(10);
打印并换行（打印什么文件中就显示什么）。
printWriter.write(99);
写入字节到文件（写入之后的内容会按照编码格式转换）。
package com.zsh.day2.字符打印流;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
/**
* 字符打印流
*/
public class PrintWriterDemo {
public static void main(String[] args) {
try (
// 获取字符打印流对象
PrintWriter printWriter = new PrintWriter("abc\\BytePrint2.txt");
){
// 打印字节到文件（打印什么文件中就显示什么）
printWriter.println(10);
// 打印字节到文件
printWriter.print("这是一句话");
// 打印字节到文件
printWriter.println("！！！");
// 写入字节到文件（写入之后的内容会按照编码格式转换）
printWriter.write(99);
// 换行
printWriter.write("\t\n");
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
}
}
数据流
把数据和数据的类型一并写到文件中去，读取的时候也将数据和数据类型一并读出来。这就可以用到数据流，有两个DataInputStream和DataOutputStream.
数据输入流：
DataInputStream类
读取时候，文件里面存储的什么类型的值，就需要用对应类型去读。
案例：
DataInputStream dataInputStream = new DataInputStream(FileInputStream fis);
获取数据输入流对象。
fis：获取读取文件的地址路径。
int i = dataInputStream.readInt();
读取文件中的int类型值
double d = dataInputStream.readDouble();
读取文件中的double类型值
boolean b = dataInputStream.readBoolean();
读取文件中的boolean类型值
String rs = dataInputStream.readUTF();
读取文件中的utf-8类型值
package com.zsh.day2.数据输入流;
import java.io.*;
/**
* 数据输入流
*/
public class DateInputStreamDemo {
public static void main(String[] args) {
try (
// 创建数据输入流对象
DataInputStream dataInputStream = new DataInputStream(new FileInputStream("abc\\io-out.txt"));
) {
int i = dataInputStream.readInt();
System.out.println(i);
double d = dataInputStream.readDouble();
System.out.println(d);
boolean b = dataInputStream.readBoolean();
System.out.println(b);
String rs = dataInputStream.readUTF();
System.out.println(rs);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
数据输出流：
DataOutputStream类
案例：
DataOutputStream dataOutputStream = new DataOutputStream(FileOutputStream fos);
获取数据输出流对象。
fos：用来设数据打印流输出后保存文件的路径地址。
dataOutputStream.writeInt(97);
写入int数据
dataOutputStream.writeDouble(99.5);
写入double数据
dataOutputStream.writeBoolean(true);
写入布尔数据
dataOutputStream.writeUTF("这是一段utf-8的数据内容");
写入utf-8数据
package com.zsh.day2.数据输出流;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 数据输出流
*/
public class DataOutputStreamDemo {
public static void main(String[] args) {
try (
// 创建数据输出流对象
DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream("abc\\io-out.txt"));
){
// 写入int数据
dataOutputStream.writeInt(97);
// 写入double数据
dataOutputStream.writeDouble(99.5);
// 写入布尔数据
dataOutputStream.writeBoolean(true);
// 写入utf-8数据
dataOutputStream.writeUTF("这是一段utf-8的数据内容");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
序列化流（对象流）
节流是以字节为单位来读写数据、字符流是按照字符为单位来读写数据、而对象流是以对象为单位来读写数据。也就是把对象当做一个整体，可以写一个对象到文件，也可以从文件中把对象读取出来。
对象输入流：
ObjectInputStream类
案例：
ObjectInputStream objectInputStream = new ObjectInputStream(FileInputStream fis);
获取对象输入流对象。
fis：获取读取文件的地址路径。
Object o = objectInputStream.readObject();
获取文件中的对象。反序列化
package com.zsh.day2.对象输入流;
import com.zsh.pojo.User;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
/**
* 对象输入流
*/
public class ObjectInputStreamDemo {
public static void main(String[] args) {
try (
// 获取对象输入流对象
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("abc\\object.txt"));
) {
// 获取文件中的对象
Object o = objectInputStream.readObject();
User user = (User) o;
// 输出
System.out.println(user);
} catch (IOException e) {
throw new RuntimeException(e);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
}
输入多个对象：
案例一：
把多个对象写入一个文件中，循环读取时条件可以设置为true，读取完之后会出现：EOFException异常表示文件读取完了，try/catch处理即可。
package com.zsh.day2.对象输入流;
import com.zsh.pojo.User;
import java.io.*;
/**
* 把多个对象存入文件
*/
public class ObjectInputStreamAllDemo {
public static void main(String[] args) {
try (
// 获取对象输出流对象
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("abc\\ObjectAll.txt"));
) {
User user1 = new User("张三",20);
User user2 = new User("李四",21);
User user3 = new User("王五",22);
// 把对象写入到文件
objectOutputStream.writeObject(user1);
objectOutputStream.writeObject(user2);
objectOutputStream.writeObject(user3);
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
// 读取文件中的对象
readTest();
}
/**
* 读取文件中的对象
*/
private static void readTest() {
// 获取对象输入流对象
try (
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("abc\\ObjectAll.txt"));
) {
// 循环读取文件中的内容（当文件读取完时候，会出现：EOFException异常，表示文件读取完了）
while (true) {
// 读取文件中的对象
Object o = objectInputStream.readObject();
// 转换
User user = (User) o;
// 打印
System.out.println(user);
}
} catch (EOFException e) {
System.out.println("文件读取完了：" + e);
} catch (IOException e) {
System.out.println("文件读取异常：" + e);
} catch (ClassNotFoundException e) {
System.out.println("文件找不到：" + e);
}
}
}
案例二：
也可以把多个对象放到ArrayList中，在放到文件中，这样也可也存储多个对象。
package com.zsh.day2.对象输入流;
import com.zsh.pojo.User;
import java.io.*;
import java.util.ArrayList;
/**
* 把多个对象存入文件
*/
public class ObjectInputStreamAllDemo {
public static void main(String[] args) {
try (
// 获取对象输出流对象
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("abc\\ObjectAll.txt"));
) {
// 创建对象
User user1 = new User("张三",20);
User user2 = new User("李四",21);
User user3 = new User("王五",22);
// 创建集合1
ArrayList<User> list = new ArrayList<>();
list.add(user1);
list.add(user2);
list.add(user3);
// 创建集合2
ArrayList<User> list2 = new ArrayList<>();
list2.add(user1);
list2.add(user2);
list2.add(user3);
// 把对象写入到文件
objectOutputStream.writeObject(list);
objectOutputStream.writeObject(list2);
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
// 读取文件中的对象
readTest();
}
/**
* 读取文件中的对象
*/
private static void readTest() {
// 获取对象输入流对象
try (
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("abc\\ObjectAll.txt"));
) {
// 循环读取文件中的内容（当文件读取完时候，会出现：EOFException异常，表示文件读取完了）
while (true) {
// 读取文件中的对象
Object o = objectInputStream.readObject();
// 转换
ArrayList<User> list = (ArrayList<User>) o;
// 打印
System.out.println(list);
}
} catch (EOFException e) {
System.out.println("文件读取完了：" + e);
} catch (IOException e) {
System.out.println("文件读取异常：" + e);
} catch (ClassNotFoundException e) {
System.out.println("文件找不到：" + e);
}
}
}
对象输出流：
ObjectOutputStraem类
案例：
创建对象，必须实现：Serializable接口，这是一个标记接口，证明对象可以被序列化。
package com.zsh.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
private String name;
private Integer age;
}
ObjectOutputStream objectOutputStream = new ObjectOutputStream(FileOutputStream fos);
获取对象输出流对象。
fos：用来设置对象流输出后保存文件的路径地址。
objectOutputStream.writeObject(Object o);
o：要写到文件中的对象。
package com.zsh.day2.对象输出流;
import com.zsh.pojo.User;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/**
* 对象输出流
*/
public class ObjectOutputStreamDemo {
public static void main(String[] args) {
try (
// 获取对象输出流
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("abc\\object.txt"));
) {
// 创建对象
User user = new User("张三",20);
// 将对象写入文件（写入文件的对象必须实现：Serializable接口，这是一个标记接口，证明对象可以被序列化）
objectOutputStream.writeObject(user);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
IO框架
在maven中引入依赖
<!-- io流框架 -->
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.11.0</version>
</dependency>x常用方法：
FileUtils：
FileUtils：直接操作文件。
FileUtils.copyFile(File f1,File f2);
复制文件。
f1：复制的文件路径。
f2：拷贝到的文件路径。
FileUtils.copyDirectory(File f1,File f2);
复制文件夹。
f1：复制的文件夹路径。
f2：拷贝到的文件夹路径。
FileUtils.deleteDirectory(File f);
删除文件夹。
f：删除的文件夹路径。
String str = FileUtils.readFileToString(File f,String str);
读数据。
f：要读取的文件路径。
str：读取的格式，如：utf-8、gbk等。
IOUtils：
IOUtils：通过流操作文件
IOUtils.copy(FileInputStream fis,FileOutputStream fos);
复制文件。
fis：要复制的文件路径。
fos：复制后要保存的路径
