1. 节点流和处理流接上
2. 处理流BufferedInputStream 和 BufferedOutputStream
2.1 介绍BufferedInputStream 626
BufferedInputStream是字节流在创建BufferedInputStream会创建一个内部缓冲区数组.
2.2 介绍BufferedOutputStream 626
BufferedOutputStream是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统
3. 应用案例 627
要求:编程完成图片/音乐的拷贝(要求使用Buffered..流).
代码在com.stulzl.bufferedcopy_.包中
BufferedCopy_
package com.stulzl.bufferedcopy_;
import java.io.*;
//案例BufferedInputStream 和 BufferedOutputStream 627
//使用他们，可以完成二进制文件拷贝.
//要求:编程完成图片/音乐的拷贝(要求使用Buffered..流).
public class BufferedCopy_ {
public static void main(String[] args) {
String srcFilePath = "e:\\guidao.jpg";
String destFilePath = "e:\\guidao2.jpg";
//思考：字节流可以操作二进制文件，可以操作文本文件吗？当然可以
// String srcFilePath = "e:\\story.txt";
// String destFilePath = "e:\\story3.txt";
//创建BufferedInputStream 和 BufferedOutputStream对象
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
bis = new BufferedInputStream(new FileInputStream(srcFilePath));
bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
//循环的读取文件，并写入到 destFilePath
byte[] buff = new byte[1024];//临时缓冲字节数组
int readLen = 0;
//当返回 -1 时，就表示文件读取完毕
while((readLen=bis.read(buff))!=-1){
bos.write(buff,0,readLen);
}
System.out.println("文件拷贝成功……");
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭流
try {
if(bis!=null){
bis.close();
}
if(bos!=null){
bos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}4. 对象流ObjectInputStream 和 ObjectOutputStream 628
➢看一个需求
1.将int num = 100这个int数据保存到文件中，注意不是100数字，而是int 100,井且，能够
从文件中直接恢复int 100
2.将Dog dog = new Dog(“小黄"，3)这个dog对象保存到文件中，并且能够从文件恢复.
3.上面的要求， 就是能够将基本数据类型或者对象进行序列化和反序列化操作
4.1 序列化和反序列化 628
1.序列化就是在保存数据时， 保存数据的值和数据类型
2.反序列化就是在恢复数据时， 恢复数据的值和数据类型
3.需要让某个对象支持序列化机制， 则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一:
Serializable // 这是一个标记接口，没有方法
Externalizable //该接口有方法需要实现，因此我们一般实现上面的Serializable接口
4.2 对象流介绍
功能：提供了对基本类型或对象类型的序列化和反序列化的方法
ObjectOutputStream 提供 序列化功能
ObjectInputStream 提供 反序列化功能
4.3 应用案例ObjectOutputStream序列化 629
1.使用ObjectOutputStream 序列化基本数据类型和一个Dog对象(name, age),并
保存到data.dat文件中
代码在com.stulzl.objectoutputstream_.包中
共有的Dog类4.4案列也共有这个Dog
package com.stulzl.objectoutputstream_;
import java.io.Serializable;
//如果需要序列化某个类的对象，需要实现Serializable接口或者Externalizable接口
public class Dog implements Serializable {
private String name;
private int age;
//serialVersionUID 序列化的版本号，可以提高兼容性
private static final long serialVersionUID = 1L;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}ObjectOutputStream_
package com.stulzl.objectoutputstream_;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
//应用案例ObjectOutputStream 完成序列化 629
//1.使用ObjectOutputStream 序列化基本数据类型和一个Dog对象(name, age),并
//保存到data.dat文件中
public class ObjectOutputStream_ {
public static void main(String[] args) throws Exception {
//序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存
String filePath = "e:\\data.dat";
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
//序列化数据到e:\data.txt
//这里的int boolean char double String都实现了Serializable接口
//因此可以序列化
oos.writeInt(100);// int -> Integer (实现了 Serializable)
oos.writeBoolean(true);//// boolean -> Boolean (实现了 Serializable)
oos.writeChar('a');// char -> Character (实现了 Serializable)
oos.writeDouble(9.5);// double -> Double (实现了 Serializable)
oos.writeUTF("中国");//String类型(实现了 Serializable)
//保存一个dog对象
oos.writeObject(new Dog("旺财",10));
oos.close();
System.out.println("数据序列化完毕");
}
}4.4 应用案例ObjectInputStream反序列化 630
2. 使用ObjectInputStream读取data.dat并反序列化恢复数据
代码在com.stulzl.objectinputstream_.包中
ObjectInputStream_
package com.stulzl.objectinputstream_;
import com.stulzl.objectoutputstream_.Dog;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
//应用案例ObjectInputStream反序列化 630
//2. 使用ObjectInputStream读取data.dat并反序列化恢复数据
public class ObjectInputStream_ {
public static void main(String[] args) throws Exception {
//指定反序列化文件
String filePath = "e:\\data.dat";
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
//读取
//读取(反序列化)的顺序需要和你保存的数据的顺序一致，否则会出现异常
System.out.println(ois.readInt());
System.out.println(ois.readBoolean());
System.out.println(ois.readChar());
System.out.println(ois.readDouble());
System.out.println(ois.readUTF());//这个是读取字符串
//dog 的编译类型是 Object , dog 的运行类型是 Dog
Object dog = ois.readObject();//这里接收一下dog对象
System.out.println("运行类型="+dog.getClass());
System.out.println("dog信息="+dog);//底层 Object->Dog
//这里是特别重要的细节:
//1. 如果我们希望调用Dog的方法, 需要向下转型
//2. 需要我们将Dog类的定义，放在到可以引用的位置
Dog dog2 = (Dog)dog;
System.out.println(dog2.getName()); //旺财
//关闭流
ois.close();
System.out.println("反序列化完毕");
}
}5. 对象节点流和处理流细节 631
1)读写顺序要致
2)要求序列化或反序列化对象，需要实现Serializable
3)序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性
4)序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
5)序列化对象时，要求里面属性的类型也需要实现序列化接口
6)序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化
6. 标准输入输出流 632
6.1 介绍 632
6.2 应用案例标准输入输出流 632
传统方法System.out.println(””); 是使用out对象将数据输出到显示器
传统的方法，Scanner是从标准输入键盘接收数据
代码在com.stulzl.standard_.包中
InputAndOutput_
package com.stulzl.standard_;
import java.util.Scanner;
//演示说明标准输入输出流 632
public class InputAndOutput_ {
public static void main(String[] args) {
//System.in是 System类中的一个属性-》public final static InputStream in = null
// System.in 编译类型 InputStream
// System.in 运行类型 BufferedInputStream
// 表示的是标准输入 键盘
System.out.println(System.in.getClass());
//System.out是 System类中的一个属性-》public final static PrintStream out = null;
//2. 编译类型 PrintStream
//3. 运行类型 PrintStream
//4. 表示标准输出 显示器
System.out.println(System.out.getClass());
//例，此例没有特别意义不必追究
System.out.println("hello,world");
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容");
String next = scanner.next();
System.out.println("next="+next);
}
}7. 转换流InputStreamReader 和 OutputStreamWriter 633
7.1 先看一个文件乱码问题，引出转换流必要性. 633
代码在com.stulzl.transformation_.
CodeQuestion_
package com.stulzl.transformation_;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
//先看一个文件乱码问题，引出学习转换流必要性. 633
public class CodeQuestion_ {
public static void main(String[] args) throws IOException {
//读取 e:\\a.txt 文件到程序
//思路
//1. 创建字符输入流 BufferedReader [处理流]
//2. 使用 BufferedReader 对象读取 a.txt
//3. 默认情况下，读取文件是按照 utf-8 编码
String filePath = "e:\\a.txt";
BufferedReader br = new BufferedReader(new FileReader(filePath));
//我们在读文件数据默认情况下是按照utf-8 编码的，一但我们改变了文件的编码形式
// ，再读取时就会出现乱码问题
String s = br.readLine();//按行读取
System.out.println("读取到的内容为="+s);
br.close();
}
}
7.2 基本介绍 634
1. InputStreamReader:Reader的子类，可以将InputStream(字节流)包装成(转换)Reader(字符流)
2. OutputStreamWriter:Writer的子类， 实现将OutputStream(字节流)包装成Writer(字符流)
3.当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流
4.可以在使用时指定编码格式(比如utf 8, gbk，gb2312, IS08859-1等)
7.3 应用案例InputStreamReader字节输入转换流
编程将字节流FileInputStream 包装成(转换成)字符流InputStreamReader,对文件进行读取(按照utf-8/gbk格式),进而在包装成BufferedReader
代码在com.stulzl.inputstreamreader_.包中
InputStreamReader_
package com.stulzl.inputstreamreader_;
import java.io.*;
//演示InputStreamReader转换流解决中文乱码问题， 634
// 将字节流 FileInputStream 转成字符流 InputStreamReader, 指定编码 gbk/utf-8
// 对文件进行读取(按照utf-8/gbk格式),进而在包装成BufferedReader
public class InputStreamReader_ {
public static void main(String[] args) throws IOException {
String filePath = "e:\\a.txt";
//解读
//1. 把 FileInputStream 转成 InputStreamReader
//2. 指定编码为 gbk
InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk");
//3. 把 InputStreamReader 传入 BufferedReader
BufferedReader br = new BufferedReader(isr);
//将 2 和 3 合在一起
// BufferedReader br = new BufferedReader(new InputStreamReader(
// new FileInputStream(filePath), "gbk"));
//读取
String s = br.readLine();//按行读取
System.out.println("读取到的内容为="+s);
//关闭流
br.close();
}
}
7.4 案例OutputStreamWriter字节输出转换流 635
2.编程将字节流FileOutputStream包装成(转换成)字符流OutputStreamWriter,对文件进行写入(按照gbk格式,可以指定其他，比如utf-8)
代码在com.stulzl.outputstreamwriter_.包中
OutputStreamWriter_
package com.stulzl.outputstreamwriter_;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
//演示 OutputStreamWriter 使用 635
//2.编程将字节流FileOutputStream包装成(转换成)字符流OutputStreamWriter,
// 对文件进行写入(按照gbk格式,可以指定其他，比如utf-8)
public class OutputStreamWriter_ {
public static void main(String[] args) throws IOException {
String filePath = "e:\\lzl.txt";
String charSet = "utf-8";
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);
osw.write("hi,中国");//按gbk编码将此句输出到e:\lzl.txt
osw.close();
System.out.println("按照 "+charSet+"保存文件成功");
}
}
