JAVASE(十六) IO流 ：File类、节点流、缓冲流、转换流、编码集、对象流
个人博客网：https://wushaopei.github.io/ (你想要这里多有)
1、File类型
1.1.File类的理解
- File类是在java.io包下
- File可以理解成一个文件(.mp3 .mp4 .txt)或者一个目录
- File没向文件写入数据的功能。只创建，删除，文件大小等方法。
- File可以理解成流的终端。
- 我们经常将File的对象作为实参传入到流的构造器中
- File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。
1.2. 如何实例化
File file = new File("H:\\aaa\\abc.txt");
File file = new File("H:/aaa/abc.txt");
new File("H:\\aaa", "abc.txt"); //H:\\aaa\\abc.txt绝对路径：包含盘符在内的完整路径
相对路径：相对于当前的项目的路径。
1.3 File 类的常见构造器：
注意：File的静态属性String separator存储了当前系统的路径分隔符。
在UNIX中，此字段为‘/’，在Windows中，为‘\\’
1.4.常用方法
1.5 案例
2、IO流概述
2.1概念：
- I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
- Java程序中，对于数据的输入/输出操作以”流(stream)” 的方式进行。
- java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
2.2 Java IO原理
2.3.流的分类
- 按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit)
- 按数据流的流向不同分为：输入流，输出流
- 按流的角色的不同分为：节点流，处理流
- Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生的。
- 由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。
图示：
2.4.流的体系结构（蓝色的部分是重点
2.5 输入流、输出流
- 节点流可以从一个特定的数据源读写数据
- 处理流是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。
（1）InputStream & Reader
（2）OutputStream & Writer
3、节点流（文件流）
文件流（1）
FileReader fr = null;
try{
fr = new FileReader("c:\\test.txt");
char[] buf = new char[1024];
int len= 0;
while((len=fr.read(buf))!=-1){
System.out.println(new String(buf ,0,len));}
}catch (IOException e){
System.out.println("read-Exception :"+e.toString());}
finally{
if(fr!=null){
try{
fr.close();
}catch (IOException e){
System.out.println("close-Exception :"+e.toString());
} } }
文件流 (2)
FileWriter fw = null;
try{
fw = new FileWriter("Test.txt");
fw.write("text");
}
catch (IOException e){
System.out.println(e.toString());
}
finally{
If(fw!=null)
try{
fw.close();
}
catch (IOException e){
System.out.println(e.toString());
}
}
注意：
- 定义文件路径时，注意：可以用“/”或者“\\”。
- 在写入一个文件时，如果目录下有同名文件将被覆盖。
- 在读取文件时，必须保证该文件已存在，否则出异常。
字节流：
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//1.创建File对象
File file = new File("char8.txt");
File file2 = new File("char9.txt");
//2.创建流的对象
fis = new FileInputStream(file);
fos = new FileOutputStream(file2);
//3.读内容和写内容
byte[] b = new byte[1024];
int len = 0;
while ((len = fis.read(b)) != -1) {
//将数组中的内容写到目标文件中
fos.write(b, 0, len);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
//4.关流
try {
if(fos != null){
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(fis != null){
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
字符流：
/*
* FileWriter
*/
@Test
public void test3() throws Exception{
FileWriter writer = new FileWriter("jjj.txt");
writer.write("中国你好我爱你么么哒".toCharArray());
writer.close();
}
/*
* FileReader ： 读取中文不会发生乱码的问题
*/
@Test
public void test() throws Exception{
FileReader reader = new FileReader("aaa.txt");
char[] c = new char[500];
int len = 0;
while((len = reader.read(c)) != -1){
// System.out.println(new String(c, 0, len));
for (int i = 0; i < len; i++) {
System.out.println(c[i]);
}
}
reader.close();
}4、缓冲流的使用
为了提高数据读写的速度，Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组
根据数据操作单位可以把缓冲流分为：
- BufferedInputStream 和 BufferedOutputStream
- BufferedReader 和 BufferedWriter
缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法
对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush()将会使内存中的数据立刻写出
4.1 处理流之一：缓冲流
File descFile = new File(desc);
File srcFile = new File(src);
FileInputStream fis = new FileInputStream(srcFile);
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream(descFile);
BufferedOutputStream bos = new BufferedOutputStream(fos);
byte[] b = new byte[1024];
int len = 0;
while((len = bis.read(b)) != -1){
bos.write(b, 0, len);
}
bos.close();
bis.close();
fis.close();
fos.close();
/*
* BufferedWriter
*/
@Test
public void test2() throws Exception{
FileWriter writer = new FileWriter("cdf.txt");
BufferedWriter bw = new BufferedWriter(writer);
bw.write("圆圆么么哒");
bw.close();
writer.close();
}
/*
* BufferedReader
*/
@Test
public void test() throws Exception{
FileReader reader = new FileReader("aaa.txt");
//创建缓冲字符流
BufferedReader br = new BufferedReader(reader);
/*
* 第一种读取文件内容
*/
// char[] c = new char[100];
// int len = 0;
// while((len = br.read(c)) != -1){
// System.out.println(new String(c,0,len));
// }
/*
* 第二种读取文件内容
* readLine() : 读取一行
*/
String str="";
while((str = br.readLine()) != null){
System.out.println(str);
}
br.close();
reader.close();
}5、转换流的使用
作用：
- 将读取文件的字节流转换成字符流，将写入文件内容的字符流转成字节流
- 转换编码集 （读入的文件比如是UTF-8，写入的文件的可以变成GBK
- 注意：InputStreamReader设置的编码集必须和读取文件的编码集是一致的。
代码：
// 读取的文件
File file = new File("demo.txt");
// 创建一个字节流，对接在demo.txt上
FileInputStream fis = new FileInputStream(file);
// 创建一个转换流 - 字节转字符
InputStreamReader isr = new InputStreamReader(fis);
// 写入的文件
File file2 = new File("demo2.txt");
// 创建一个字节流，对接在demo2.txt上
FileOutputStream fos = new FileOutputStream(file2);
// 创建一个转换流 - 字符转字节
OutputStreamWriter osw = new OutputStreamWriter(fos);
char[] c = new char[1024];
int len = 0;
while ((len = isr.read(c)) != -1) {
osw.write(c, 0, len);
}
osw.close();
isr.close();
fos.close();
fis.close();图示：
6、字符编码集
7、其他流的使用：标准输入输出流、打印流
7.1 标准输入输出流
- System.in和System.out分别代表了系统标准的输入和输出设备
- 默认输入设备是键盘，输出设备是显示器
- System.in的类型是InputStream
- System.out的类型是PrintStream，其是OutputStream的子类FilterOutputStream 的子类
- 通过System类的setIn，setOut方法对默认设备进行改变。
public static void setIn(InputStream in)
public static void setOut(PrintStream out)代码示例：
/*
* 从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，
* 直至当输入“e”或者“exit”时，退出程序。
*/
@Test
public void test2() throws Exception{
/*
* 1.从控制台读取数据
* 2.将字节流转成字符流
* 3.使用缓冲流
*/
//将字节流转换成字符流
InputStreamReader isr = new InputStreamReader(System.in);
//创建字符缓冲流
BufferedReader br = new BufferedReader(isr);
while(true){
//读取控制台上的数据
String str = br.readLine();
//判断如果是"e"/"exit"那么就退出程序，否则全部转成大写并输出
if("e".equalsIgnoreCase(str) || "exit".equalsIgnoreCase(str)){
//关流
br.close();
isr.close();
return;
}else{
System.out.println(str.toUpperCase());
}
}
}7.2 打印流
代码：
@Test
public void test() {
/*
* 第一步 创建一个连接text.txt的管道
* 第二步 将输入到控制台的管道改成输入到text.txt
* 第步 输入内容
*/
FileOutputStream fos = null;
try {
//创建一个输出流
fos = new FileOutputStream(new File("text.txt"));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
// 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
PrintStream ps = new PrintStream(fos, true);
/*
* 第二步 将输入到控制台的管道改成输入到text.txt
*/
// 把标准输出流(控制台输出)改成文件
System.setOut(ps); //在程序运行时只能设置一次。
/*
* 第步 输入内容
*/
for (int i = 0; i <= 10; i++) {
System.out.print("a");
}
ps.close();
}
7.3 数据流
代码：
/*
* 输入流
*
* 注意 ： 写入数据的格式 和 读取数据的格式必须一致
*/
@Test
public void test() throws Exception{
FileInputStream fis = new FileInputStream("abc.txt");
DataInputStream dis = new DataInputStream(fis);
String readUTF = dis.readUTF();
int readInt = dis.readInt();
boolean boo = dis.readBoolean();
System.out.println(readUTF);
System.out.println(readInt);
System.out.println(boo);
dis.close();
fis.close();
}
/*
* 输出流
*/
@Test
public void test2() throws Exception{
FileOutputStream out = new FileOutputStream("abc.txt");
DataOutputStream dos = new DataOutputStream(out);
dos.writeUTF("abcde");
dos.writeInt(10);
dos.writeBoolean(true);
dos.close();
out.close();
}
7.4 对象流的使用
序列化 ：用ObjectOutputStream类保存基本类型数据或对象的机制 (保存对象，或者发送对象)
反序列化 ：用ObjectInputStream类读取基本类型数据或对象的机制(读取对象，接收对象)
* 注意：
- 序列化对象的类必须实现Serializable接口
- 序列化对象的类的属性除基本类型外，也必须全部实现Serializable接口
- 需要声明一个 serialVersionUID （如果不显示声明系统会默认填加一个）
- 不能序列化static和transient修饰的成员变量
代码：
/*
* ObjectInputStream
*/
@Test
public void test() throws Exception{
FileInputStream fis = new FileInputStream("aaa.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Person p = (Person) ois.readObject();
p.show();
Person p2 = (Person) ois.readObject();
p2.show();
ois.close();
fis.close();
}
/*
* ObjectOutputStream
*/
@Test
public void test2() throws Exception{
FileOutputStream fos = new FileOutputStream("aaa.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//写数据
oos.writeObject(new Person("aa",18,new Address("aaaa",20)));
oos.writeObject(new Person("bb",18,new Address("bbbb",20)));
oos.close();
}9、RandomAccessFile类的使用
需求：
文件中的内容 : abcdefg
需求: 在c的后面插入AAA
- 先将指针移动到c的后面
- 读取c后面的所数据并保存到一个临时变量中
- 指针回移，移动到c的后面
- 写入需要插入的数据
- 写入临时变量中的数据
代码：
@Test
public void test4() throws Exception{
RandomAccessFile accessFile = new RandomAccessFile("access.txt", "rw");
//移动指针到c后面
accessFile.seek(3);
//将c后面的数据读出并保存到一个临时变量中。
// String str = accessFile.readLine();
String str = "";
//读取插入位置后面的所内容
byte[] b = new byte[1024];
int len = 0;
while((len = accessFile.read(b)) != -1){
str += new String(b,0,len);
}
//指针回移
accessFile.seek(3);
//插入数据
accessFile.write("AAA".getBytes());
accessFile.write(str.getBytes());
//关流
accessFile.close();
}