第一章 缓冲流
1.1 概述
缓冲流,也叫高效流,是对4个基本的FileXxx
流的增强,所以也是4个流,按照数据类型分类:
- 字节缓冲流:
BufferedInputStream
,BufferedOutputStream
- 字符缓冲流:
BufferedReader
,BufferedWriter
缓冲流的基本原理,是在创建流对象时,会创建一个内置的默认大小的缓冲区数组,通过缓冲区读写,减少系统IO次数,从而提高读写的效率。
1.2 字节缓冲流
BufferedOutputStream:字节缓冲输出流
构造方法:
BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流, 以将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流,已将具有指定缓存
缓冲区大小的数据写入指定的底层输出流
参数:
OutputStream out:字节输出流
我们可以传递 FileOutputStream, 缓冲流会给FileOutputStream增加一个缓冲区,提高FileOutputStream的写入效率
int size:指定缓冲流内部缓冲区的大小,不指定就是默认大小
使用步骤(重点)
1.创建FileOutputStream对象,构造方法绑定要输出的目的地
2.创建BufferedOutputStream 对象 ,构造方法中传递FileOutputStream对象,提高FileOutputStream效率
3.使用BufferedOutputStream对象中的 Write 拿数据写入到内部缓冲区
4.使用BufferedOutputStream 对象中的方法Flush,把内部缓冲去中的数据,刷新到文件
5.释放资源
实现代码:
public class Demo01BufferedWriter {
public static void main(String[] args) throws IOException {
// 1.创建FileOutputStream对象,构造方法绑定要输出的目的地
FileOutputStream fo = new FileOutputStream("D:\\a.txt");
// 2.创建BufferedOutputStream 对象 ,构造方法中传递FileOutputStream对象,提高FileOutputStream效率
BufferedOutputStream bos = new BufferedOutputStream(fo);
// 3.使用BufferedOutputStream对象中的 Write 拿数据写入到内部缓冲区
bos.write("你怎么这么自私".getBytes());
//4.使用BufferedOutputStream 对象中的方法Flush,把内部缓冲去中的数据,刷新到文件
bos.flush();
//释放资源
bos.close();
}
}
BufferedInputStream:字节缓冲输入流
构造方法:
BufferedInputStream(InputStream in) 创建一个BufferedInputStream, 并保存其参数,及保存其参数,即输入流 in,以便将来使用
BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的BufferedInputStream 并保存其参数,即输入流in以便将来使用
参数:
InputStream int:字节输入流
我们可以传递 FileInputStream, 缓冲流会给FileInputStream增加一个缓冲区,提高FileInputStream的写入效率
int size:指定缓冲流内部缓冲区的大小,不指定就是默认大小
使用步骤(重点)
1.创建FileInputStream对象,构造方法绑定要读取的目的地
2.创建BufferedInputStream 对象 ,构造方法中传递BufferedInputStream对象,提高BufferedInputStream效率
3.使用BufferedInputStream对象中的 read ,读取文件
4.释放资源
代码实现:
public class Demo01BufferedRead {
public static void main(String[] args) throws IOException {
FileInputStream fi = new FileInputStream("D:\\a.txt");
BufferedInputStream bi = new BufferedInputStream(fi);
int len;
byte[] bytes = new byte[1024];
while ((len=bi.read(bytes))!=-1){
System.out.println(new String(bytes));
}
bi.close();
}
}
1.3 字符缓冲流
BufferedWriter:字符缓冲输出流
老思路:
看构造方法:
BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
BufferedWriter(Writer out, int sz) 创建一个新的缓冲字符输出流,使用给定大小的输出缓冲区。
参数:
Writer out:字符输出流
可以传递FileWriter,缓冲流会给FileWriter增加一个缓冲区,提高FileWriter的写入效率
Writer out, int sz
指定缓冲区的大小,不写默认大小
特有的成员方法:
public void newLine() 写一行行分隔符,由系统属性定义符号
换行:换行符号
windows:\r\n
linux: /n
mac:/r
步骤:
1.创建字符缓冲输出流对象,构造方法中传递字符输出流
2.调用字符串缓冲输出流的方法writer,把数据写入到内存缓冲区中
3.调用字符串缓冲输出流中的方法flush,把内存缓冲区中的数据,刷新到文件
4,释放资源
代码的实现:
public class BufferedWriterDemo {
public static void main(String[] args) throws IOException {
// 创建字符缓冲输入流
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\log\\van.txt"));
//调用字符串缓冲输出流的方法writer,把数据写入到内存缓冲区中
for (int i = 0; i < 10; i++) {
bw.write("Ox Van");
bw.newLine();
}
//调用字符串缓冲输出流中的方法flush,把内存缓冲区中的数据,刷新到文件
bw.flush();
//释放资源
bw.close();
}
}
BufferedReader:字符缓冲输入流
构造方法:
BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz) 创建使用指定大小的输入缓冲区的缓冲字符输入流。
参数:
Reader in:字符输入流
特有的成员方法:
String readLine() 读取一个文本行。读取一行数据
行的终止符号:通过下列字符之一即可认为某行已终止
返回值:
包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null
使用步骤:
1.创建字符缓冲输入流,构造方法传递字符输入流
2.使用字符缓冲输入该对象中的方法read/readLine读取文本
3.释放资源
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("D:\\log\\van.txt"));
//使用字符缓冲输入该对象中的方法read/readLine读取文本
String line;
while ((line=br.readLine())!=null){
System.out.println(line);
}
br.close();
}
}
1.4 练习:文本排序
3.侍中、侍郎郭攸之、费祎、董允等,此皆良实,志虑忠纯,是以先帝简拔以遗陛下。愚以为宫中之事,事无大小,悉以咨之,然后施行,必得裨补阙漏,有所广益。
8.愿陛下托臣以讨贼兴复之效,不效,则治臣之罪,以告先帝之灵。若无兴德之言,则责攸之、祎、允等之慢,以彰其咎;陛下亦宜自谋,以咨诹善道,察纳雅言,深追先帝遗诏,臣不胜受恩感激。
4.将军向宠,性行淑均,晓畅军事,试用之于昔日,先帝称之曰能,是以众议举宠为督。愚以为营中之事,悉以咨之,必能使行阵和睦,优劣得所。
2.宫中府中,俱为一体,陟罚臧否,不宜异同。若有作奸犯科及为忠善者,宜付有司论其刑赏,以昭陛下平明之理,不宜偏私,使内外异法也。
1.先帝创业未半而中道崩殂,今天下三分,益州疲弊,此诚危急存亡之秋也。然侍卫之臣不懈于内,忠志之士忘身于外者,盖追先帝之殊遇,欲报之于陛下也。诚宜开张圣听,以光先帝遗德,恢弘志士之气,不宜妄自菲薄,引喻失义,以塞忠谏之路也。
9.今当远离,临表涕零,不知所言。
6.臣本布衣,躬耕于南阳,苟全性命于乱世,不求闻达于诸侯。先帝不以臣卑鄙,猥自枉屈,三顾臣于草庐之中,咨臣以当世之事,由是感激,遂许先帝以驱驰。后值倾覆,受任于败军之际,奉命于危难之间,尔来二十有一年矣。
7.先帝知臣谨慎,故临崩寄臣以大事也。受命以来,夙夜忧叹,恐付托不效,以伤先帝之明,故五月渡泸,深入不毛。今南方已定,兵甲已足,当奖率三军,北定中原,庶竭驽钝,攘除奸凶,兴复汉室,还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益,进尽忠言,则攸之、祎、允之任也。
5.亲贤臣,远小人,此先汉所以兴隆也;亲小人,远贤臣,此后汉所以倾颓也。先帝在时,每与臣论此事,未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军,此悉贞良死节之臣,愿陛下亲之信之,则汉室之隆,可计日而待也。
public class BufferedTest {
public static void main(String[] args) throws IOException {
//创建流对象
BufferedReader br = new BufferedReader(new FileReader("D:\\log\\lsk.txt"));
BufferedWriter bo = new BufferedWriter(new FileWriter("D:\\log\\lk.txt"));
//创建一个HashMap集合对象,存储每行文本的序号(1,2,3···) value:存储每行的文本
Map<String,String> map=new HashMap<>();
String line;
while ((line= br.readLine())!=null){
String[] split = line.split("\\.");
map.put(split[0],split[1]);
}
//遍历集合 获得每一个键值对
for (String k : map.keySet()) {
String v = map.get(k);
//键值对拼接
line=k+"."+v;
bo.write(line);
bo.newLine();
}
//释放资源
bo.close();
br.close();
}
}
第二章节:转换流
2.1字符编码和字符集
字符编码
计算机中存储的信息都是二进制数表示的,按照某种规划,将字符存储到计算机中,称为编码
反之将存储在计算机中二进制数按照某种规划解析显示出来,称为解码
-
字符编码
Character Encoding
: 就是一套自然语言的字符与二进制数之间的对应规则。编码表:生活中文字和计算机中二进制的对应规则
字符集
字符集 Charset
:也叫编码表。是一个系统支持的所有字符的集合,包括各国家文字、标点符号、图形符号、数字等。
2.2OutputStreamWriter:
是字符流通向字节流的桥梁:可指定的charset 将要写入流中的字符编码成字节
构造方法
OutputStreamWriter(OutputStream out)
: 创建一个使用默认字符集的字符流。OutputStreamWriter(OutputStream out, String charsetName)
: 创建一个指定字符集的字符流。
参数:
OutputStream out : 字节输出流,可以用来写转换之后的字节到文件中
String charsetName:指定的编码表名称,不区分大小写,默认时UTF-8
使用步骤:
- 创建OutputStreamWriter 对象,构造方法中传递字节输出流和指定的编码表名称
- 使用OutputStreamWriter 对象中的方法writer,把字符转换为字节存储缓冲区中(编码)
- 使用OutputStreamWriter 对象中的flush方法, 把内存缓冲区中的字节刷新到文件中
- 释放资源
public class WriterDemo2 {
public static void main(String[] args) throws IOException {
writer_utf();
}
private static void writer_utf() throws IOException {
// 创建OutputStreamWriter 对象,构造方法中传递字节输出流和指定的编码表名称
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\log\\u8"),"UTF-8");
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\log\\u8.txt"));//不指定默认为utf-8
//使用OutputStreamWriter 对象中的方法writer,把字符转换为字节存储缓冲区中(编码)
osw.write("早呀");
//使用OutputStreamWriter 对象中的flush方法, 把内存缓冲区中的字节刷新到文件中
osw.flush();
//释放内存
osw.close();
}
}
2.3InputStreamReader类
字节流通向字符流的桥梁:它使用指定的charset 读取字节并将其解码为字符
构造方法
InputStreamReader(InputStream in)
创建一个使用默认字符集的InputStreamReader。
InputStreamReader(InputStream in, String charsetName)
创建一个使用命名字符集的InputStreamReader。
参数 ;
InputStream in :字节输入流,用来读取文件中保存的字节
String charsetName :指定的编码表名称,不区分大小写
使用步骤:
- 创建InputStreamReader对象,构造方法中传递字节输入流和指定的指定的编码表名称
- 使用InputStreamReader对象中的方法read读取文件
- 释放资源
注意事项:
构造方法中指定的编码表名称要和文件的编码相同,否则乱码
public class ReaderDemo3 {
public static void main(String[] args) throws IOException {
read_utf();
}
private static void read_utf() throws IOException {
// 创建InputStreamReader对象,构造方法中传递字节输入流和指定的指定的编码表名称
//InputStreamReader isw = new InputStreamReader(new FileInputStream("D:\\log\\u8"),"UTF-8");
InputStreamReader isw = new InputStreamReader(new FileInputStream("D:\\log\\u8.txt"));//不指定默认为utf-8
//使用InputStreamReader对象中的方法read读取文件
int len;
byte[] bytes = new byte[1024];
while ((len=isw.read())!=-1){
System.out.println((char) len);
}
//释放资源
isw.close();
}
}
2.4练习:转换文件编码
将GBK编码的文本文件,转换为UTF-8编码的文本文件。
public class lxDemo3 {
public static void main(String[] args) throws IOException {
//读
InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\log\\GBK.txt"),"GBK");
//写
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\log\\UTF-8.txt"),"UTF-8");
int len=0;
while ((len=isr.read())!=-1){
osw.write(len);
}
//释放资源
osw.close();
isr.close();
}
}
第三章 序列化
Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象,该字节序列包含该对象的数据
、对象的类型
和对象中存储的属性
等信息。字节序列写出到文件之后,相当于文件中持久保存了一个对象的信息。
反之,该字节序列还可以从文件中读取回来,重构对象,对它进行反序列化。对象的数据
、对象的类型
和对象中存储的数据
信息,都可以用来在内存中创建对象
3.1ObjectOutputStream :对象的序列化流
作用 : 把对象以流的方式写入到文件中保存
构造方法:
ObjectOutputStream(OutputStream out)
创建写入指定 OutputStream 的
ObjectOutputStream
参数:
OutputStream out:字节输出流
特有的成员方法:
void writeObject(object obj) 将指定的对象写入 ObjectOutputStream
使用步骤:
- 创建ObjectOutputStream对象,构造方法中传递字节输出流
- 使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中
- 释放资源
/*
* Serializable 标记型接口
* 要进行序列化和反序列化的类必须实现Serializable接口,就会给类添加一个标记
*
* */
public class Person implements Serializable {
protected String name;
protected int age;
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;
}
}
public class Demo01 {
public static void main(String[] args) throws IOException {
//创建ObjectOutputStream对象,构造方法中传递字节输出流
ObjectOutputStream obs = new ObjectOutputStream(new FileOutputStream("day830\\Person.txt"));
obs.writeObject(new Person("老姐姐",18));
obs.close();
}
}
3.2ObjectOutInputStream :对象的反序列化流
作用:将之前使用ObjectOutputStream序列化的原始数据恢复为对象。
构造方法
public ObjectInputStream(InputStream in)
: 创建一个指定InputStream的ObjectInputStream。
参数:
InputStream in :字符输入流
特有的成员方法:
Object readObject() 从 ObjectInputStream 读取对象
使用步骤:
- 创建ObjectInputString对象,构造方法中传递字节输入流
- 使用ObjectInputString对象中的方法readObject读取保存对象的文件
- 释放资源
- 打印
ClassNotFoundException(class找不到异常)
反序列化的前提:
1.类必须实现Serializable接口
2.必须存在类对应的class文件
public class WDemo02 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//创建ObjectInputString对象,构造方法中传递字节输入流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day830\\Person.txt"));
//使用ObjectInputString对象中的方法readObject读取保存对象的文件
Object o = ois.readObject();
//释放资源
ois.close();
//打印
System.out.println(o);
}
}
static关键字: 静态关键字
静态优先于非静态加载到内存中(静态优先于对象进入到内存中)
被static修饰的成员变量不能被序列化,序列化的都是对象
瞬态关键字:transient
被transient关键字修饰的成员变量,不能被序列化
public class Person implements Serializable {
private String name;
private transient int age;
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;
}
}
在main方法里面的代码与**WDemo02
**一样
在前面有一个异常ClassNotFoundException:对于JVM可以反序列化对象,它必须是能够找到class文件的类。如果找不到该类的class文件,则抛出一个 ClassNotFoundException
异常
如果 JVM反序列化对象时,能找到class文件,但是class文件在序列化对象之后发生了修改,那么反序列化操作也会失败,抛出一个InvalidClassException
异常。
发生这个异常的原因如下:
- 该类的序列版本号与从流中读取的类描述符的版本号不匹配
- 该类包含未知数据类型
- 该类没有可访问的无参数构造方法
Serializable
接口给需要序列化的类,提供了一个序列版本号。serialVersionUID
该版本号的目的在于验证序列化的对象和对应类是否版本匹配。
直接反序列化不会报错因为我们用的都是同一个序列化
3.3 小练习 序列化集合
public class Demo03Test {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//创建一个存储Person的集合
List<Person> list=new ArrayList<>();
//添加对象
list.add(new Person("张三",19));
list.add(new Person("李四",14));
list.add(new Person("王麻子",18));
list.add(new Person("淘气",29));
//创建一个序列化流
ObjectOutputStream ops = new ObjectOutputStream(new FileOutputStream("day830\\list.txt"));
//writeObject方法对集合序列化
ops.writeObject(list);
//创建一个反序列化流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day830\\list.txt"));
//readObject 读取集合
Object o = ois.readObject();
//强转
ArrayList<Person> arr=(ArrayList<Person>) o;
//遍历
for (Person person : arr) {
System.out.println(person);
}
//释放资源
ois.close();
ops.close();
}
}