目录
3.1.OutputStream和FileOutputStream输出流
3.2.InputStream和FileInputStream输入流
7.7.InvalidClassException异常的原理(序列号不匹配问题)
1.IO流概述
- 电脑里的硬盘一直在转动，硬盘上还有磁头，硬盘存储数据特点:永久存储；硬盘里面有一个文件a.txt，文件中存储了一个字符串"abc",磁头通过硬盘的旋转来读取不同的文件。电脑里的另一个硬件即内存，内存存储数据特点:临时存储。
IO流概述:
- I:input输入(读取到内存)
- O:output输出(写入文件)
- 流:即数据(包括字符和字节),1个字符=2字节，1个字节=8个二进制位(bit比特位)
- 输入:把硬盘中的数据读取到内存中使用
- 输出:把内存中的数据写入到硬盘中保存。
- 由于数据分为字符和字节，因此流又分为字节流和字符流两种。
- 字节流的两个顶级父类:字节输入流InputStream、字节输出流OutputStream
- 字符流的两个顶级父类:字符输入流Reader、字符输出流Writer
2.一切皆为字节
- 一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都是一个一个的字节(Byte/B)，
- 那么传输时也是如此，所以字节流可以传输任意文件数据，在操作流的时候，要时刻明确，无论使用什么样的流对象，底层传输的始终是二进制数据。
3.字节流
3.1.OutputStream和FileOutputStream输出流
3.1.1.FileOutStream的使用
- 1. java.io.OutputStream:字节输出流(即io包下的OutputStream类)概述，此类为抽象类，表示输出字节流的所有类的超类(父类)
- 2.OutputStream抽象类定义了子类共性的成员方法:
-public void close():关闭此输出流并释放与此流相关联的任何系统资源
-public void flush():刷新此输出流并强制任何缓冲的输出字节被写出。
-public void write(byte[] b):将b.length字节从指定的字节数组写入此输出流
-public void write(byte[] b,int off,int len):
从指定的字节数组中写入len个字节(到内存)，从偏移量off开始输出到此输出流。
-public abstract void write(int b):将指定的(一个)字节输出流- 3.java.io.FileOutputStream extends OutputStream
- FileOutputStream:文件字节输出流(是一个继承类，主要讲这个继承类)
- 作用:把内存中的数据写入到硬盘的文件中
- 构造方法:
- FileOutputStream(String name):创建一个向具有指定名称的文件中写入数据的输出文件流
- FileOutputStream(File file):创建一个向指定File对象表示的文件中写入数据的文件输出流
- 参数:表示写入数据的目的地
- String name :目的地是一个文件的路径(字符串类型)
- File file:目的地是一个文件
- 构造方法的作用:
- 1.创建一个FileOutputStream文件输出流对象
- 2.会根据构造方法中传递的文件/文件路径，创建一个空文件
- 3.会把FileOutputStream对象指向创建好的文件
- 即创建流对象，创建空文件，流对象指向空文件
- 4.字节输出流的使用步骤(重点):
- 1.创建一个FileOutStream文件输出流对象，构造方法中传递写入数据的目的地
- 2.调用FileOutputStream对象中的方法write，把数据写入到文件
- 3.释放资源(流会占用一定的内存，使用完毕需要把内存清空，提高程序效率)
- 注意上述三个方法都抛异常，而第二步的write方法抛出的异常最大，另外两个异常为子类，因此只要将第二步的write方法抛出异常即可。
3.1.2.字节输出流写入数据到文件的原理(内存->硬盘)
java程序-->JVM(java虚拟机)-->OS(操作系统)-->OS调用写输入的方法-->把数据写到文件中
3.1.3.FileOutStream—Demo
文件字节输出流Demo
当前项目名称是java,使用相对路径在当前项目下的IO流模块中创建文件IO\\a.txt
package OutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo2OutputStream {
public static void main(String[] args) throws IOException {
//下面使用文件字节输出流FileOutputStream将数据97从内存写入硬盘a.txt文件中
//1.创建一个FileOutStream文件输出流对象，构造方法中传递写入数据的目的地(可相对路径)
FileOutputStream fos = new FileOutputStream("IO\\a.txt");
//2.调用FileOutputStream对象中的方法write，把数据写入到文件
fos.write(97);//将一个字节写入到文件
//3.释放资源(流会占用一定的内存，使用完毕需要把内存清空，提高程序效率)
fos.close();
}
}
3.1.4.文件存储的原理和记事本打开文件
- 使用文件字节输出流FileOutputStream将数据97从内存写入硬盘a.txt文件中 为例:
- 总之:将内存数据以二进制形式存入硬盘文件，当打开硬盘文件时查询编码表将二进制转化为字符展示。
- 首先调用文件字节输出流构造方法时，会先创建文件字节输出流对象，
- 然后构造方法会根据传递的文件/文件路径，创建一个空文件，
- 然后文件字节输出流FileOutputStream对象执行空文件，
- 当调用write方法写入数据的时候，会把十进制的整数97，转化为二进制1100001，即fos.write(1100001);所以文件a.txt中存储的就是二进制的97即1100001，因为硬盘中存储的数据都是字节，1个字节=8比特。
- 当打开文本编辑器时(记事本等)，会查询编码表，把字节转化为字符表示，
- 若文件中的二进制转化十进制在0-127范围:则查询ASCII表，易只97-->a
- 若不在0-127范围:则查询系统默认码表(如中文系统查询 GBK)
3.1.5.字节输出流写多个字节的方法
字节输出流写多个字节到硬盘文件的方法:
-public void write(byte[] b):将指定字节数组中字节写入此输出流
-public void write(byte[] b,int off,int len):
从指定的字节数组中写入len个字节(到内存)，从偏移量off开始输出到此输出流。即字节数组部分写入到文件
写入字符串的方法:可以使用String类中的getBytes()方法把字符串，转化为字节数组
然后调用write方法把字节数组写入文件，就实现了字符串的写入。
byte[] getBytes():把字符串转化为字节数组字节输出流写多个字节到硬盘文件
package OutputStream;
import sun.plugin.javascript.navig.Array;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
public class Demo3OutputStream {
public static void main(String[] args) throws IOException {
//1.创建一个FileOutStream文件输出流对象，构造方法中传递写入数据的目的地(可相对路径)
FileOutputStream fos = new FileOutputStream("IO流\\b.txt");
//2.1.调用FileOutputStream对象中的方法write，把数据写入到文件
// 若文件中存储的是一百100，那么需要写入3个字节，1对应ASCII码的49，0对应48
fos.write(49);
fos.write(48);
fos.write(48);
/**2.2
* -public void write(byte[] b):将指定字节数组中字节写入此输出流
* 一次写多个字节：
* 如果写的第一个字节是正数(0-127),那么显示的时候会查询ASCII表
* 如果写的第一个字节是负数，那第一个字节会和第二个字节，两个字节组成一个中文显示，
* 查询系统默认码表(GBK)
*/
byte[] bytes={65,66,67,68};//创建字节数组
fos.write(bytes); //将字节数组写入文件，显示为abcd
byte[] bytes1={-60,-61,-62,-63,64,65};//3个字节为一个汉字，且开头为负
fos.write(bytes1); //写入文件显示
/**2.3
*-public void write(byte[] b,int off,int len):
* 即把字节数组中的一部分写入到文件中。int off:数组的开始索引 int len:写几个字节
*/
fos.write(bytes,1,2);//将bytes字节数组中从第1位及后2位字节写入文件，输出bc
/**2.4
* 写入字符串的方法:可以使用String类中的getBytes()方法把字符串，转化为字节数组
* 然后调用write方法把字节数组写入文件，就实现了字符串的写入。
* byte[] getBytes():把字符串转化为字节数组
*/
byte[] bytes2="你好".getBytes();
System.out.println(bytes2);//输出数组地址[B@14ae5a5
//"你好"对应的字节[-28, -67, -96, -27, -91, -67]
//因为现在使用utf-8编码，这里是3个字节对应一个中文，GBK编码中2个字节是一个中文
System.out.println(Arrays.toString(bytes2));
fos.write(bytes2);//将字节数组写入文件b.txt,文件显示为"你好"
//3.释放资源(流会占用一定的内存，使用完毕需要把内存清空，提高程序效率)
fos.close();
}
}3.1.6.字节输出流续写与换行
续写/追加
字节输出流的续写(追加写):使用含两个参数的构造方法
FileOutputStream(String name,boolean append):
创建一个向具有指定名称的文件中写入数据的输出文件流
FileOutputStream(File file,boolean append):
创建一个向指定File对象表示的文件中写入数据的文件输出流参数:
- String name,File file:写入数据的目的地(要么是字符串型路径要么是File封装路径)
- boolean append:追加写开关
- true:创建对象不会覆盖源文件，继续在文件末尾追加写数据
- false:创建一个新文件，覆盖源文件
换行:
- 写换行符号windows:\r\n linux:/n mac:/r
- 要实现换行，将换行字符串调用getBytes()方法化为字节数组传递到write方法中
package OutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo4OutputStream {
public static void main(String[] args) throws IOException {//需抛异常
//1.创建文件输出流对象，第一个参数为目的地，第二个参数追加开关true
FileOutputStream fos = new FileOutputStream("IO流\\c.txt", true);
//2.流对象调用write方法，将字符串"你好"写入c.txt文件，调用getBytes()化字符串为字节数组
fos.write("你好1".getBytes());//两个字符串续写在c.txt中，没有覆盖文件
fos.write("你好2".getBytes());//结果:你好1你好2
//3.每输入一个"你好"就换行一次
for (int i=0;i<10;i++){
fos.write("你好".getBytes());//写入数据到c.txt，没有覆盖文件
fos.write("\r\n".getBytes());
}
//关闭字节输出流
fos.close();
}
}
3.2.InputStream和FileInputStream输入流
3.2.1.FileInputStream的使用
- java.io.InputStream:字节输入流，此抽象类是表示字节输入流的所有类的超类(父类)
- 该抽象类定义了所有子类共性的方法:
int read():从输入流中获取数据的下一个字节,读取到文件的末尾则返回-1
int read(byte[] b):输入流中读取一定数量的字节，并将其存储到缓冲区的数组b中
void close():关闭此输入流并释放与该关联的所有系统资源- 3.java.io.FileInputStream extends InputStream (InputStream抽象类的继承类)
- FileInputStream:文件字节输入流
- 作用:把硬盘中的数据，读取到内存中使用
- 4.构造方法:
FileInputStream(String name)
FileInputStream(File file)
参数:读取文件的数据源
String name:字符串类型的文件路径
File file:封装路径的文件对象
- 5.构造方法的作用:
- 1.会创建FileInputStream文件输入流对象，构造方法中绑定要读取的数据源
- 2.FileInputStream流对象指定构造方法中要读取的文件
- 6.读取数据的原理(硬盘-->内存)
- java程序-->JVM-->OS-->OS读取数据的方法-->读取文件
- 7.字节输入流InputStream的使用步骤(重点):
- 1.创建FileInputStream文件输入流对象，构造方法中绑定要读取的数据源
- 2.使用FileInputStream对象中的方法read，读取文件
- 3.释放资源
3.2.2.字节输入流读取字节数据
package InputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class Demo1InputStream {
public static void main(String[] args) throws IOException {
//1.创建FileInputStream文件输入流对象，构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("IO流\\a.txt");
/*2.使用FileInputStream对象中的方法read，读取文件a.txt,该文件中数据为abc
//read()方法读取文件中的一个字节并返回，若读取到文件末尾返回-1
int read = fis.read();
System.out.println(read);//输出97 文件中显示为a
read=fis.read();
System.out.println(read);//输出98 文件中显示为b
read=fis.read();
System.out.println(read);//输出99 文件中显示为c
read=fis.read();
System.out.println(read);//输出-1 文件读取完毕*/
/**
* 上述可以使用循环优化，不知道循环次数，使用while循环
* while循环结束条件是读取到-1时候结束
*/
int len=0;//记录读取到的字节
while((len=fis.read())!=-1){
System.out.println((char)len); //输出abc
}
/* while(fis.read()!=-1){
//只能输出b和-1，因为每次循环调用两次read(),文件指针移动2次
System.out.println((char)fis.read());
}
*/
//3.释放资源
fis.close();
}
}
3.2.3.字节输入流一次读取一个字节原理
创建文件字节输入流对象，构造方法中绑定要读取的文件，流对象调用read方法时，java程序调用jvm，jvm调用os,os调用读取方法读取文件中字节
3.2.4.字节输入流一次读取多个字节原理
- 硬盘中的文件d.txt中的数据是ABCDE,
- 第一步创建流对象指向要读取的文件，
- 然后创建一个字节数组长度为2，数组初始值为0，
- 下面开始读取数据，同样的，java程序找到jvm,jvm找到os,os调用方法读取数据，开始文件指针指向起始位置
- 第一次read读取两个字节(字节数组有两个位置)，所以读取了A,B，返回len为2表示读取有效字节个数，此时文件指针指向C的位置。
- 第二次read同样读取两个字节C,D,返回读取有效字节数2,读取的C,D把之前的字节数组中的A,B覆盖掉，所以输出C,D此时文件指针就移动到E位置。
- 第三次read读取文件时只剩下一个字节E,读取E覆盖到之前数组中的C，因此输出E,D,返回有效读取字节len为1
- 第四次read读取文件，此时文件指针指向结束标记位置，没有读取到数据，len返回为-1
字节数组的作用:
- 缓存作用，存储读取到的多个字节。若是定义new byte[5]一次读取5个字节，可提高效率。
3.2.5.字节输入流一次读取多个字节
- 1.字节输入流一次读取多个字节的方法:
- int read(byte[] b):输入流中读取一定数量的字节，并将其存储到缓冲区的数组b中
- 2.明确两件事情:
- 1.方法中的参数byte[]的作用
- 起到缓冲作用，存储每次读取到的多个字节，数组的长度一般定义为1024(1kb)字节或1024整数倍
- 2.方法的返回值int是什么
- 每次读取到的有效字节个数
- 1.方法中的参数byte[]的作用
- 3.String类的构造方法
- String(byte[] bytes):把字节数组转换为字符串
- String(byte[] bytes,int offset,int length):把字节数组中一部分转换为字符串，offset数组的开始索引，length转换的字节个数
package InputStream;
import com.sun.org.apache.xpath.internal.operations.String;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
public class Demo2InputStream1 {
public static void main(String[] args) throws IOException {
//创建FileInputStream文件字节输入流对象，构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("IO流\\d.txt");
//文件输入流对象调用read方法读取文件,将读取的字节存入缓冲区的字节数组b中
byte[] bytes=new byte[5];//创建字节数组
int len=fis.read(bytes);//将读取的数据abcde存入字节数组，以ASCII码97 98 99形式
System.out.println(len);//返回的len是读取文件的字节数5
//调用Arrays工具类的toString方法来遍历数组bytes输出[65,66,67,68,69]
System.out.println(Arrays.toString(bytes));
//为使字节数组中数据[65,66,67,68,69]转化为字符串即文件中的ABCDE,
// 即解码，将计算机看的懂的转化我们看得懂
// 可以调用String类构造方法传递字节数组
System.out.println(new java.lang.String(bytes));//输出ABCDE
/**
* 使用循环来优化，不知道循环次数，使用while，
* 循环结束条件读取到-1结束
*/
byte[] bytes1 = new byte[1024];//创建字节数组
int len1=0;//记录每次读取到的有效字节数
while((len1=fis.read(bytes1))!=-1){//当读取的字节数大于0
//使用String(byte[] bytes,int offset,int length)方法，指定读取个数
//因为初始化数组存储1024字节，所以第一次读取就可全部读取出len1=5，
//若直接使用 String(byte[] bytes)，没有限制，会读取1024个字节，只有5个有效
System.out.println(new java.lang.String(bytes1,0,len1));
}
//释放资源
fis.close();
}
}
3.2.6.字节流练习_文件复制
C盘中的1.jpg、a.txt、wwww.avi、123.mp3这些文件都是以字节方式存储，所以使用字节流读取任意文件包括文本，图片，音乐，电影等然后再写入到D盘中，这就使用到流技术，任何的java程序都要进入内存中执行，java程序中需要创建一个文件输入流读取文件到内存，然后创建一个文件输出流将内存中数据写入硬盘文件。文件复制就是一读一写。
package Demo3CopyFile; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class Demo01CopyFile { public static void main(String[] args) throws IOException { long s = System.currentTimeMillis(); //1.创建一个字节输入流对象，构造方法绑定要读取的数据源 FileInputStream fis = new FileInputStream("IO流\\a.txt"); //2.创建一个字节输出流对象，构造方法中绑定要写入的目的地 FileOutputStream fos = new FileOutputStream("IO流\\d.txt"); /** * 一次读取一个字节写入一个字节的方式： * int read():从输入流中获取数据的下一个字节,读取到文件的末尾则返回-1 * 下面将a.txt中的abc读取并复制到d.txt中，只有三个字节需要循环三次 * 缺点:有多少字节就要循环多少次，若是上千字节的图片就要循环千遍。 */ /* 3.使用字节输入流对象中的read方法读取文件 int len=0;//记录获取的字节，若获取空则返回-1 while((len=fis.read())!=-1){ //4.使用字节输出流对象中的write方法把读取到的字节写入到目的地文件中 fos.write(len); }*/ /** * 下面使用一次读取多个字节并写入多个字节的方法: * int read(byte[] b):输入流中读取一定数量的字节，并将其存储到缓冲区的数组b中 * 使用数组缓冲读取多个字节，写入多个字节 */ byte[] bytes=new byte[1024];//创建缓冲字节数组，存储1024字节 int len=0;//这里的len记录着读取的有效字节数 //3.使用字节输入流对象中的read方法读取文件 while((len=fis.read())!=-1){ //4.使用字节输出流对象中的write方法把读取到的字节写入到目的地文件中 fos.write(bytes,0,len); } //5.释放资源(先释放输出流对象，若写完了，肯定读完了) fos.close(); fis.close(); long e = System.currentTimeMillis(); System.out.println("复制文件共耗时:"+(e-s)+"毫秒"); } } /** * 缓存数组最大缓存容量1024字节，若是读取的文件大于1024字节，那么read(byte[]b) * 第一次读取的字节数是1024赋值给len，下一次只能读取1个效字节，复制到缓存数组的 * 索引为0的位置，并返回len值为1，这样在第二次write写入时写入的是数组中0-len长度 * 的字节，若是开始读取的文件小于1024，为200字节，那么read(byte[] b)方法读取的 * 有效字节数就是200，len值为200，所以write写入的时候只写数组的0-200的字节
4.字符流
4.1.字节流读取中文的问题
当使用字节流读取文本文件时，可能会有一个小问题，就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储，所以java提供一些字符流，以字符为单位读写数据，专门用于处理文本文件。
4.2.Reader和FileReader字符输入流
4.2.1.Reader和FileReader基本使用
- java.io.Reader:字符输入流，是字符输入流最顶层的父类，定义了一些共性成员方法，是抽象类
- Reader抽象类共性的成员方法:
int read():读取单个字符并返回
int read(char[] cbuf):一次读取多个字符，将字符读入数组
void close():关闭该流，并释放与之关联的所有资源- java.io.FileReader extends InputStreamReader extends Reader
- FileReader:文件字符输入流
- 作用:把硬盘文件中的数据以字符的方式读取到内存中
- 构造方法:
FileReader(String fileName)
FileReader(File file)
参数:读取文件的数据源
String fileName:字符串型的文件路径
File file:一个文件(将路径封装的文件对象)
构造方法的作用:
1.创建一个FileReader字符输入流对象
2.把字符输入流对象指向要读取的文件- 字符输入流的使用步骤:
- 1.创建FileReader文件字符输入流对象，构造方法绑定要读取的数据源
- 2.文件字符输入流对象调用方法read读取数据
- 3.释放资源
- String类另外两个构造方法(字符数组与字符串转化):
String(char[] value):把字符数组转换为字符串
String(char[] value,int offset,int count)把字符数组的一部分转化为字符串FileReader的使用
package Reader;
import java.io.FileReader;
import java.io.IOException;
public class Demo02Reader {
public static void main(String[] args) throws IOException {
//1.创建FileReader文件字符输入流对象，构造方法绑定要读取文件，e.txt中数据是: 你好abc
FileReader fr = new FileReader("IO流\\e.txt");
//2.文件字符输入流对象调用read方法读取文件
/*2.1 int read():读取单个字符并返回，使用while循环，当返回值为-1结束
int len=0;//这里的len表示读取的单个字符
while ((len=fr.read())!=-1){//单个字符的获取需要循环多次while，效率低
//对于汉字，一个汉字算一个字符,"你好abc"读取出来为20320 22909 97 98 99
System.out.print(len+" ");
//上述是计算机可以看懂的输出数据，下面可以强转，换成我们可以看懂的
System.out.print((char)len+" ");//输出:你 好 a b c
}
*/
//2.2.int read(char[] cbuf):一次读取多个字符，将字符存入数组
char[] cs = new char[1024];//先定义一个字符数组
int len=0;//记录获取的有效字符数，获取空则len=-1结束
//循环读取文件，以字符形式存入数组cs中，返回有效读取字符数len
while((len=fr.read(cs))!=-1){
//注意该版本的jdk不能使用String类的构造方法化字符数组为字符串
//System.out.println(new String(cs,0,len));
}
//3.关闭流，释放资源
fr.close();
}
}4.3.Writer和FileWriter字符输出流
4.3.1.Writer和FileWriter基本使用
- 1.java.io.Writer:字符输出流，是所有字符输出流的最顶层的父类，是一个抽象类
- 2.该抽象类Writer的共性成员方法:
* -void write(int c):写入单个字符
* -void write(char[] cbuf):写入字符数组
* -abstract void write(char[] cbuf,int off,int len):写入字符数组的一部分
* -void write(String str):写入字符串
* -void write(String str,int off,int len):写入字符串的一部分
* -void flush():刷新该流的缓冲，把内存缓冲区中的数据，刷新到文件中，刷新完后流还可以使用
* -void close():关闭此流，但要先刷新该流缓冲区中的数据，刷新后此流就被销毁了。- 3.主要学习该抽象方法下的FileWriter文件字符输出流(继承类)
- java.io.FileWriter extends OutputStreamWriter extends Writer
- FileWriter:文件字符输出流(即继承类)
- 作用:将内存中字符数据写入到文件中
- 4.FileWriter构造方法
* FileWriter(File file):根据给定的File对象，构造一个FileWriter文件字符输出流对象
* FileWriter(String fileName):根据给定的文件名，构造一个FileWriter对象
* 参数:表示写入数据的目的地
* String fileName:文件的路径(字符串型)
* File file:是一个文件(File对象)
* 构造方法作用:
* 1.创建一个FileWriter对象
* 2.会根据构造方法中传递的文件/文件的路径，创建文件
* 3.把FileWriter文件字符输出流对象指向创建好的文件- 5.字符输出流的使用步骤(重点)
- 1.创建FileWriter文件字符输出流对象，构造方法中绑定要写入数据的目的地
- 2.使用FileWriter中的方法write，把数据写入到内存缓冲区(存在字符转化为字节过程),和字节输出流不同，字符输出流调用write方法是把数据写入内存缓冲区，未写入文件
- 3.使用FileWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
- 4.释放资源(会先把内存缓冲区中的数据刷新到文件中)
package Writer;
import java.io.FileWriter;
import java.io.IOException;
public class Demo01Writer {
public static void main(String[] args) throws IOException {
//1.创建FileWriter文件字符输出流对象，构造方法中绑定要写入数据的目的地
FileWriter fw = new FileWriter("IO流\\f.txt");
//2.使用FileWriter中的方法write，把数据写入到内存缓冲区(存在字符转化为字节过程)
// 和字节输出流不同，字符输出流调用write方法是把数据写入内存缓冲区，未写入文件
//void write(int c):写入单个字符
fw.write(97);//此时并没有创建f.txt文件，也没有数据到文件
//3.使用FileWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
//fw.flush();
//4.释放资源(会先把内存缓冲区中的数据刷新到文件中),close功能包含了flush
fw.close();
}
}4.3.2.关闭和刷新的区别(close/flush)
- -flush:刷新内存缓冲区，将数据写入文件，流对象可以继续使用
- -close:先刷新缓冲区，将数据写入文件,然后通知系统释放资源，流对象不可以再被使用了。
package Writer;
import java.io.FileWriter;
import java.io.IOException;
/**
* flush方法和close方法的区别:
* -flush:刷新内存缓冲区，将数据写入文件，流对象可以继续使用
* -close:先刷新缓冲区，然后通知系统释放资源，流对象不可以再被使用了。
*/
public class Demo02Writer {
public static void main(String[] args) throws IOException {
//1.创建FileWriter文件字符输出流对象，构造方法绑定要写入数据的目的地
FileWriter fw = new FileWriter("IO流\\g.txt");
//2.使用FileWriter中的write，把字符数据写入到内存缓冲区(字符转换为字节过程)
//void write(int c):写入单个字符
fw.write(97); //向内存缓冲区写入字符a
//3.使用flush方法把内存缓冲区中的数据，刷新到文件中
fw.flush();
//刷新之后，流可以继续使用
fw.write(98);//向内存缓冲区写入字符b
//4.释放资源(会先刷新内存缓冲区中数据到文件),流已关闭，不能再使用
fw.close();//这样g.txt文件中的数据是ab
}
}
4.3.3.字符输出流写数据其它方法
* 字符输出流写数据的其它方法:
* -void write(char[] cbuf):写入字符数组
* -abstract void write(char[] cbuf,int off,int len):写入字符数组的一部分
* -void write(String str):写入字符串
* -void write(String str,int off,int len):写入字符串的一部分package Writer;
import java.io.FileWriter;
import java.io.IOException;
public class Demo03Writer {
public static void main(String[] args) throws IOException {
//1.创建FileWriter文件字符输出流对象
FileWriter fw = new FileWriter("IO流\\h.txt");
//2.调用FileWriter的write(char[] cbuf)方法写入字符数组到内存缓冲区
char[] cs={'a','b','c','d','e'};
fw.write(cs);//abcde
//-abstract void write(char[] cbuf,int off,int len):写入字符数组的一部分
fw.write(cs,0,2);//ab
//-void write(String str):写入字符串
fw.write("你好");
//-void write(String str,int off,int len):写入字符串的一部分
fw.write("今天天气不错",0,2);//今天
//4.释放资源
fw.close();
//上述向h.txt文件中写入的数据是 abcdeab你好今天
}
}
4.3.4字符输出流的续写和换行
- 续写,追加写:使用两个参数的FileWriter构造方法
* FileWriter(String fileName,boolean append)
* FileWirter(File file,boolean append)- 参数:
- String fileName,File file:写入数据的目的地
- boolean append:续写开关，
- true:不会创建新的文件覆盖源文件，可续写
- false:创建新的文件覆盖源文件
- 续写是指对同一个程序运行多次，只会创建一个文件，并在该文件中续写，而不是每执行一次程序就创建一个新文件覆盖。
- 换行:换行符号
- windows:\r\n
- linux:/n
- mac:/r
package Writer;
import java.io.FileWriter;
import java.io.IOException;
public class Demo04Writer {
public static void main(String[] args) throws IOException {
//1.创建文件字符输出流,可续写
FileWriter fw = new FileWriter("IO流\\j.txt",true);
//2.for循环写入字符串到内存缓冲区并换行，且可以续写
for (int i=0;i<3;i++){
fw.write("你好"+i+"\r\n");
}
//3.释放资源，先刷新缓冲区数据到文件
fw.close();
}
}
4.3.5.JDK7前处理流中异常
* 在jdk1.7之前使用try catch finally处理流中的异常,比较麻烦，后面会有简便的方法
* 格式:
* try{
* 可能产生异常的代码
* }catch(异常类变量 变量名){
* 异常的处理逻辑
* }finally{
* 一定会执行的代码(不管有无异常)
* 释放资源
* }
package Writer;
import java.io.FileWriter;
import java.io.IOException;
public class Demo05Writer {
public static void main(String[] args) {
//提高变量(流对象)作用域，让finally中可以调用，不然fw只能在try中使用
//另外，变量在定义的时候，可以没有值，但是使用时必须有值
//若try中异常导致没有创建流对象给fw,fw就没有值，fw.close会报错因此定义fw时赋值为null
FileWriter fw=null;
try {
//1.创建文件字符输出流FileWriter对象，设置可续写
fw = new FileWriter("IO流\\k.txt",true);
//2.for循环向内存缓冲区写入数据
for (int i=0;i<3;i++){
fw.write("你好"+i+"\r\n");
}
}catch(IOException e){
System.out.println(e);
}finally {
//3.释放资源,close方法声明会抛出IOException异常对象，需要处理异常。
//注意，若try中路径错误，创建流对象失败，那么fw值为null,是不能调用方法，
//会抛出NullPointerException空指针异常，需要先判断fw非空再释放资源
if (fw!=null){
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}4.3.6.JDK7中处理流中异常
* JDK7处理异常新特性:
* 在try的后面可以添加一个()，在括号中可以定义流对象，
* 那么这个流对象作用域就在try中有效
* try中的代码执行完毕，会自动把流对象释放，不再写finally来释放资源close,
* 格式:
* try(定义流对象;定义流对象...){
* 可能会产生异常的代码
* }catch(异常类变量 变量名){
* 异常处理逻辑
* }package Writer;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo06Writer {
public static void main(String[] args) {
try(//1.创建一个字节输入流对象，构造方法绑定要读取的数据源
FileInputStream fis = new FileInputStream("IO流\\a.txt");
//2.创建一个字节输出流对象，构造方法绑定要写入的目的地
FileOutputStream fos = new FileOutputStream("IO流\\m.txt");
){
//复制文件a.txt到m.txt，采用一次读取一个字节写入一个字节方法
//3.使用字节输入流中read方法读取文件
int len=0;//记录获取的单个字节
while((len=fis.read())!=-1){
//4.使用字节输出流中write，把读取到的字节写入目的地文件中
fos.write(len);
}
}catch (IOException e){
System.out.println(e);
}
}
}4.3.7.JDK9中处理流中异常
* JDK9处理流中异常新特性:
本电脑使用的是JDK8，所以下面方法是无法执行的，但要知道try的前边可以定义流对象，
* 在try后边的()中可以直接引入流对象的名称(变量名)
* 在try代码执行完毕之后，流对象也可释放，不再需要finally中来释放
* 格式:
* A a=new A();
* B b=new B();
* try(a,b){
* 产生异常的代码
* }catch(异常类变量 变量名){
* 异常的处理逻辑
package Writer;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo07Writer {
public static void main(String[] args) throws FileNotFoundException {
//1.创建一个字节输入流对象，构造方法绑定要读取的数据源
FileInputStream fis = new FileInputStream("IO流\\a.txt");
//2.创建一个字节输出流对象，构造方法绑定要写入的目的地
FileOutputStream fos = new FileOutputStream("IO流\\n.txt");
try(fis;fos){
int len=0;//记录读取的单个字节
while((len=fis.read())!=-1){
//调用write方法，将获取的单个字节len写入文件n.txt中
fos.write(len);
}
}catch (IOException e){
System.out.println(e);
}
}
}4.4.Properties集合
4.4.1.Properties能做什么
- 1.java.util.Properties集合 extends Hashtable<k,v> implement Map<k,v>
- 2.Properties类表示了一个持久的属性类，Properties可保存在流中或从流中加载
- 3.Properties集合是一个唯一和IO流相结合的集合
- 可以使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储，
- 可以使用Properties集合中的方法load,把硬盘中保存的文件(键值对)读取到集合中使用
- store和load方法分别各自对应字节流和字符流，一般都是使用字符流，不然会出现乱码。
- 4.属性列表中每个键及其对应值都是一个字符串
- Properties集合是一个双列集合，Key和value默认都是字符串
4.4.2.Properties存储、遍历数据方法
*Properties集合有一些操作字符串的特有方法:
Object setProperty(String key,String value):向集合添加数据，底层调用hashtable的put方法
String getProperty(String key):通过key找到value,相当于map集合中get(key)
Set<String>stringPropertyNames():返回此属性列表中的键值，其中该键及其对应值是字符串4.4.3.Properties序列化和反序列化
- 使用Properties集合中的方法load，把硬盘中保存的文件(键值对)，读取到集合中使用
load(InputStream inStream)
load(Reader reader)
参数:
InputStream inStream:字节输入流对象，不能读取含有中文的键值对
Reader reader:字符输入流对象，能读取含有中文的键值对- 使用步骤:
- 1.创建Properties集合对象
- 2.使用Properties集合对象中的方法load读取保存键值对的文件
- 3.遍历集合Properties
- 注意:
- 1.存储键值对的文件中，键与值默认的连接符号可以使用空格(其它符号)
- 2.存储键值对的文件中，在键值对前使用#注释，被注释的键值对不会再被读取
- 3.存储键值对的文件中，键与值默认都是字符串，不用再加引号
package Demo6Properties;
import java.io.*;
import java.util.Properties;
import java.util.Set;
public class Demo01Properties {
public static void main(String[] args) throws IOException {
//show01();
//show02();
show03();
}
public static void show01(){
//1.创建Properties集合对象
Properties prop = new Properties();
//2.使用setProperty()往集合中添加数据
prop.setProperty("焰灵姬","22");
prop.setProperty("韩非","23");
prop.setProperty("卫庄","24");
//3.取出Properties集合中的键存储到set集合中，使用stringPropertyNames()方法
Set<String> set = prop.stringPropertyNames();
//4.遍历set集合，取出Properties集合每一个键
for (String key:set){
//5.使用getProperty(key)方法通过key获取value
String value = prop.getProperty(key);
System.out.println(key+"="+value);
}
}
public static void show02() throws IOException {
//1.创建Properties集合对象
Properties prop = new Properties();
// 使用setProperty()往集合中添加数据
prop.setProperty("焰灵姬","22");
prop.setProperty("韩非","23");
prop.setProperty("卫庄","24");
//2.创建字节输出流/字符输出流对象，构造方法绑定要输出的目的地
FileWriter fw = new FileWriter("IO流\\o.txt");
//3.使用Properties集合中的方法store，把集合中数据，持久化写入硬盘中存储
prop.store(fw,"sava data");
/*当Properties集合中有中文，就不能使用下面的字节输出流，否则持久化的文件是乱码
* prop.store(new FileOutputStream("IO流\\o.txt"),"sava data");
* */
//4.释放资源，关闭流
fw.close();
}
public static void show03() throws IOException {
//1.创建Properties集合对象
Properties prop = new Properties();
//2.集合调用Load方法读取保存键值对的文件
prop.load(new FileReader("IO流\\o.txt"));
//3.遍历Properties集合
//先获取集合中的键存储到set集合，使用stringPropertyNames()方法
Set<String> set = prop.stringPropertyNames();
//遍历set集合，根据键获取值
for (String key:set){
String value = prop.getProperty(key);
System.out.println(key+"="+value);
}
}
}
- 以上学习了基本的流(字节字符输出输入流)，作为IO流入门，今天我们要见识一下更强大的流。
- 比如能够高效读写的缓冲流，能转换编码的转换流，能持久化存储对象的序列化流等等，
- 这些功能更为强大的流，都是在基本的流对象基础上创建而来，就像穿上铠甲的武士一样，相当于是对基本流对象的一种增强。
5.BufferedStream缓冲流
5.1.缓冲流原理
- 1.比如使用基本的字节输入流读取文件a.txt中的abcde数据，需要经过java程序调用jvm,jvm调用os,os调用系统方法一个个字节读取，每读取一个字节都要原路返回到java程序，效率非常低。
- 2.而字节缓冲输入流，即给基本的字节输入流增加一个缓冲区(数组)，来提高字节输入流读取效率，读取的路径还是从java程序-jvm-os-os系统方法把数据都读取到缓冲区，把缓冲区一次性返回。
- 3.缓冲流基本原理:
- 是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。
5.2.BufferedOutputStream使用
字节缓冲输出流的使用
1.缓冲流--字节缓冲输出流
java.io.BufferedOutputStream extends OutputStream (继承字节输出流)
BufferedOutputStream:字节缓冲输出流2.该类继承自父类(字节输出流)的共性成员方法：
-public void close():关闭此输出流并释放与此流相关联的任何系统资源
-public void flush():刷新此输出流并强制任何缓冲的输出字节被写出。
-public void write(byte[] b):将b.length字节从指定的字节数组写入此输出流
-public void write(byte[] b,int off,int len):
从指定字节数组中写入len个字节(到内存)，从偏移量off开始输出到此输出流。
-public abstract void write(int b):将指定的(一个)字节输出流3.构造方法:
BufferedOutputStream(OutputStream out):创建一个新的缓冲输出流，以将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out,int size):创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入底层输出流
参数:
- OutputStream out:字节输出流
- 传递FileOutputStream文件字节输出流对象，缓冲流会给FileOutputStream这个底层(基本)输出流增加一个缓冲区，提高FileOutputStream流写入效率。
- int size:指定缓冲流内部缓冲区的大小，不指定则默认。
4.字节缓冲输出流使用步骤(重点):
- 1.创建FileOutputStream文件字节输出流对象，构造方法绑定要输出的目的地
- 2.创建BufferedOutputStream字节缓冲输出流，构造方法绑定FileOutputStream对象，提高FileOutputStream流写入效率。
- 3.使用BufferedOutputStream对象中的write，把数据写入缓冲流内部缓冲区中
- 4.使用BufferedOutputStream对象中的flush，把缓冲区中数据，刷新到文件中
- 5.释放资源(会先调用flush方法刷新数据，第4步可以省略)
package Demo7BufferedStream;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo01BufferedOutputStream {
public static void main(String[] args) throws IOException {
//1.创建FileOutputStream文件字节输出流对象，构造方法绑定要输出的目的地
FileOutputStream fos = new FileOutputStream("IO流\\p.txt");
//2.创建BufferedOutputStream字节缓冲输出流，构造方法绑定FileOutputStream对象，
// 提高FileOutputStream流写入效率。
BufferedOutputStream bos = new BufferedOutputStream(fos);
//3.使用BufferedOutputStream对象中的write，把数据写入缓冲流内部缓冲区中
bos.write("把数据写到缓冲流内部缓冲区中".getBytes());//字符串转化为字节
//4.释放资源(会先调用flush方法刷新数据，第4步可以省略)
bos.close();
}
}
5.3.BufferedInputStream使用
字节缓冲输入流使用
1.缓冲流--字节缓冲输入流
* java.io.BufferedInputStream extends InputStream (继承自字节输入流)
* BufferedInputStream:字节缓冲输入流2.该类继承自父类(InputStream)的成员方法:
* int read():从输入流中读取一个字节数据
* int read(byte[] b):从输入流中读取一定数量的字节，并将其保存到缓冲区数组b中
* void close():关闭此输入流，释放与该流关联的所有系统资源3.构造方法:
BufferedInputStream(InputStream in):创建字节缓冲输入流对象
BufferedInputStream(InputStream in,int size):创建具有指定缓冲区大小的字节缓冲输入流对象，参数:
- InputStream in:字节输入流对象
- 我们可以传递FileInputStream文件字节输入流，缓冲流会给FileInputStream增加一个缓冲区，提高FileInputStream的读取效率。
- int size:指定缓冲流内部缓冲区的大小，不指定默认
4.BufferedInputStream流使用步骤(重点):
- 1.创建FileInputStream(基本输入流)对象,构造方法中绑定要读取的数据源
- 2.创建BufferedInputStream(字节缓冲输入流)对象，构造方法传递FileInputStream对象让缓冲流给FileInputStream(基本流)添加缓冲区，提供FileInputStream读取效率
- 3.使用BufferedInputStream对象中read方法读取文件
- 4.释放资源
package Demo7BufferedStream;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class Demo02BufferedInputStream {
public static void main(String[] args) throws IOException {
//1.创建FileInputStream(基本输入流)对象,构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("IO流\\a.txt");
//2.创建BufferedInputStream(字节缓冲输入流)对象，构造方法传递FileInputStream对象
// 让缓冲流给FileInputStream(基本流)添加缓冲区，提供FileInputStream读取效率
BufferedInputStream bis = new BufferedInputStream(fis);
/*3.1使用BufferedInputStream对象中read方法读取文件
//int read():从输入流中读取一个字节
int len=0;//记录读取的字节
while((len=bis.read())!=-1){
System.out.println((char) len);
}
*/
//3.2 int read(byte[] b):从输入流中读取一定数量的字节，并将其保存到缓冲区数组b中
byte[] bytes=new byte[1024];//存储每次读取的数据的字节数组(作为缓冲区)
int len=0;//记录读取的有效字节数
while((len=bis.read(bytes))!=-1){
System.out.println(new String(bytes,0,len));//将字节数组转化为字符
}
//4.释放资源
bis.close();
}
}5.4.缓冲流效率测试--文件复制
文件复制练习:一读一写
明确:
- 数据源:IO流\\a.txt
- 数据的目的地:IO流\\d.txt
文件复制的步骤:
* 1.创建一个字节输入流对象，构造方法绑定要读取的数据源
* 2.创建一个字节输出流对象，构造方法中绑定要写入的目的地
* 3.使用字节输入流对象中的read方法读取文件
* 4.使用字节输出流对象中的write方法把读取到的字节写入到目的地文件中
* 5.释放资源(先释放输出流对象，若写完了，肯定读完了)比较:
- a.txt文件大小占3字节，内容abc,采用字节流复制到d.txt文件的两种方式比较:
- 1.使用一次读写一个字节复制文件:3毫秒
- 2.使用数组缓冲读写多个字节:1毫秒
package Demo7BufferedStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo03CopyFile {
public static void main(String[] args) throws IOException {
long s = System.currentTimeMillis();
//1.创建一个字节输入流对象，构造方法绑定要读取的数据源
FileInputStream fis = new FileInputStream("IO流\\a.txt");
//2.创建一个字节输出流对象，构造方法中绑定要写入的目的地
FileOutputStream fos = new FileOutputStream("IO流\\d.txt");
/**1.
* 一次读取一个字节写入一个字节的方式：
* int read():从输入流中获取数据的下一个字节,读取到文件的末尾则返回-1
* 下面将a.txt中的abc读取并复制到d.txt中，只有三个字节需要循环三次
* 缺点:有多少字节就要循环多少次，若是上千字节的图片就要循环千遍。
*/
// 3.使用字节输入流对象中的read方法读取文件
int len=0;//记录获取的字节，若获取空则返回-1
while((len=fis.read())!=-1){
//4.使用字节输出流对象中的write方法把读取到的字节写入到目的地文件中
fos.write(len);
}
/**2.
* 下面使用一次读取多个字节并写入多个字节的方法:
* int read(byte[] b):输入流中读取一定数量的字节，并将其存储到缓冲区的数组b中
* 使用数组缓冲读取多个字节，写入多个字节
*/
byte[] bytes=new byte[1024];//创建缓冲字节数组，存储1024字节
int len=0;//这里的len记录着读取的有效字节数
//3.使用字节输入流对象中的read方法读取文件
/*while((len=fis.read(bytes))!=-1){
//4.使用字节输出流对象中的write方法把读取到的字节写入到目的地文件中
fos.write(bytes,0,len);
}*/
//5.释放资源(先释放输出流对象，若写完了，肯定读完了)
fos.close();
fis.close();
long e = System.currentTimeMillis();
System.out.println("复制文件共耗时:"+(e-s)+"毫秒");
}
}
文件复制步骤(使用字节缓冲流)
1.创建字节缓冲输入流对象，构造方法中传递字节输入流
2.创建字节缓冲输出流对象，构造方法中传递字节输出流
3.使用字节缓冲输入流对象的read方法，读取文件
4.使用字节缓冲输出流对象的write方法，把读取的数据写入缓冲流内部缓冲区中
5.释放资源(会先把缓冲区中数据，刷新到文件中)package Demo7BufferedStream;
import java.io.*;
public class Demo03CopyFile_BufferedStream {
public static void main(String[] args) throws IOException {
long s = System.currentTimeMillis();//获取当前时间
//1.创建字节缓冲输入流对象，构造方法中传递字节输入流(可匿名对象)
BufferedInputStream bis=
new BufferedInputStream(new FileInputStream("IO流\\a.txt"));
//2创建字节缓冲输出流对象，构造方法中传递基本的字节输出流
BufferedOutputStream bos =
new BufferedOutputStream(new FileOutputStream("d.txt"));
/*3.1使用字节缓冲输入流对象的read方法，读取文件
// 一次读写一个字节的方式
int len=0;//记录读取的字节
while((len=bis.read())!=-1){
//读取一个字节，就写入一个字节
bos.write(len);
}
*/
//3.2.使用字节缓冲流对象中的read方法，读取文件
// 在缓冲流下，采用数组缓冲读写多个字节
byte[] bytes=new byte[1024];//定义缓存数组，存储读取的数据
int len=0;//记录读取到的有效字节数
while((len=bis.read(bytes))!=-1){
//每次将读取到缓存数组中的数据写入文件
bos.write(bytes,0,len);
}
//5.释放资源(先释放输出流对象，若写完了，肯定读完了)
bos.close();
bis.close();
long e = System.currentTimeMillis();
System.out.println("复制文件共耗时:"+(e-s)+"毫秒");
}
}5.5.BufferedWriter使用
1.缓冲流--字符缓冲输出流BufferedWriter
1.java.io.BufferedWriter extends Writer (Writer继承类，增强版)
BufferedWriter:字符缓冲输出流2.该类继承自父类(字符输出流Writer)的共性成员方法:
* -void write(int c):写入单个字符
* -void write(char[] cbuf):写入字符数组
* -abstract void write(char[] cbuf,int off,int len):写入字符数组的一部分
* -void write(String str):写入字符串
* -void write(String str,int off,int len):写入字符串的一部分
* -void flush():刷新该流的缓冲
* -void close():关闭此流，但要先刷新它3.构造方法：
* BufferedWriter(Writer out):创建一个使用默认大小缓冲区的缓冲字符输出流
* BufferedWriter(Writer out,int size):创建一个使用给定大小输出缓冲区的缓冲字符输出流参数:
- Writer out:(基本)字符输出流
- 我们可以传递FileWriter字符输出流，缓冲流会给FileWriter增加一个缓冲区，提高FileWriter的写入效率
- int size:指定缓冲区的大小，不写则默认
4.字符缓冲输出流特有的成员方法：
- void newLine():写入一个行分隔符，会根据不同的操作系统，获取不同的行分隔符
- 换行:换行符号
- windows:/r/n
- linux:\n
- mac:/r
5.字符缓冲输出流使用步骤:
* 1.创建字符缓冲输出流对象，构造方法中传递字符输出流
* 2.调用字符缓冲输出流中write方法，把数据写入到内存缓冲区中
* 3.调用字符缓冲输出流中flush方法，把内存缓冲区的数据，刷新到文件中
* 4.释放资源package Demo7BufferedStream;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class Demo04BufferedWriter {
public static void main(String[] args) throws IOException {
//1.创建字符缓冲输出流对象，构造方法传递字符输出流(可以匿名对象)参数
//当前项目名称是java,使用相对路径在当前项目下的IO流模块中创建文件
BufferedWriter bw = new BufferedWriter(new FileWriter("IO流\\p.txt"));
//2.调用字符缓冲输出流中write方法，把数据写入到内存缓冲区
// 使用write(String str)写入字符串
for (int i=0;i<3;i++){
bw.write("你好");
//每写入一个字符串就换行,使用bw.newLine()也可以
bw.write("\r\n");
}
//3.调用字符缓冲输出流中flush方法，把内存缓冲区中数据，刷新到文件中
bw.flush();
//4.释放资源
bw.close();
}
}
5.6.BufferefReader使用
1.缓冲流--字符缓冲输入流BufferedReader
* java.io.BufferedReader extends Reader (继承Reader)
* BufferedReader:字符缓冲输入流2.该类继承父类(Reader字符输入流)的共性成员方法：
-int read():读取单个字符并返回
-int read(char[] cbuf):一次读取多个字符，将字符读入数组
-void close():关闭该流，并释放资源3.构造方法：
BufferedReader(Reader in):创建一个使用默认大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in,int size):创建一个使用指定大小输入缓冲区的..参数:
- Reader in:(基本)字符输入流
- 我们可以传递FileReader流,缓冲流会给FileReader增加一个缓冲区，提高FileReader的去效率。
4.字符缓冲输入流特有的方法:
- String readLine():读取一个文本行，读取一行数据
- 行的终止符:通过下列字符之一即可认为某行已终止:换行('\n')，回车(\r)或回车后直接跟着换行(\r\n)
- 返回值:包含该行内容的字符串，不包含任何终止符，如果已到达流末尾，则返回null
5.字符缓冲输入流使用步骤
1.创建字符缓冲输入流对象，构造方法中传递字符输入流
2.字符缓冲输入流对象中方法read/readLine读取文件
3.释放资源package Demo7BufferedStream;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class Demo05BufferedReader {
public static void main(String[] args) throws IOException {
//1.创建字符缓冲输入流对象，构造方法中传递字符输入流
BufferedReader br = new BufferedReader(new FileReader("IO流\\k.txt"));
//2.调用readLine一行行读取文件数据，使用while循环，结束条件line==null
String line;//记录读取某行的数据
while((line=br.readLine())!=null){
System.out.println(line);
}
//3.释放资源
br.close();
}
}
5.7.练习-对文本内容排序
缓冲流练习:
- 对文本的内容进行排序，按照(1,2,3...)顺序排序
* 3.焰灵姬。。。。。。。。
* 2.韩非。。。。。。。。。
* 4.紫女。。。。。。。。。
* 1.卫庄。。。。。。。。。分析:
- 1.创建一个HashMap集合对象， 键:存储每行文本的序号(1,2,3..);value:存储每行文本
- 2.创建字符缓冲输入流对象，构造方法绑定字符输入流。(先读取文件)
- 3.创建字符缓冲输出流对象，构造方法中绑定字符输出流。(排序后再写回去)
- 4.使用字符缓冲输入流中readLine方法，逐行读取文本
- 5.对读取到的文本进行切割split，获取行中的序号和文本内容
- 6.把切割好的序号和文本的内容存储到HashMap集合中(key序号是有序的，会自动排序)
- 7.遍历HashMap集合，获取每一个键值对
- 8.把每一个键值对，拼接为一个文本行
- 9.把拼接好的文本，使用字符缓冲输出流中的write方法，写入文件中
- 10.释放资源
package Demo7BufferedStream;
import java.io.*;
import java.util.HashMap;
public class Demo06ContentSort {
public static void main(String[] args) throws IOException {
//1.创建一个HashMap集合对象，
// 键:存储每行文本的序号(1,2,3..);value:存储每行文本
HashMap<String,String> map=new HashMap<>();
//2.创建字符缓冲输入流对象，构造方法绑定字符输入流。
BufferedReader br = new BufferedReader(new FileReader("IO流\\in.txt"));
//3.创建字符缓冲输出流对象，构造方法中绑定字符输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("IO流\\out.txt"));
//4.使用字符缓冲输入流中readLine方法，逐行读取文本
String line;//存储每行文本
while((line=br.readLine())!=null){
//5.对读取到的文本以点.进行切割，获取行中的序号和文本内容存入数组中
String[] arr = line.split("\\.");//转义字符
// 6.把切割好的序号和文本的内容存储到HashMap集合中(key序号是有序的，会自动排序)
map.put(arr[0],arr[1]);
}
//7.遍历HashMap集合，获取每一个键值对
for (String key:map.keySet()){
String value = map.get(key);
//8.把每一个键值对，拼接为一个文本行
line=key+"."+value;
//9.把拼接好的文本，使用字符缓冲输出流中的write方法，写入文件中
bw.write(line);
bw.newLine();//写换行
}
//10.释放资源
bw.close();
br.close();
}
}
6.转换流ReverseStream
6.1.字符编码
- 计算机中存储的信息都是用二进制数表示的，而我们在屏幕上看到的数字，英文，标点符号，汉字等字符都是二进制数转换之后的结果。
- 按照某种规则，将字符存储到计算机中，称为编码。
- 反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号，反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。
- 编码:字符(能看懂的)-->字节(看不懂的) ，即将字符编码以字节(二进制)方式存入计算机中
- 解码:字节(看不懂的)-->字符(看的懂)，即将计算机中的二进制解码为可以看懂的字符
- 字符编码(Character Encoding):就是一套自然语言的字符与二进制数之间的对应规则.
- 编码表:生活中文字和计算机中二进制的对应规则
6.2.字符集
- 1.字符集(Charset):也叫编码表，是一个系统支持的所有字符的集合，包各国文字，标点符号，图形符号，数字等
- 2.计算机要准确的存储和识别各种字符集符号，需要进行字符编码(即将各种字符以二进制表示)，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集，GBK字符集，Unicode字符集等。当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们最终要关心的。
6.3.编码引出的问题
- FileReader文件字符输入流可以读取IDEA默认编码格式(utf-8)的文件
- FileReader读取系统默认编码(中文GBK)会产生乱码
- 同理FileWriter也是。
- FileReader基本输入流和FileWriter基本输出流的各自的一个父类都是转换流，用来处理由于编码问题产生的乱码，即InputStreamReader和OutputStreamWriter转换流。
- 下面在IO流项目下创建一个"我是GBK格式文本.txt"文本，并在文件中写入"你好"，然后文本另存为时修改编码格式为ANSI，即系统默认编码格式GBK,
- 而IDEA默认编码格式为utf-8,下面使用IDEA编程读取这个GBK文本，会出现乱码,FileReader也会出现乱码，看下面代码
package Demo8ReverseStream;
import java.io.FileReader;
import java.io.IOException;
public class Demo01ReverseStream {
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("IO流\\我是GBK格式文本.txt");
int len=0;//记录获取的一个字符
while((len=fr.read())!=-1){
System.out.print((char)len);//输出乱码���，真实字符""你好
}
fr.close();
}
}
6.4.转换流原理
1.先看FileInputStream流:
- 实际上FileReader只做一件事，一件转换的事，它可以把字节通过查询utf-8编码表转化为字符，硬盘存储的文件都是以字节形式存储的，
- 那么FileReader流如何读取字节呢？通过FileReader底层源码可知，FileReader构造方法中new了一个FileInputStream文件字节输入流对象，即FileReader字符流底层就是用FileInputStream这个字节流来读字节，然后再通过FileReader把字节转换为我们能看懂的字符。
2.再看InputStreamReader转换流:
- InputStreamReader类是FileReader类的父类，InputStreamReader是字节流通向字符流的桥梁，可以把字节转换为字符，它可以使用指定的charset(字符集/编码表)读取字节(计算机中都是以字节存储的)并将其转换为字符，即这个流可以指定编码表，而其子类FileReader这个流只能使用默认编码表(utf-8)
3.转换流原理:
- GBK中文编码表，使用两个字节存储一个中文，比如"你好"--> -55-44,-33,-34
- UTF-8国际标准编码表，使用是三个字节存储一个中文，比如"你好"-->-11-12-23，-19-56-78
- 在1.txt文本中使用GBK编码存储"你好"需要4个字节，使用utf-8编码格式存储"你好"需要6个字节，
- 当使用文件输入流FileReader读取1.txt文本中utf-8编码格式存储的"你好"即-11-12-23，-19-56-78这6个字节，
- 首先是字节输入流FileInputStream来读取文本中的6个字节，然后使用FileReader字符输入流查询IDEA默认编码表utf-8来把字节转换为字符(即解码)即转化为"你好"读取到内存(或说java程序中)。
- 但若是使用FileReader流来读取1.txt文件中GBK编码格式存储的"你好"即-55-44,-33,-34这4个字节，解码后就是乱码了，因为FileReader流只能查询IDEA默认编码表(utf-8)来解码，若是查询数据是GBK编码，就会出现乱码。
- 当使用InputStreamReader转换流来读取1.txt文本中utf-8编码格式下存储的"你好"时，首先会使用字节输入流(InputStreamReader底层)FileInputStream来读取这6个字节，然后再使用InputStreamReader这个转换流。它是字节流通向字符流的桥梁，不同于FileReader的是，InputStreamReader流可以查询指定的编码表，从而不会产生乱码。
- 当java程序向硬盘文件写入数据时，使用FileWriter流，该基本流会查询IDE默认编码表utf-8，把字符变为字节即编码，然后使用FilWriter的底层代码即字节输出流FileOutputStream来将转化来字节输出到文件中，因此文件中存储的是6个字节-11-12-23，-19-56-78；如果向文件写入GBK编码的字符，FileWriter流是写不了的，它只能写入IDE默认的编码表(utf-8)，因此只能使用转换流OutputStreamWriter转换流实现。
- 当java程序向硬盘文件写入数据时，可以使用OutputStreamWriter转换流，该流不仅可以查询IDE默认的编码表utf-8也可以根据数据的编码格式来指定编码表查询，来实现将字符转换为字节(即编码)，转换后，使用该OutputStreamWriter转换流的底层代码字节输出流FileOutputStream来将字节写入文件中。
6.5.OutputStreamWriter转换流使用
OutputStreamWriter (字符输出转换流)
1.java.io.OutputStreamWriter extends Writer (Writer子类，FileWriter父类)
OutputStreamWriter:是字符流通向字节流的桥梁，可使用指定的charset(字符集/编码表)2.该转换流继承自父类(writer)的共性成员方法:
-void write(int c):写入单个字符
-void write(char[] cbuf):写入字符数组
-abstract void write(char[] cbuf,int off,int len):写入字符数组的一部分
-void write(String str):写入字符串
-void write(String str,int off,int len):写入字符串的一部分
-void flush():刷新该流的缓冲
-void close():关闭此流，但要先刷新它3.构造方法
OutputStreamWriter(OutputStream out):创建使用默认字符编码(utf-8)的OutputStreamWriter转换流
OutputStreamWriter(OutputStream out,String charsetName):创建使用指定字符集的OutputStreamWriter转换流对象
参数:
OutputStream out:(基本)字节输出流，用来写转换之后的字节到文件中
String charsetName:指定的编码表名称，不区分大小写，不指定则默认uft-8/UTF-84.转换流使用步骤:
1.创建OutputStreamWriter对象，构造方法中传递字节输出流和指定的编码表名称
2.使用OutputStreamWriter对象中方法write，把字符转换为字节存储在缓冲区(编码)
3.使用OutputStreamWriter对象中方法flush,把内存缓冲区中字节刷新到文件中(使用字节流写字节过程)
4.释放资源package Demo8ReverseStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class Demo02ReverseStream {
public static void main(String[] args) throws IOException {
//write_utf_8();
write_gbk();
}
/**
* 使用转换流OutputStreamWriter写UTF-8编码格式(默认的)的字符到utf-8.txt文件中
*/
public static void write_utf_8() throws IOException {
//1.创建OutputStreamWriter对象，构造方法传递字节输出流和指定编码表(默认编码表可省略)
OutputStreamWriter osw = new OutputStreamWriter(
new FileOutputStream("IO流\\utf-8.txt"),"utf-8");
//2.使用OutputStreamWriter对象中方法write，把字符转换为字节存储在缓冲区(编码)
osw.write("你好");
//3.使用OutputStreamWriter对象中flush,把内存缓冲区字节刷新到文件(使用字节流写字节过程)
osw.flush();
//4.释放资源
osw.close();
}
/**
* 使用字符输出转换流OutputStreamWriter写GBK编码格式的数据到文件
*/
public static void write_gbk() throws IOException {
//1.创建字符输出转换流OutputStreamWriter对象，构造方法中传递字符输出流和编码表名称
OutputStreamWriter osw = new OutputStreamWriter(
new FileOutputStream("IO流\\gbk.txt"),"GBK");
//2.调用转换流对象中write方法，把字符转化为字节存储到缓冲区
osw.write("你好");
//3.使用缓冲流对象中flush，把缓冲区中的字节刷新到文件中(即使用字节输出流写字节过程)
osw.flush();
//4.释放资源
osw.close();
/*
* 使用GBK编码格式写入文件，若是找到gbk.txt文件打开后是"你好"，
* 若直接在IDE中打开gbk.txt，是按照IDE默认的编码uft-8展示出来的是乱码
* */
}
}
6.6.InputStreamReader使用
InputStreamReader (字符输入转换流)
1.java.io.InputStreamReader extends Reader (是FileReader父类，Reader子类)
InputStreamReader:是字节流通向字符流的桥梁，它使用指定的charset(字符集/编码表)读取字节并将其
解码为字符(解码:字节-->字符)2.该转换流继承自父类(Reader)的共性成员方法:
int read():读取单个字符并返回
int read(char[] cbuf):一次读取多个字符，并将字符读入数组
void close()关闭流，并释放相关资源3.构造方法:
InputStreamReader(FileInputStream in):创建一个使用默认字符集的InputStreamReader缓冲流对象
InputStreamReader(FileInputStream in,String charsetName):
创建使用指定字符集的InputStreamReader对象
参数:
FileInputStream in:字节输入流，读取文件中字节，再由InputStreamReader流通过编码表转换为字符
String charsetName:指定编码表名称，不区分大小写，不指定则默认为uft-84.InputStreamReader使用步骤：
* 1.创建InputStreamReader转换流对象，构造方法中传递字节输入流(读取字节)和指定编码表
* 2.使用inputStreamReader对象中read读取文件
* 3.释放资源5.注意事项
- 构造方法中指定的编码表名称要和读取的文件的编码相同，否则会发生乱码
package Demo8ReverseStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class Demo03ReverseStream {
public static void main(String[] args) throws IOException {
//read_utf_8();
read_gbk();
}
/**
* 使用InputStreamReader字符输入转换流读取uft-8编码格式的文件utf-8.txt
* 构造方法中可以不指定编码表，表示默认
*/
public static void read_utf_8() throws IOException {
//1.创建InputStreamReader转换流对象，构造方法中传递字节输入流(读取字节)和指定编码表
InputStreamReader isr = new InputStreamReader(
new FileInputStream("IO流\\utf-8.txt"),"utf-8");
//2.使用inputStreamReader对象中read读取文件
// int read():一个字符一个字符的读取
int len=0;//记录获取的的单个字符
while((len=isr.read())!=-1){
System.out.print((char)len);//输出 你好
}
//3.释放资源
isr.close();
}
/**
* 使用InputStreamReader读取GBK编码格式的文件gbk.txt,
* 构造方法中必须指定编码表为GBK,否则乱码，因为IDE默认编码utf-8
*/
public static void read_gbk() throws IOException {
InputStreamReader isr=new InputStreamReader(
new FileInputStream("IO流\\gbk.txt"),"GBK");
int len=0;
while((len=isr.read())!=-1){
System.out.println((char)len); 输出 你好,若指定utf-8中乱码
}
isr.close();
}
}
6.7.练习-转换文件编码
将GBK编码格式的文件，转换为utf-8编码的文本文件
分析:
- 指定GBK编码的字符输入转换流，读取文本文件
- 使用UTF-8编码的字符输出缓冲流，写入文本文件
步骤:
1.创建InputStreamReader对象，构造方法中传递字节输入流和指定编码名称GBK
2.创建OutputStreamWriter对象，构造方法中传递字节输出流和指定编码名称utf-8
3.使用InputStreamReader对象中read方法读取文件
4.使用OutputStreamWriter对象中write方法把读取数据写入到文件
5.释放资源package Demo8ReverseStream;
import java.io.*;
public class Demo04Test {
public static void main(String[] args) throws IOException {
//1.创建InputStreamReader对象，构造方法中传递字节输入流和指定编码名称GBK
InputStreamReader isr = new InputStreamReader(
new FileInputStream("IO流\\我是GBK格式文本.txt"),"GBK");
//2.创建OutputStreamWriter对象，构造方法中传递字节输出流和指定编码名称utf-8
OutputStreamWriter osw = new OutputStreamWriter(
new FileOutputStream("IO流\\我是utf-8格式文本.txt"),"utf-8");
//3.使用InputStreamReader对象中read方法读取文件
// int read():一个个字符读取,返回该字符的十进制数
int len=0;
while((len=isr.read())!=-1){
//4.使用OutputStreamWriter对象中write方法把读取数据写入到文件
osw.write((char)len); //输出 你好
}
//5.释放资源
osw.close();
isr.close();
}
}
7.ObjectStream序列化流
7.1.序列化和反序列化概述
Person p=new Person("旺财",18);
对象序列化
- 把对象以流的方式，写入到文件中保存，叫写对象，也叫对象的序列化。
- 对象中包含的不仅是字符，还有字节，所以使用字节流，
对象序列化流
- ObjectOutputStream:现要将Person对象写入硬盘的person.txt文件中，使用对象的序列化流中writeObject(p)方法来写入对象到文件，并以字节形式存储到文件(看不懂)。
对象反序列化
- 当读取person.txt文件时，把文件中保存的对象，以流的方式读取出来，叫做读对象，也叫对象的反序列化，
- 读取的文件都是字节形式，使用字节流，
对象的反序列化流
- ObjectInputStream:对象的反序列化流
- 使用对象的反序列化流调用readObject()方法读取person.txt文件中对象到java程序中，读取的对象应该使用Object类型来接收，因为写对象时对象类型是明确的，但是读对象时对象不止一个，只能使用Object类型接收任意类型的对象。
- 序列化:就是把对象以流的方式写入文件中
- 反序列化:就是把对象以流的方式读取到java程序中
- 序列化流不仅可以文件上的对象传输，还可以网络上的对象传输
7.2.Serializable接口
要序列化和反序列化的类需要注意事项:该类必须实现Serializable序列化接口
- 1.序列化和反序列化的时候，会抛出NotSerializableException没有序列化异常
- 2.只有类实现java.io.Serializable序列化接口才可以启用序列化功能，未实现此接口的类将无法使用其任何状态序列化或反序列化
- 3.Serializable序列化接口也叫标记型接口:
- 要进行序列化和反序列化的类必须实现Serializable接口，就会给类添加一个标记,当我们进行序列化和反序列化时候，就会检测类上是否有这个标记，
- 有:就可以序列化和反序列化
- 没有:就会抛出NotSerializableException没有序列化异常
- 就像去买商品，只有商品上有合格证这个标记才可以购买。
- 4.标记型接口底层源码中方法体什么也没有为空。
7.3.ObjectOutputStream
对象的序列化流
1.java.io.ObjectOutputStream extends OutputStream
ObjectOutputStream:对象的序列化流,把对象写入文件中2.构造方法:
ObjectOutputStream(OutputStream out):
创建写入指定OutputStream字节输出流的ObjectSOutputStream对象序列化流
参数:
OutputStream out:字节输出流3.对象序列化流特有的成员方法:
void ObjectWrite(Object obj):将指定的对象写入ObjectOutputStream序列化流4.对象序列化流使用步骤:
1.创建ObjectOutputStream对象，构造方法中传递字节输出流
2.使用ObjectOutputStream对象中方法writeObject,把对象写入到文件
3.释放资源5.Demo
package ObjectStream;
import java.io.Serializable;
// 要序列化和反序列化的类需要注意事项:该类必须实现Serializable序列化接口，
public class Demo01Person implements Serializable { //该类实现序列化接口
private String name;
private int age;
public Demo01Person(String name, int age) {
this.name = name;
this.age = age;
}
public Demo01Person() { }
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 "Demo01Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package ObjectStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
public class Demo01ObjectOutputStream {
public static void main(String[] args) throws IOException {
//1.创建ObjectOutputStream序列化流对象，构造方法中传递字节输出流
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("IO流\\person.txt"));
//2.使用ObjectOutputStream对象中writeObject方法写入对象到文件
oos.writeObject(new Demo01Person("东方月初",18));
//3.释放资源
oos.close();
}
}
7.4.ObjectInputStream
对象反序列化流
1.java.io.ObjectInputStream extends InputStream (是字节输入流子类)
ObjectInputStream:对象反序列流
作用:把文件中保存的对象，以流的方式读取出来使用2.构造方法
ObjectInputStream(InputStream in):创建从指定InputStream字节输入流读取的反序列化流
参数:InputStream in:字节输入流3.反序列化流特有方法:
Object readObject():从ObjectInputStream反序列化流中读取对象4.反序列化流使用步骤:
1.创建ObjectInputStream反序列化流对象，构造方法中传递字节输入流
2.调用ObjectInputStream对象中readObject方法读取文件中对象
3.释放资源
4.使用读取出来的对象(打印)5.注意:
- readObject方法声明抛出了ClassNotFoundException(class文件找不到异常),当不存在对象的class文件时抛出此异常
- 反序列化前提:
- 1.此类必须实现Serializable序列化接口
- 2.必须存在类对应的class文件
6.Demo
package ObjectStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class Demo02ObjectInputStream {
public static void main(String[] args)
throws IOException, ClassNotFoundException {
//1.创建ObjectInputStream反序列化流对象，构造方法传递字节输入流读取person.txt文件中对象
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("IO流\\person.txt"));
//2.调用ObjectInputStream对象中readObject方法读取文件中对象
Object o = ois.readObject();
//3.释放资源
ois.close();
//4.使用读取出来的对象(打印)
System.out.println(o);//Demo01Person{name='东方月初', age=18}
//将Object类型对象转化为Person类型对象
Demo01Person p=(Demo01Person)o;
System.out.println(p.getName()+" "+p.getAge());//东方月初 18
}
}7.5.静态和瞬态关键字对序列化 影响
package ObjectStream;
* 1.static:静态关键字
* 静态优先于非静态加载到内存中(静态优先于对象进入到内存)，
* 被static修饰的成员变量不能被序列化的，序列化的都是对象，
* private static int age;
* oos.writeObject(new Demo01Person("东方月初",18));//序列化对象
* Object o=ois.readObject();//反序列化读取文件中对象
* 输出Person{name="东方月初",age=0}, //age不能序列化
*
* 2.transient:瞬态关键字
* 被transient修饰的成员变量，不能被序列化
* private transient int age;
* oos.writeObject(new Demo01Person("东方月初",18));//序列化
* Object o=ois.readObject(); //反序列化
* 输出Person{name="东方月初",age=0}, //age不能序列化
public class Demo03transient {
}
7.6.反序列前提
- 1.对于jvm可以反序列化对象，它必须是能够找到class文件的类，如果找不到该类的class文件，则抛出ClassNotFoundException异常。
- 2.另外，当jvm反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException异常，异常的原因如下:
- 1.该类的序列版本号与从流中读取的类描述的版本号不匹配
- 2.该类包含未知数据类
- 3.该类没有可访问的无参数构造方法
序列版本号作用
- Serializable接口给需要序列化的类，提供了一个序列版本号serialVersionUID,该版本号目的在于验序列化的对象和对应类是否版本匹配。
- 若先将对象序列化后存入文件，然后修改Class文件即把Demo01Person类中的 private int age改为public int age之后，再进行对象的反序列化就会抛出InvalidClassException异常，序列版本号不匹配， 也就是说写入对象时的类和读取对象时的类不同导致无法读取出对象。
序列版本号不匹配解决
- 为了避免序列化后修改了class文件后再反序列化时出现序列版本号不匹配问题，可以在可序列化类中自己定义一个 序列化版本号serialVersionUID字段，该字段是常量，是静态static,最终的final的Long型字段，这样不管怎么修改class文件，该文件的序列化版本号都不会变。
7.7.InvalidClassException异常的原理(序列号不匹配问题)
- 编译器(javac.exe)会把Person.java文件编译成Person.class文件，
- 当Person类实现Serializable序列化接口后，会根据类的定义给Person.class文件添加一个序列号存储在class文件中，然后开始执行序列化，把对象存储到Person.txt文件中同时，class文件中的序列号也会被存储到Person.txt文件中，当执行反序列化来读取文件中对象时，会使用Person.class文件中的序列号和Person.txt文件中的序列号比较，如果一致，则反序列化成功，否则抛出反序列化冲突异常invalidClassException。
- 若对象序列化后在Person.class文件和Person.txt文件中的序列号都为serialVersionUID=-64726,但在执行对象反序列化(读取文件中对象)前修改类Person类的定义，那么就会给Person.class文件重新编译生成一个新的序列号serialVersionUID=-32969,而此时由于之前的序列化使得Person.txt中序列号为serialVersionUID=-64726
- 这样一来，在反序列化时由于class文件和txt文件中序列号不一致导致反序列化失败。序列号只要是验证序列化后txt文件中的序列号与反序列化时class文件中的序列号是否一致，决定反序列化成功与否
package ObjectStream;
import java.io.Serializable;
/**
* 为确保序列化后txt文件中的序列号与反序列化时class文件中的序列号一致，
* 在可序列化类中要定义一个静态的最终的长整型的常量serialVersionUID序列号，
* 这样即使序列化后又修改了可序列化类Demo01Person也不会改变系列号。
*/
public class Demo01Person implements Serializable { //该类实现序列化接口
//序列号常量，确保序列号一致，反序列化成功
private static final long serialVersionUID=1;
private String name;
private int age;
public Demo01Person(String name, int age) {
this.name = name;
this.age = age;
}
public Demo01Person() { }
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 "Demo01Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
8.PrintStream
打印流:PrintStream
* 1.java.io.PrintStream打印流
* PrintStream为其它输出流添加了功能，使他们能够方便打印各种数据值表示形式
* 2.PrintStream打印流特点:
* 1.只负责数据的输出，不负责数据的读取
* 2.与其他输出流不同，PrintStream永远不会抛出IOException异常
* 3.有特别的方法:print,println
* void print(任意类型的值)
* void println(任意类型的值并换行)
* 3.打印流的构造方法
* PrintStream(File file):输出的目的地是一个文件
* PrintStream(OutputStream out):输出的目的地是一个字节输出流
* PrintStream(String fileName):输出的目的地是一个文件路径
* 4.PrintStream extends OutputStream (打印流是字节输出流的子类)
* 继承自父类OutputStream的成员方法：
* -void write(int c):写入单个字符
* -void write(char[] cbuf):写入字符数组
* -abstract void write(char[] cbuf,int off,int len):写入字符数组的一部分
* -void write(String str):写入字符串
* -void write(String str,int off,int len):写入字符串的一部分
* -void flush():刷新该流的缓冲
* -void close():关闭此流，但要先刷新它
* 5.注意:
* 如果使用继承自父类的write方法写数据，那么查看数据的时候会查看编码表，97--a
* 如果使用自己特有的方法print/println写数据，写的数据原样输出 97--97
package Demo10PrintStream;
import java.io.FileNotFoundException;
import java.io.PrintStream;
public class Demo01PrintStream {
public static void main(String[] args) throws FileNotFoundException {
//1.创建打印流PrintStream对象，构造方法中绑定要输出的目的地
PrintStream ps = new PrintStream("IO流\\print.txt");
//2.如果使用继承自父类的write方法写数据，那么查看数据的时候会查看编码表，97--a
ps.write(97);
//3.如果使用自己特有的方法print/println写数据，写的数据原样输出 97--97
ps.println(97);
ps.println(8.8);
ps.println("你好");
ps.println(true);
//4.释放资源
ps.close();
}
}
* 打印流可以改变输出语句的目的地(打印流的流向)
* 输出语句，默认在控制台输出
* 使用System.setOut方法可以将输出语句的目的地改为参数中传递的打印流的目的地
* static void setOut(PrintStream out):重新分配标准输出流package Demo10PrintStream;
import java.io.FileNotFoundException;
import java.io.PrintStream;
public class Demo02PrintStream {
public static void main(String[] args) throws FileNotFoundException {
System.out.println("我是在控制台输出");
PrintStream ps = new PrintStream("IO流\\目的地打印流.txt");
System.setOut(ps);//把输出语句的目的地改为打印流的目的地
System.out.println("我在打印流的目的地中输出");
ps.close();
}
}
148
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
