Java-增强io-缓冲流、转换流、序列化流
缓冲流
缓冲流也叫高效流,是对四个基本的File流的增强,所以也是四个流,按照数据类型分为:
字符缓冲流:BufferedReader
,BufferedWriter
字节缓冲流:BufferedInputStream
,BufferedOutputStream
缓冲流的原理:在创建流对象时,会创建一个内置的默认大小的缓冲区数组,通过缓冲区读写,减少IO次数,从而提高读写效率。
字节缓冲流:
构造方法
public BufferedInputStream(InputStream in)
:创建一个 新的缓冲输入流。
public BufferedOutputStream(OutputStream out)
: 创建一个新的缓冲输出流。
字节缓冲输出流
package sample.Day18.Work;
import java.io.*;
/*写出数据*/
public class BufferedTest01 {
public static void main(String[] args) throws IOException {
//创建字节缓冲输出流对象
BufferedOutputStream bw = new BufferedOutputStream(new FileOutputStream("bwout.txt"));
//写出数据
bw.write('a');
bw.write('b');
bw.write('c');
/*释放资源*/
bw.close();
}
}
字节缓冲输入流
package sample.Day18.Work;
import java.io.*;
/*写出数据*/
public class BufferedTest01 {
public static void main(String[] args) throws IOException {
//创建流对象
BufferedInputStream bw = new BufferedInputStream(new FileInputStream("bwout.txt"));
//读数据
int ch = 1;
while((ch=bw.read())!=-1){
System.out.print((char)ch)
}
/*释放资源*/
bw.close();
}
}
使用缓冲流复制图片文件
public class FileCopy02 {
public static void main (String[]args) throws IOException {
//计录文件拷贝时间
long start = System.currentTimeMillis();
//写入需要复制的目标文件
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("c:/c.jpeg"));
//将目标文件写出到文件
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("d:/c.jpeg"));
byte[] bytes = new byte[1024];
int len = 0;
while ((len = bis.read(bytes)) != -1) {
bos.write(bytes, 0, len);
}
bos.flush();
bis.close();
bos.close();
long end = System.currentTimeMillis();
System.out.println("拷贝文件需要的时间:" + (end - start));
}
}
字符缓冲流
构造方法:字符缓冲流的基本方法与普通字符流调用方式一致
public BufferedReader(Reader in)
:创建一个 新的缓冲输入流。
public BufferedWriter(Writer out)
: 创建一个新的缓冲输出流。
字符缓冲输入流
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
// 创建流对象
BufferedReader br = new BufferedReader(new FileReader("in.txt"));
// 定义字符串,保存读取的一行文字
String line = null;
// 循环读取,读取到最后返回null
while ((line = br.readLine())!=null) {
System.out.print(line);
System.out.println("------");
}
// 释放资源
br.close();
}
}
字符缓冲输出流
public class BufferedWriterDemo throws IOException {
public static void main(String[] args) throws IOException {
// 创建流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
// 写出数据
bw.write("我喜欢");
// 写出换行
bw.newLine();
bw.write("吃肉");
bw.newLine();
bw.write("和啤酒");
bw.newLine();
// 释放资源
bw.close();
}
}
输出效果:
我喜欢
吃肉
和啤酒
转换流
编码:按照某种规则,将字符存储到计算机中 。
解码 :将存储在计算机中的二进制数按照某种规则解析显示出来。
在IDEA中,使用FileReader
读取项目中的文本文件。由于IDEA的设置,都是默认的UTF-8
编码,所以没有任何问题。但是,当读取Windows系统中创建的文本文件时,由于Windows系统的默认是GBK编码,就会出现乱码。
public class ReaderDemo {
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("E:\\File_GBK.txt");
int read;
while ((read = fileReader.read()) != -1) {
System.out.print((char)read);
}
fileReader.close();
}
}
输出结果:
���
那么如何读取GBK编码的文件呢?
InputStreamReader类
InputStreamReader是Reader的子类,可将字节流转换到字符流。它读取字节并使用指定的字符集解码方式将其解码为字符。
构造方法
InputStreamReader(InputStream in)
: 创建一个使用默认字符集的字符流。
InputStreamReader(InputStream in, String charsetName)
: 创建一个指定字符集的字符流。
构造举例,代码如下:
InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");
指定编码读取
package sample.Day18.Work2;
import java.io.*;
public class Work6 {
public static void main(String[] args) throws IOException {
String Filename = "aaa.txt";
InputStreamReader osw = new InputStreamReader(new FileInputStream(Filename),"gbk");
int read;
while ((read=osw.read())!=-1) {
System.out.print((char) read);
}
osw.close();
}
}
OutputStreamWriter类
转换流java.io.OutputStreamWriter ,可将字符流转换到字节流。它读取字符并使用指定的字符集解码方式将其解码为字节。
OutputStreamWriter(OutputStream in)
: 创建一个使用默认字符集的字符流。
OutputStreamWriter(OutputStream in, String charsetName)
: 创建一个指定字符集的字符流。
构造举例,代码如下:
OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");
指定编码写出
package sample.Day18.Work2;
import java.io.*;
public class Work6 {
public static void main(String[] args) throws IOException {
String Filename = "aaa.txt";
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(Filename),"gbk");
osw.write("我爱java");
osw.close();
}
}
转换流是字节流和字符流之间的桥梁
案例分析
- 指定GBK编码的转换流,读取文本文件。
- 使用UTF-8编码的转换流,写出文本文件。
案例实现
public class TransDemo {
public static void main(String[] args) {
// 1.定义文件路径
String srcFile = "file_gbk.txt";
String destFile = "file_utf8.txt";
// 2.创建流对象
// 2.1 转换输入流,指定GBK编码
InputStreamReader isr = new InputStreamReader(new FileInputStream(srcFile) , "GBK");
// 2.2 转换输出流,默认utf8编码
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(destFile));
// 3.读写数据
// 3.1 定义数组
char[] cbuf = new char[1024];
// 3.2 定义长度
int len;
// 3.3 循环读取
while ((len = isr.read(cbuf))!=-1) {
// 循环写出
osw.write(cbuf,0,len);
}
// 4.释放资源
osw.close();
isr.close();
}
}
序列化流
Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象,该字节序列包含该对象的数据
、对象的类型
和对象中存储的属性
等信息。字节序列写出到文件之后,相当于文件中持久保存了一个对象的信息。
反之,该字节序列还可以从文件中读取回来,重构对象,对它进行反序列化。对象的数据
、对象的类型
和对象中存储的数据
信息,都可以用来在内存中创建对象。看图理解序列化:
序列化流是字节和对象之间的桥梁
ObjectOutputStream类
构造方法
public ObjectOutputStream(OutputStream out)
: 创建一个指定OutputStream的ObjectOutputStream。
构造举例,代码如下:
FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
序列化操作必须满足的条件
1.该类必须实现java.io.Serializable
接口,Serializable
是一个标记接口,不实现此接口的类将不会使任何状态序列化或饭序列化,会抛出NotSerializableException
异常 。该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的,则该属性必须注明是瞬态的,使用transient
关键字修饰。
public class Employee implements java.io.Serializable {
public String name;
public String address;
public transient int age; // transient瞬态修饰成员,不会被序列化
public void addressCheck() {
System.out.println("Address check : " + name + " -- " + address);
}
}
例:
建立一个学生类
package sample.Day18.Work2;
import java.io.Serializable;
import java.util.Objects;
public class Sudents implements Serializable {
private String name;
//瞬态修饰年龄,年龄不序列化
transient int age;
private String sex;
public Sudents(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Sudents)) return false;
Sudents sudents = (Sudents) o;
return age == sudents.age && Objects.equals(name, sudents.name) && Objects.equals(sex, sudents.sex);
}
@Override
public int hashCode() {
return Objects.hash(name, age, sex);
}
@Override
public String toString() {
return "Sudents{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
}
序列化学生类
package sample.Day18.Work2;
import java.io.*;
public class Studenttest02 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectOutputStream obj = new ObjectOutputStream(new FileOutputStream("stus.txt"));
obj.writeObject(new Sudents("张三",20,"man"));
obj.writeObject(new Sudents("王莽",28,"man"));
obj.writeObject(new Sudents("霍去病",18,"man"));
obj.writeObject(new Sudents("刘彻",30,"man"));
obj.writeObject(new Sudents("始皇",40,"man"));
obj.flush();
obj.close();
}
}
反序列化ObjectInputStream类
ObjectInputStream反序列化流,将之前使用ObjectOutputStream序列化的原始数据恢复为对象。
构造方法
public ObjectInputStream(InputStream in)
: 创建一个指定InputStream的ObjectInputStream。
public final Object readObject ()
: 读取一个对象。
例:反序列化上边学生类
package sample.Day18.Work2;
import java.io.*;
public class StudentsTest03 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
FileInputStream fileIn = new FileInputStream("stus.txt");
ObjectInputStream oij = new ObjectInputStream(fileIn);
Sudents s = null;
s = (Sudents) oij.readObject();
System.out.println(s);
System.out.println(s.getName());
System.out.println(s.getSex());
System.out.println(s.getAge());//null因为没有序列化
oij.close();
}
}
对于JVM可以反序列化对象,它必须是能够找到class文件的类。如果找不到该类的class文件,则抛出一个 ClassNotFoundException
异常。
反序列化操作2
**另外,当JVM反序列化对象时,能找到class文件,但是class文件在序列化对象之后发生了修改,那么反序列化操作也会失败,抛出一个InvalidClassException
异常。**发生这个异常的原因如下:
- 该类的序列版本号与从流中读取的类描述符的版本号不匹配
- 该类包含未知数据类型
- 该类没有可访问的无参数构造方法
Serializable
接口给需要序列化的类,提供了一个序列版本号。serialVersionUID
该版本号的目的在于验证序列化的对象和对应类是否版本匹配。
public class Employee implements java.io.Serializable {
// 加入序列版本号
private static final long serialVersionUID = 1L;
public String name;
public String address;
// 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.
public int eid;
public void addressCheck() {
System.out.println("Address check : " + name + " -- " + address);
}
}