学习目标：
- 熟练使用缓冲流进行效率的提高
- 理解转换流的转换原理
- 深入理解编码解码，熟练使用序列化与反序列化
- 了解打印流基本操作
学习内容：
一、缓冲流
1、简介
- 在内存与硬盘文件之间建立一个缓冲区，提升数据的传输效率
- 对应四种流：字节输出流，字节输入流，字符输出流，字符输入流 存在四种缓存流
BufferedOutputStream,BufferedInputStream,BufferedWriter,BufferedReader
2、注意
- 对应的BufferedWriter字符缓冲输出流中存在一个特定的方法
- newLine() 新的一行进行数据的写入
- 对应的BufferedReader字符缓冲输入流中存在一个特定的方法
- readLine() 返回读取到的不包含换行符的行数据，若到文件结尾则返回null
二、转换流
1、编码与解码
- 编码表
- ASCII
- Unicode： utf-8…
- GB： GBK/GB1032…
- 编码表名称的书写不区分大小写
- Unicode与国标都兼容ASCII表
2、字节输出转换流（编码）
- java.io.OutputStreamWriter extends Writer
字符流转换成字节流的桥梁 - 构造方法
- OutputStreamWriter(OutputStream out);
- OutputStreamWriter(OutputStream out, String charsetName);
- 注意：
- 单参数构造方法，默认使用utf-8进行编码
- charsetName代表指定的编码表
3、字节输入转换流（解码）
- java.io.InputStreamWriter extends Reader
- 字节流转换成字符流的桥梁
- 构造方法
- InputStreamWriter(InputStream out);
- InputStreamWriter(InputStream out, String charsetName);
- 注意：
- 单参数构造方法，默认使用utf-8进行解码
- charsetName代表指定的编码表
三、序列化与反序列化
1、简介
- 针对对象进行相关转化工作：
- 序列化：将对象（能看懂的）转换成字节数据进行操作（看不懂的）；
- 反序列化：将字节数据转换成对象
- 序列化与反序列化的类都继承自字节流
2、序列化
- 简介
- java.io.ObjectOutputStream extends OutputStream;
- 构造方法
- ObjectOutputStream(OutputStream out);
- 成员方法
- writeObject(Object obj); 将对象转换成字节数据操作（写入文件）
- 使用前提
- 类实现了Serializable（标志性接口，不需要重写任何方法）接口
3、反序列化
- 简介
- java.io.ObjectInputStream extends InputStream;
- 构造方法
- ObjectInputStream(InputStream in);
- 成员方法
- readObject(Object obj); 将字节数据转换成对象
- 使用前提
- 类实现了Serializable（标志性接口，不需要重写任何方法）接口
- 包含对应的类文件
4、注意
- transient
- 瞬态关键字，当类的变量或者方法用上述瞬态关键字进行修饰，则该变量或者方法不能被序列化
- 序列化与反序列化验证码
- 现象：当对类的对象序列化之后改变类的内容，则不能顺利完成反序列化，会报InvalidClassException异常；
- 解决办法：在类的定义时，直接设置始终不变的序列号，设置方法如下–>
直接在类的定义中添加语句private static final long SerialVersionUID = 序列号L;
四、打印流
1、简介
- java.io.printStream extends OutputStream;
2、构造方法
- printStream(File file);
- printStream(String filename);
- printStream(OutputStream out);
3、特有成员方法
- print()
- println()
4、注意
- 打印流调用继承自父类的write方法会自动的将字节数据转换成对应的字符（97–>a）
- 当调用特有的成员方法print/println时，不会完成自动转换，写啥打印啥
- System.out.print()输出目的地的控制方式
- 默认会输出到控制台显示
- 可以通过调用System.setOut(PrintStream out);设置成输出到对应的打印流目的地
- 打印流只负责数据的输出不负责数据的获取，所以不会产生IOException
学习产出：
1、 缓冲流基本操作
package demo01;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class DemoiBuffered01 {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("1.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
bos.write("你好啊，abcdefg！".getBytes());
bos.close();
}
}
package demo01;
import java.io.*;
public class DemoiBuffered02 {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("1.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
byte[] bytes = new byte[1024];
int val = bis.read(bytes);
System.out.println(new String(bytes,0,val));
bis.close();
}
}
package demo01;
import java.io.*;
public class DemoiBuffered03 {
public static void main(String[] args) throws IOException {
BufferedWriter bw = new BufferedWriter(new FileWriter("2.txt"));
bw.write("Hello");
bw.newLine();
bw.write("你好！");
bw.flush();
bw.close();
}
}
package demo01;
import java.io.*;
public class DemoiBuffered04 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("2.txt"));
// int line = 0;
// while ((line=br.read())!=-1){
// System.out.print((char)line);
// }
// char[] chars = new char[1024];
// while ((line = br.read(chars)) != -1){
// System.out.println(new String(chars,0,line));
// }
String line = null;
while ((line=br.readLine())!=null){
System.out.println(line);
}
br.close();
}
}
2、缓冲流练习
package demo02;
/*
复制文件
*/
import java.io.*;
public class ExciseBuffered01 {
public static void main(String[] args) throws IOException {
long s = System.currentTimeMillis();
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("water.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("复制\\water.jpg"));
int len = 0;
while ((len = bis.read())!=-1){
bos.write(len);
}
bos.close();
bis.close();
long e = System.currentTimeMillis();
System.out.println("复制耗时"+(e-s)+"毫秒");
}
}
package demo02;
/*
文本排序
*/
import java.io.*;
import java.util.HashMap;
public class ExciseBuffered02 {
public static void main(String[] args) throws IOException {
long s = System.currentTimeMillis();
BufferedReader br = new BufferedReader(new FileReader("3.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("复制\\3.txt"));
HashMap<String, String> hashMap = new HashMap<>();
String line;
while ((line = br.readLine())!=null){
String[] arr = line.split("\\.");
hashMap.put(arr[0],arr[1]);
}
for (String key : hashMap.keySet()) {
line = key+"."+hashMap.get(key);
bw.write(line);
bw.newLine();
}
bw.close();
br.close();
long e = System.currentTimeMillis();
System.out.println("复制耗时"+(e-s)+"毫秒");
}
}
3、 编码与解码
package demo03;
import java.io.*;
public class DemoEncode01 {
public static void main(String[] args) throws IOException {
cutf();
}
private static void cutf() throws IOException {
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf-8.txt"));
osw.write("你好");
osw.flush();
osw.close();
}
}
package demo03;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class DemoEncode02 {
public static void main(String[] args) throws IOException {
OutputStreamWriter gbk = new OutputStreamWriter(
new FileOutputStream("gbk.txt"),
"gbk");
gbk.write("你好");
gbk.flush();
gbk.close();
}
}
package demo03;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class DemoDecode01 {
public static void main(String[] args) throws IOException {
InputStreamReader isr = new InputStreamReader(new FileInputStream("utf-8.txt"));
int len;
while ((len=isr.read())!=-1){
System.out.print((char) len);
}
isr.close();
}
}
package demo03;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class DemoDecode02 {
public static void main(String[] args) throws IOException {
InputStreamReader isr = new InputStreamReader(
new FileInputStream("utf-8.txt"),
"gbk");
int len;
while ((len=isr.read())!=-1){
System.out.print((char) len);
}
isr.close();
}
}
4、序列化与反序列化
package demo04;
import java.io.Serializable;
public class Person implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
// public int age;
// private transient int age;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" + "name='" + name + '\'' + ", 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;
}
}
package demo04;
import java.io.*;
public class DemoObjectInputStream {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("对象序列化.txt"));
Object o = ois.readObject();
ois.close();
System.out.println(o);
Person person = (Person) o;
System.out.println(person.getName()+":"+person.getAge());
}
}
package demo04;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class DemoObjectOutputStream {
public static void main(String[] args) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("对象序列化.txt"));
oos.writeObject(new Person("Jim",18));
oos.close();
}
}
package demo04;
import java.io.*;
import java.util.ArrayList;
public class DemoMultiObject {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
ArrayList<Person> people = new ArrayList<>();
people.add(new Person("Jim",18));
people.add(new Person("Tom",28));
people.add(new Person("Mary",38));
oos.writeObject(people);
oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("list.txt"));
Object o = ois.readObject();
ois.close();
ArrayList<Person> people1 = (ArrayList<Person>) o;
for (Person person : people1) {
System.out.println(person);
}
}
}
5、打印流
package demo05;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
public class DemoPrintStream {
public static void main(String[] args) throws FileNotFoundException {
// PrintStream ps = new PrintStream("print.txt");
// PrintStream ps = new PrintStream(new File("print.txt"));
PrintStream ps = new PrintStream(new FileOutputStream("print.txt"));
ps.write(99);
ps.print(97);
ps.println('a');
System.setOut(ps);
System.out.println("你好啊！！！");
ps.close();
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
