java基础之--缓冲流-字节流+字符流+转换流+序列化+打印流
昨天学习了基本的一些流，作为IO流的入门，今天我们要见识一些更强大的流。比如能够高效读写的缓冲流，能够转换编码的转换流，能够持久化存储对象的序列化流等等。这些功能更为强大的流，都是在基本的流对象基础之上创建而来的，就像穿上铠甲的武士一样，相当于是对基本流对象的一种增强
1. 概述
缓冲流,也叫高效流 ,是对4个基本的FileXxx流的增强,所以也是4个流,按照数据类型分类
- 字节缓冲流：
BufferedInputStream，BufferedOutputStream - 字符缓冲流：
BufferedReader，BufferedWriter
缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。
2. 字节缓冲流
构造方法
public BufferedInputStream(InputStream in) :创建一个新的缓冲输入流public BufferedOutputStream(OutputStream out) :创建一个新的缓冲输出流
package Stream;
import FileStream.FileOutputStreamConstructor;
import java.io.*;
/**
* @Description
* @auther 宁宁小可爱
* @create 2020-01-16 14:28
*/
public class BufferDemo {
public static void main(String[] args) throws Exception {
// 记录开始时间
long startTime = System.currentTimeMillis();
try {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\softWare-all\\developSoftware\\projectPath\\java-project\\Thread\\src\\Stream\\wegameservice.exe"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
int len;
byte[] bytes = new byte[8*1024];
while ((len = bis.read(bytes)) != -1){
bos.write(bytes,0,len);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
// 记录结束时间
long endTime = System.currentTimeMillis();
System.out.println("缓冲流使用数组复制时间: "+(endTime-startTime) + "毫秒");
}
}
3. 字符缓冲流
public BufferedReader(Reader in) :创建一个新的缓冲输入流public BufferedWriter(Writer out) :创建一个新的缓冲输出流
字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法
BufferedReader： public String readLine() :读一行文字BufferedWriter： public void newLine() :写一行行分隔符,由系统属性定义符号
readline方法演示
package Stream;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
/**
* @Description
* @auther 宁宁小可爱
* @create 2020-01-16 15:17
*/
public class BufferReaderDemo {
public static void main(String[] args) throws Exception {
// 创建流对象
BufferedReader br = new BufferedReader(new FileReader("fw.txt"));
String line = null;
while ((line = br.readLine()) != null){
System.out.println(line);
System.out.println("--------------------------");
}
br.close();
}
}
newLine方法演示
package Stream;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/**
* @Description
* @auther 宁宁小可爱
* @create 2020-01-16 15:20
*/
public class BufferWriterDemo {
public static void main(String[] args) throws IOException {
// 创建流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("fw.txt"));
bw.write("宁宁小可爱");
bw.newLine();
bw.write("新年快乐");
bw.close();
}
}
输出结果:
宁宁小可爱
新年快乐
4. 转换流
字符集 Charset ：是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。 计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符 集有ASCII字符集、GBK字符集、Unicode字符集等,可见，当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们最终要关心的
在IDEA中，使用 FileReader 读取项目中的文本文件。由于IDEA的设置，都是默认的 UTF-8 编码，所以没有任何问题。但是，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码,那么如何读取GBK编码的文件呢
4.1 InputStreamReader类
构造方法
InputStreamReader(InputStream in) :创建一个使用默认字符集的字符流InputStreamReader(InputStream in, String charsetName) :创建一个指定字符集的字符流
指定编码读取
package Stream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
/**
* @Description
* @auther 宁宁小可爱
* @create 2020-01-16 15:29
*/
public class ReadDemo {
public static void main(String[] args) throws Exception {
String filePath = "E:\\test.txt";
// 创建流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath));
// 创建流对象 指定编码GBK
InputStreamReader isr2 = new InputStreamReader(new FileInputStream(filePath));
int read;
while ((read = isr.read()) != -1){
System.out.println((char)read);
}
isr.close();
while ((read = isr2.read()) != -1){
System.out.println((char)read);
}
isr2.close();
}
}
输出结果: isr乱码 isr2 输出如下
新
年
快
乐
宁
宁
小
可
爱
4.2 OutputStreamWriter类
转换流 java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集讲字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集
构造方法
OutputStreamWriter(OutputStream in) :创建一个使用默认字符集的字符流OutputStreamWriter(OutputStream in, String charsetName) :创建一个指定字符集的字符流
指定编码
package Stream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/**
* @Description
* @auther 宁宁小可爱
* @create 2020-01-16 15:40
*/
public class OutPutDemo {
public static void main(String[] args) throws IOException {
String filePath = "E:\\test.txt";
// 创建流对象,默认UTF-8编码
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath));
// 写数据
osw.write("宁宁小可爱");
osw.close();
String filePath2 = "E:\\test2.txt";
// 创建流对象,默认UTF-8编码
OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(filePath2),"GBK");
// 写数据
osw2.write("宁宁小可爱");
osw2.close();
}
}
转换流图解
5. 序列化
Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据 、 对象的类型和对象中存储的数据等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。 反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。 对象的数据 、 对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象
5.1 ObjectOutputStream类
java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储
构造方法
public ObjectOutputStream(OutputStream out) :创建一个指定OutputStream的ObjectOutputStream
序列化操作,一个对象要想序列化，必须满足两个条件
- 该类必须实现
java.io.Serializable接口，Serializable是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException - 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用
transient关键字修饰
package Stream;
import sun.management.Agent;
import java.io.Serializable;
/**
* @Description
* @auther 宁宁小可爱
* @create 2020-01-16 15:55
*/
public class Employee implements Serializable {
public String name;
public String address;
public transient int age; // transient瞬态修饰成员,不会被序列化
}
写出对象方法
public final void writeObject (Object obj) :将指定的对象写出
package Stream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/**
* @Description
* @auther 宁宁小可爱
* @create 2020-01-16 15:58
*/
public class SerializeDemo {
public static void main(String[] args) {
Employee e = new Employee();
e.name = "ningning";
e.address = "beijing";
e.age = 19;
try {
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
out.writeObject(e);
out.close();
System.out.println("Serialized data is saved");
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
5.2 ObjectInputStream类
ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象
构造方法
public ObjectInputStream(InputStream in) :创建一个指定InputStream的ObjectInputStream
反序列化操作
如果能找到一个对象的class文件，我们可以进行反序列化操作，调用 ObjectInputStream 读取对象的方法
public final Object readObject () :读取一个对象
package Stream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
/**
* @Description
* @auther 宁宁小可爱
* @create 2020-01-16 16:04
*/
public class DeSerializeDemo {
public static void main(String[] args) {
Employee e = null;
try {
// 创建反序列化流
FileInputStream fis = new FileInputStream("employee.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
// 读取对象
e = (Employee)ois.readObject();
ois.close();
fis.close();
} catch (Exception ex) {
ex.printStackTrace();
}
System.out.println("name : "+e.name);
System.out.println("address : "+e.address);
System.out.println("address : "+e.age);
}
}
6. 打印流- PrintStream类
平时我们在控制台打印输出，是调用 print 方法和 println 方法完成的，这两个方法都来自于 java.io.PrintStream 类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式
构造方法
public PrintStream(String fileName) :使用指定的文件名创建一个新的打印流- 举例如下
PrintStream ps = new PrintStream("test.txt")；
改变打印流向
System.out 就是 PrintStream 类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象， 我们就可以玩一个"小把戏"，改变它的流向
package Stream;
import java.io.FileNotFoundException;
import java.io.PrintStream;
/**
* @Description
* @auther 宁宁小可爱
* @create 2020-01-16 16:11
*/
public class PrintDemo {
public static void main(String[] args) throws FileNotFoundException {
// 控制台输出 97
System.out.println(97);
// 创建打印流 指定文件名称
PrintStream ps = new PrintStream("ps.txt");
// 设置流向 输出到ps.txt
System.setOut(ps);
// 再次打印97
System.out.println(97);
}
}