前言:根据动力节点培训班视频来总结的一篇博客,可以说是取其精华去其糟粕,我将用最通俗易懂的语言,讲明白IO流,最为新手入门应该掌握的知识点。
1)注意,目录中表名【重要】的,就是要掌握的流,其他的流作为了解即可。
2)代码中 main() 方法 throws 异常这种写法是不规范的,应该 try catch,为了省空间,我直接写 throws
3)本文哪里写得不好的,还请各位不吝赐教,我一定第一时间修改,在此谢过。
视频连接:https://www.bilibili.com/video/BV1Rx411876f?p=720
目录
一、IO流简介
二、FileInputStream【重要】、FileOutputStream【重要】
- 1)FileInputStream
- 2)FileInputStream的其他方法
- 3)相对路径和绝对路径
- 4)FileOutputStream
- 5)文件复制
三、FileReader、FileWriter
- 1)FileOutputStream
- 2)文件复制
四、缓冲流 BufferedReader和BufferedWriter
五、数据流 DataOutputStream、DataInputStream
六、打印流 PrintStream【重要】、PrintWriter
七、对象流 ObjectInputStream【重要】、ObjectOutputStream【重要】
- 1)序列化流将对象写入文件
- 2)反序列化流读取文件中的对象
- 3)存入和读取多个对象
- 4)transient关键字
- 5)序列化版本号
八、IO和Properties【重要】
- 1)Properties
- 2)属性配置文件
- 3)结合IO流和Properties集合读取文件内容
- 4)第八章的重要性
一、IO流简介
1)什么是IO流?
I 是 input(输入)的缩写,O 是 output(输出)的缩写,流是指数据。
2)什么是输入,什么是输出?
我们的计算机上,有内存和硬盘两个可以存放数据的地方,内存中的数据的临时的,硬盘中的数据的持久的。当我们从硬盘中“读取”(read)数据到内存中使用时,称为“输入”(input);当我们将内存中的数据“写入”(write)到硬盘中存储时,称为“输出”(output)。【注意:“读取”对应“输入”,“写入”对应“输出”。背好这句,后面贼好用!】
3)IO流有哪些分类?
根据流的方向进行分类:输入流和输出流。
根据数据的读取方式进行分类:字节流和字符流。
4)什么是字节流,什么是字符流?
如果对输入和输出理解了,那么对输入流和输出流这种分类方式应该不难理解。那么什么是字节流和字符流呢?
字节流,是指数据的读取方式是一次读取1个字节byte,这种流能够读取任何类型的文件,比如音频、视频、图片等都可以;字符流,是指数据的读取方式是一次读取一个字符,是只为了读取文本文件(仅仅只对 【.txt】 文件)而存在的,因此不能读取音频、视频等类型的文件。举个例子:
假设有一个文本文件,是a.txt,文件中的内容如下:a张三12李四
在windows系统的文本文件中,一个数字、符号或者是字母,其大小是1个字节;一个汉字的大小则会因为编码格式的
不同而占用不同的字节。
假如用字节流读取:第一次读取'a',第二次读取'张'的一部分,第三次读取'张'的另一部分......
假如用字符流读取:第一次读取'a',第二次读取'张',第三次读取'三'......
5)IO流怎么学?
java中IO流对应的多种类都已经写好了,初学者不需要关心其底层原理,只需要掌握java为我们提供了哪些流,流的特点是什么,常用方法有哪些即可。且要知道java中所有的流都是在 java.io.* 下面。
6)先看一下大概的IO流家族,如下图,有加中文的,本篇博客都会介绍到。
![](https://img-blog.csdnimg.cn/20201004161307963.jpg?#pic_center)
上图中,带“File”的是文件流,带“Buffered”的是缓冲流,带“StreamReader”的是转换流,带“Data”的是数据流,
带“Print”的是打印流,带“Object”的是对象流,我们会在后面一一介绍到。
注意:
1)在java中,类名以“Stream”结尾的就都是字节流;以“Reader/Writer”结尾的就都是字符流。
2)InputStream、OutputStream、Reader、Writer都是抽象类。所有的流都实现了Closeable接口,都有close()方法,都是可以关闭的,且流在使用之后是必须关闭的。
3)所有的输出流还实现了Flushable接口,都有flush()方法,每一次使用完输出流之后,先flush()后,再close()。flush()方法可以将没有输出的数据强行输出,防止丢失数据。
二、FileInputStream、FileOutputStream【重要】
1、FileInputStream
FileInputStream,包含“Stream”,说明它是一个字节流;包含“File”,说明它是专门用于读取文件的流。
现在,我们直接用代码来表述,说明这个类的使用。我们创建一个文件 F:\a.txt,文本内容是 1a.中 。注意这个文本内容很具有代表性,1是数字,a是字母,. 是符号,中是汉字。
然后我们尝试将该硬盘文件中的内容读取并打印出来,看看我们能打印出什么。
public class IOTest01 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
//1)先创建流对象,构造方法 FileInputStream() 会抛出异常,需要处理
fis = new FileInputStream("F:\\a.txt");
//4)reaf()方法是读取一个字节。
//在ASCII编码表中,字符'1'对应49,字符'a'对应97,字符'.'对应46
//可以看到,汉字'中'对应3个字节,分别是228、184、173
//当读取到-1后,表示文本已经读取完了,没有其他内容了
int readData = fis.read();
System.out.println(readData); //49
readData = fis.read();
System.out.println(readData); //97
readData = fis.read();
System.out.println(readData); //46
readData = fis.read();
System.out.println(readData); //228
readData = fis.read();
System.out.println(readData); //184
readData = fis.read();
System.out.println(readData); //173
readData = fis.read();
System.out.println(readData); //-1
readData = fis.read();
System.out.println(readData); //-1
//2)FileInputStream() 抛出的异常在这里处理
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) { //5)read()方法也存在异常,因此也需要捕捉
e.printStackTrace();
} finally {
//3)流使用之后,需要关闭,在finally中进行关闭
if(fis!=null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
对上述代码的解释,按注释给的顺序阅读代码,很容易懂
对 if(fis!=null) 的解释:
这个判断条件很有必要加,加完之后。
假设fis为空,那么就不需要关闭了,就不会执行 if{ } 中关闭流这些代码;如果fis不为空,就关闭流。
这样做的目的是防止空指针异常。
你想想,如果不加的话,fis为空,即fis这个引用没有指向任何对象,那它怎么调用close()方法,这样就会发空指
针异常。
对read()方法的解释:
read()方法就是“读取”,每次读取一个字节大小的数据,返回一个int类型的字面量。
每读取一个,光标就会往下移动一个字节,以便读取下一个字节。
当读取的返回值是-1时,表示文本已经读完了。
对’中’读取了三个字节的解释:
字母,英文符号,数字只占一个字节。但是汉字的字节数是不确定的,编码格式不同,汉字的字节数也可能会不同。
细心的小伙伴应该有发现到,上面读一个字节,打印一个字节,代码大量重复,因此我们优化一下代码,用循环来读取。代码如下:
public class IOTest01 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("F:\\a.txt");
//1)我们定义一个变量readData,来存放读取到的字节
int readData = 0;
//2)以下代码的意思是,只要读取到的字节不为-1,也就是文本没有读完,就一直循环地读,并把
//读到的值赋值给readData,同时打印readData。
while((readData=fis.read())!=-1){
System.out.println(readData);
}
//!!!注意从现在开始,这行以下代码基本都是相同的,我们不需要再关注它们
//重要事情再说一遍,接下来的重复代码,我们看try{}中的代码即可
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fis!=null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
学会了怎么使用输入流之后,我们反过来,再来看看JDK帮助文档,我们发现,read()方法还有另一个重载方法,如下:
read()方法:这个方法,是将一个字节从硬盘读取内存,再继续读下一个,依次往返读取。这就好比是送外卖,外卖
小哥一次从饭店拿一个饭盒,送给客户,然后又回到饭店,再拿一个饭盒....显然这样做的效率十分低下。
read(byte[] b)方法:这个方法,是将读取到的多个字节存放到字节数组中,然后一次性搬到内存。这就好比外卖小
哥学聪明了,他用大袋子装了很多饭盒,这就不用往复跑很多次了。这样,效率就变高了。
注意:read()的返回值是一个小于256的int类型的数字;read(byte[] b)的返回值表示读到了几个字节数量,比如我们
定义一个byte[1024],也就是能存1024个字节的数组,然后我们的文件大小是1025个字节,那么使用循环读取,第
一次返回的int是1024,第二次是1,第三次是-1。具体看下面的代码。
我们把 a.txt 文件的内容改成 abcde,把文件放到项目下
我们来看一下代码是怎样的:
public class IOTest01 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("a.txt");
//注意这里的变量名从readData变成了readCount,因为使用read(byte[] b)方法,其返回值是
//字节数量,而不是字节这个数据本身
int readCount = 0;
//1)定义一个字节数组,长度为4
byte[] bytes = new byte[4];
//2)将字节4个4个地读取到bytes中
readData = fis.read(bytes);
System.out.println(readData); //4
readData = fis.read(bytes);
System.out.println(readData); //1
readData = fis.read(bytes);
System.out.println(readData); //-1
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fis!=null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
同样的,上述代码也可以用循环进行优化
public class IOTest01 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("a.txt");
int readData = 0;
//1)定义一个字节数组,长度为4
byte[] bytes = new byte[4];
//2)将字节4个4个地读取到bytes中
while((readData=fis.read(bytes))!=-1){
//3)这一步稍作修改,使用String类的构造方法传入一个字节数组,将字节数组中的数据转换成
//字符串,从下标0读到下标为readData的位置
System.out.println(new String(bytes,0,readData));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fis!=null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2、FileInputStream的其他方法
在前面的学习中,我们只学习了FileInputStream的两个方法,read()和close()。现在,我们来了解另外的方法,可能以后会用到。
1) avaliable()方法:该方法返回文件中剩下的字节数量,注意是数量
我们的文本内容依然是 abcde,来看看avaliable()方法有什么妙用
public class IOTest01 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("a.txt");
//1)先不读,光标落在文件的初始位置,因此available()会返回文件的总字节数量,将其作为
//byte[]数组的大小,我们就不需要循环读取了
byte[] bytes = new byte[fis.available()];
fis.read(bytes);
System.out.println(new String(bytes));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fis!=null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2) skip()方法:跳过指定数量的字节,不读
public class IOTest01 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("a.txt");
fis.skip(3); //跳过3个,我们推测接下来读到的是d,而不是a
System.out.println(fis.read()); //100.ASCII编码表中,字符'd'对应100.
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fis!=null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
3、相对路径和绝对路径
绝对路径:指从盘符开始的路径
相对路径:指当前项目的路径
这样说简直不是人话,我们用图说话吧。
首先是绝对路径:我们在javase这个项目下面新建一个a.txt文件,那么这个文件的绝对路径就是 F:\software\IDEA\project\javase\a.txt
然后是相对路径,a.txt 的相对路径是什么呢?上面是说,当前项目的路径。诶,我们的 a.txt 不就是刚好就在 javase 这个项目下吗?所以相对路径就是 a.txt 。如下代码,盘符和前面的各层文件夹都不用写出来了。
FileInputStream fis = new FileInputStream("a.txt");
来,考一考各位,以下将 a.txt 放在src文件夹下,该怎么写相对路径呢?如果会的话,说明你就掌握了。
//同样的,盘符和前面的各层文件夹都不用写
FileInputStream fis = new FileInputStream("IO流\\src\\a.txt");
另外值得一提的是,在java中,以下路径写法都是对的
FileInputStream fis = new FileInputStream("IO流\\src\\a.txt");
// 使用两个 \ ,是因为java中的字符串中,\是转义字符,在字符串中两个 \ 才能表示一个 \
FileInputStream fis = new FileInputStream("IO流/src/a.txt");
4、FileOutputStream
学明白FileInputStream之后,FileOutputStream就简单了。我们直接看代码
public class IOTest01 {
public static void main(String[] args) {
FileOutputStream fos = null;
try {
//同样的,我们关注try{}中的代码即可
//1)假设我们的new.txt文件是不存在。那它会像FileInputStream那样出现找不到文件的异常吗?
//答案是不会,如果new.txt文件不存在,由于这是个相对路径,因此会在当前项目创建一个new.txt
//文件
fos = new FileOutputStream("new.txt");
//2)我们要想 new.txt 中写入数据,先定义一个有数据的字节数组。97、98、99、100分别对应字
//符'a'、'b'、'c'、'd'
byte[] bytes = {97,98,99,100};
//3)调用write()方法将数组bytes中的数据写到文件 new.txt 中
fos.write(bytes);
//4)前面已经有提到,输出流在关闭之前,需要调用flush()方法清空数据流。防止数据缺漏
fos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fos!=null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
执行以上代码之后,我们可以看到在 javase 文件夹下,多了一个新的 new.txt 文件,且文本内容是 abcd 。
关于write()方法
输出流的write()方法和输入流的read()方法其实是对应的。
read()方法有几个重载方法,read(byte[] b),read(byte[],int off,int length)(off是起始位置,length)
是所要读取的字节数。
类比过去,write()方法也是有write(byte[] b),write(byte[],int off,int length),他们的功能也都是类似
的。只不过read()是读取,write()是写入而已。也就是说write()是一个字节一个字节地写入,write(byte[] b)
是将字节数组中的多个字节同时写入。
此时,我们想在 new.txt 中,再加上 efg,使文本内容变成 abcdefg,我们将上面代码修改一下
byte[] bytes = {101,102,103};
继续执行,然后看看我们的文件。发现文本内容竟然是 efg,并没有达到我们想要的结果。我们去看看JDK的帮助文档。
发现还有另外一个构造方法,第二个参数 boolean append,当为true时,表示在文本内容末尾加上新的内容;当为false时,表示将文本内容覆盖掉,写入新的内容。这里就不再演示了,大家改改代码验证一下就行。
FileOutputStream fos = new FileOutputStream("new.txt",true);
接着,上面的代码中,我们想要向文件中写入 abcd ,这是因为我们知道在ASCII码表中,他们分别对应97、98、99、100,那要是我想写入汉字呢,比如我想写入“我爱中国”,有什么办法将这些汉字转换成字节吗?有的,我们可以使用getBytes()方法。
我直接写try中的内容。
try{
fos = new FileOutputStream("new.txt",true);
byte[] bytes = "我爱中国".getBytes();
fos.write(bytes);
fos.flush();
}
//当然,还能简化一点
try{
fos = new FileOutputStream("new.txt",true);
fos.write("我爱中国".getBytes());
fos.flush();
}
5、文件复制
已经学习了FileInputStream和FileOutputStream,输入流是将数据从硬盘读取到内存,输出流是将数据从内存写入到硬盘,那这样的话,我们就能实现文件的复制了。这次不操作文本文件,我们来试一下图片的复制。
如上,将图片 01.jpg 放到项目 javase 中,我们将它复制到 IO流 模块的目录下。
public class IOTest01 {
public static void main(String[] args) {
//1)声明两个对象,要在try{}以外声明,否则不能在finally{}中关闭
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("01.jpg");
fos = new FileOutputStream("IO流\\01.jpg");
byte[] bytes = new byte[fis.available()];
fis.read(bytes);
fos.write(bytes);
fos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
//2)注意这里两个流都要关闭
if(fis!=null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fos!=null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
有了前面的学习,这里的代码就不难了。执行程序,图片就复制成功了。
注意这里前面说过,字节流能操作任何类型的文件,所以这里除了复制图片,复制其他类型的文件也是可以的,只不过如果是比较大的视频,效率可能会比较低。
三、FileReader、FileWriter
在第一部分 IO简介 中就有指出,类名包含 Reader 和 Writer 的,就是专门用来操作文本文件的。而且学懂前面的字节流,字符流就会相当简单。
字节流的read()和write(),是一个字节一个字节地读取和写入,那么字符流的read()和write(),自然就是一个字符一个字符地读取和写入。比如我们读取一个内容为 我爱abc 的文本文件,会先读 ‘我’ ,然后光标移动一位,下次调用read()方法的时候,就是读 ‘爱’。
这里口水比较多,大家估计都已经懂了,但我还是要啰嗦一下,同样的,字符流也有read(char[] c)和write(char[] c)方法来一次性读取或者写入多个字符。
已经没有多的知识点了,直接贴代码吧。
1、FileReader
public class IOTest01 {
public static void main(String[] args) {
FileReader fr = null;
try {
fr = new FileReader("a.txt");
//1)字节流就要定义字节数组,字符流就要定义字符数组。
//注意字节流中有avaliable()方法得到剩下的字节数,而字符流没有对应的方法
char[] chars = new char[1024];
//2)与字节流相同。同样读取到数组中。
fr.read(chars);
System.out.println(chars);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
//3)这里的变量名要修改成fr喽,别忘了
if(fr!=null){
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2、FileWriter
public class IOTest01 {
public static void main(String[] args) {
FileWriter fw = null;
try {
fw = new FileWriter("a.txt",true);
char[] chars = {'我','爱','中','国'};
fw.write(chars);
fw.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fw!=null){
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
四、缓冲流 BufferedReader和BufferedWriter
在前面那个说要介绍哪些流的图中,有四个缓冲流,分别是 BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream ,和文件流中的字节流和字符流类似,缓冲流中的字节流和字符流之间基本的方法也都是类似的,因此这里只介绍 BufferedReader和BufferedWriter。
所谓缓冲流,就是自带字节数组或者字符数组,我们不需要像之前那样去定义字节数组或者字符数组了,因为缓冲流中是自带的。
另外,很多人死记硬背使用缓冲流的代码,这样子一旦太久没有敲IO流的代码,就会很容易忘记。
所以接下来。我们一起去看帮助文档,理解了,就容易记了。
我们看到这两个构造方法,第二个参数是 sz,即 size(大小) 的缩写,这个就是用来指定字符数组的大小的;关键是第一个参数 Reader in,我们貌似还学习过这个类,继续查这个类,得到以下重要信息。
绕了一圈,因为Reader是抽象类不能实例化,因此我们要实例化其子类,查看其子类,最终找到其子类InputStreamReader的子类FileReader是我们学过的,所以,我们应该用FileReader对象来作为参数。
现在,我们来读取一个文本,文本内容如下图:
看代码。
public class IOTest01 {
public static void main(String[] args) {
BufferedReader br = null;
try {
//1)用FileReader对象作为参数传入
br = new BufferedReader(new FileReader("a.txt"));
//2)使用缓冲流的好处,就是其有一个方法readLine(),可以读取文本的一行。
//当文本读完时,返回的不是-1,而是null
String str = br.readLine();
System.out.println(str); //我爱中国
str = br.readLine();
System.out.println(str); //
str = br.readLine();
System.out.println(str); //我爱中国
str = br.readLine();
System.out.println(str); //null
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(br!=null){
try {
//3)注意这里,只有最外层的包装流BufferedReader需要关闭
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
同样的,我们用循环进行优化
try {
br = new BufferedReader(new FileReader("a.txt"));
String str = null;
//只要读到的字符串不为null,也就是文本没有结束,就一直一行一行地往下读
while((str=br.readLine())!=null){
System.out.println(str);
}
}
这里还有两个概念,就是节点流和包装流,很好理解。当我们将一个流对象A作为参数传给另一个流B的构造方法时,
A就是节点流,B就是包装流。
节点流和包装流是相对而言的,比如下面的代码中,InputStreamReader对于FileInputStream来说是包装流,对于
BufferedReader来说是节点流。
现在,假设我们用一个FileInputStream对象作为参数传入会怎样呢?会报错,因为FileInputStream是字节流,而我们所需要的参数是Reader,是字符流,因此,我们需要用到转换流,也就是我们在找Reader的子类时,找到的那个InputStreamReader。
用法如下:
try {
//1)套娃行为,就是现将字节流转换成字符流,再传给BufferedReader的构造方法
br = new BufferedReader(new InputStreamReader(new FileInputStream("a.txt")));
String str = null;
while((str=br.readLine())!=null){
System.out.println(str);
}
}
BufferedWriter就不多介绍了,你想想,BufferedReader可以读取一行,且读取到的一行是字符串,那么相对的,BufferedWriter的write()方法,也可以写入一行字符串,直接给代码,试试效果。
BufferedWriter br = null;
try {
br = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt")));
br.write("张三\n");
br.write("李四");
br.flush();
}
五、数据流 DataOutputStream、DataInputStream
到这里内容优点多,我们做个简单回顾,前面已经学习了文件流、转换流、缓冲流,其实最重要的两个流,是FileInputStream、FileOutputStream,以下是杜聚宾老师的原话
我们以前在开发中,最常用的是FileInputStream、FileOutputStream,偶尔会用到缓冲流,转换流基本没用过。
这里你会觉得很坑,那前面不是都白学了吗?并没有,因为这些是基本功,把基础打牢固了,后面接触某些新知识就会容易了。
回到数据流,我们来介绍一下什么是数据流?
数据流在将数据写入到文件的时候,除了数据本身之外,数据的类型也会被一起写入到文件中。因此这个文件是特殊
,不是普通的文本文件,不能被直接打开。
以下是DataOutputStream的构造方法
同样的,OutputStream是一个抽象类,不能实例化,我们用其子类FileOutputStream
public class IOTest01 {
//这里的throws抛出异常是不规范写法,应该要用try catch捕捉处理
public static void main(String[] args) throws IOException {
//1)定义数据流,构造方法的参数传一个FileOutputStream对象。
//注意这里的文件名没有后缀,不是 .txt 文件
DataOutputStream dos = new DataOutputStream(new FileOutputStream("b"));
//2)定义各种数据类型的变量
byte b = 100;
short s = 200;
int i = 300;
long l = 400L;
float f = 1.0f;
double d = 2.0;
boolean bo = true;
char c = 'a';
//3)调用相对应的方法将变量写入到文件中
dos.writeByte(b);
dos.writeShort(s);
dos.writeInt(i);
dos.writeLong(l);
dos.writeFloat(f);
dos.writeDouble(d);
dos.writeBoolean(bo);
dos.writeChar(c);
//4)流的刷新和关闭
dos.flush();
dos.close();
}
}
执行以上程序之后,我们来打开,看看这个文件,发现是一堆乱码。
那如何重新查看这些数据呢?
[ 只能用数据输入流重新读取,且读取的顺序,必须和存入的时候一模一样,才能使读到的数据完全正确 ]
代码如下:
public class IOTest02 {
public static void main(String[] args) throws IOException {
DataInputStream dis = new DataInputStream(new FileInputStream("b"));
byte b = dis.readByte();
short s = dis.readShort();
int i = dis.readInt();
long l = dis.readLong();
float f = dis.readFloat();
double d = dis.readDouble();
boolean bo = dis.readBoolean();
char c = dis.readChar();
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(l);
System.out.println(f);
System.out.println(d);
System.out.println(bo);
System.out.println(c);
}
}
数据流也用的很少,以下仍是杜聚宾老师的原话
在开发生涯中,只用过一次
六、打印流 PrintStream【重要】、PrintWriter
你还记得我们学习java的第一个程序“Hello World”吗?打印字符串的语句:
System.out.println("Hello world");
这我们都会写。但是你有没有去想过,为什么System.out.println(),就能将字符串打印在控制台上吗?我来解释给你听。
1)首先了解System,它也是一个类,在java.lang包下面,java规定,lang包下的类都是不用导入就能直接使用的。因此我们不导包,也能直接使用System类。
2)其次了解System.out。我们来看System类的部分源代码。System类中有一个引用out,其类型是就是PrintStream,我们还发现,这是一个用static修饰的引用,因此我们能直接用 System.out 进行访问。
这里的 out 是 null ,但往下的代码中会对其进行赋值,这里涉及到的有些方法是用C++或者C代码写的,我们没有必要再深究了。只要知道,其最后会被赋值一个PrintStream对象即可。
3)接着了解整句,System.out.println()。我们看PrintStream的源码。我们发现,原来println()是PrintStream类的一个方法。关于这个方法为什么能将字符串打印到控制台上,我们依旧没有必要再深究了。
来,也就是说我们得到以下的代码,两者是完全等价的。
public class IOTest02 {
public static void main(String[] args) throws IOException {
System.out.println("张三");
PrintStream ps = System.out;
ps.println("张三");
}
}
理解了System.out.println()之后,先转个脑回路,我们思考一个问题:凭什么只能输出在控制台上,我输出到其他地方不可以吗?我们来看看System类的源码。我们发现一个setOut()方法,根据字面意思,就是设置输出,这应该是就是我们要用到的方法了。
setOut()方法调用了两个方法,我们来看setOut0()方法。发现它是个本地方法(用关键字 native 修饰的方法称为本地方法,底层是用C++写的),那就不深究了,我们会用setOut()方法就行。
setOut()方法需要传入一个PrintStream对象,因此我们需要先创建一个PrintStream对象,PrintStream的构造方法又需要传入一个OutputStream,OutputStream是抽象类,因此我们要使用其子类FileOutputStream来创建(利用多态特性)。
万事俱备了,我们来看代码
public class IOTest01 {
public static void main(String[] args) throws IOException {
PrintStream ps = new PrintStream(new FileOutputStream("a.txt"));
System.setOut(ps);
//以下语句会打印到当前项目下的a.txt文件中
System.out.println("张三");
System.out.println("李四");
System.out.println("王五");
}
}
那输出到文件有什么作用呢?作用大着呢,我们可以利用上述代码来写一个日志类,通过日志类来生成日志。(日志文件,就是专门用来记录程序执行情况的文件)
日志类的代码如下:(这个类的代码是垃圾代码,不规范,只是想让大家知道日志是个什么东西)
public class Logger {
public static void log(String str){
try {
//1)创建一个打印流,打印在log.txt文件上
PrintStream ps = new PrintStream(new FileOutputStream("log.txt",true));
//2)通过System类修改输出方向
System.setOut(ps);
//3)创建日期对象
Date date = new Date();
//4)格式化日期:年-月-日 时-分-秒 毫秒
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
String time = sdf.format(date);
//5)将日期和参数str打印到log.txt文件中
System.out.println(time + ":" + str);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
创建好Logger类之后,我们执行以下程序。日志文件就生成了,打开看文件中的内容,你就了解日志文件是个什么玩意儿了。
public class IOTest01 {
public static void main(String[] args) throws IOException {
Logger.log("调用了login()方法,用户开始登陆");
Logger.log("用户登陆成功");
}
}
七、对象流 ObjectInputStream【重要】、ObjectOutputStream【重要】
在前面的所有所学到的流中,我们向文件中写入的数据,要么是字节,要么是字符,要么是字符串,最后一部分,我们要来学习怎么向文件中写入java对象。
1)为什么我们要向文件中写入java对象呢?
java对象中可以保存数据,假设我们定义了一个User类(用户)来存放用户的一些信息,比如账号、密码,以及个人
信息等,这些在用户注册完账号后,都要先把数据作为参数保存在User对象中,再将User对象写入到文件中,这样就
能将用户信息永久地保存在硬盘中了。
当下一次用户登陆的时候,我们就去文件中找到对应的账号,只有用户输入的密码是正确的,才能成功地登陆。
2)什么是“序列化”和“反序列化”?
这两个流因为能写入和读取文件中的java对象,因此称为“对象流”。其中,ObjectOutputStream又称为“序列化流”,
ObjectInputStream又称为“反序列化流”。
序列化是指将对象从内存写入到硬盘的过程,反序列化是指将对象从硬盘读取到内存的过程。
我们仍然先看看帮助文档,其构造方法仍然是需要传入FileOutputStream和FileInputStream(多态,再次强调!)
我们先创建一个User类,等会就来存这个类的对象(直接复制代码即可)
public class User {
private long account; //账号
private String password; //密码
public User(long account, String password) {
this.account = account;
this.password = password;
}
public long getAccount() {
return account;
}
public void setAccount(long account) {
this.account = account;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User{" +
"account=" + account +
", password='" + password + '\'' +
'}';
}
}
1、序列化流将对象写入文件
现在,我们来实际操作一下,首先是序列化流ObjectOutputStream
public class IOTest01 {
public static void main(String[] args) throws IOException {
//1)创建一个序列化对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user"));
//2)创建user对象
User user = new User(123456, "abc");
//3)调用方法将user对象写入
oos.writeObject(user);
oos.flush();
oos.close();
}
}
执行以上程序,结果出异常了,如下
解决方法很简单,我们修改一下User类如下:也就是去实现Serializable这个接口
public class User implements Serializable{
}
我们查看这个Serializable接口,发现这个接口里面竟然什么都没有写!
这里扩展一下,向Serializable这种什么内容都没有的接口,称为'标识接口'。
实现Serializable这个接口,并不是想要实现它的某些方法,或者遵从它的某些规范,它仅仅只是一个标识的作用,
它仅仅只是要告诉程序员,实现了它的类,就是可以序列化的类。
也就是说,实现了Serializable之后,现在我们的User对象可以序列化了。
继续执行将其序列化的代码,发现成功了,而且生成了一个user文件,且打开之后都是乱码。想要知道里面存的是什么,方法就是使用反序列化流来读取。
2、反序列化流读取文件中的对象
其实,我们发现,加上序列化流中上述代码,和之前相比只多了两个新的方法,writeObject()和readObject(),所以要掌握的新内容也不多,下面直接给代码,很容易看懂。
接下来,开始反序列化流ObjectInputStream的代码:
public class IOTest02 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//1)定义一个反序列化对象,指向user文件
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user"));
//2)调用readObject()方法,读取文件中的对象
Object obj = ois.readObject();
System.out.println(obj); //打印一个对象,其实是调用该对象的toString()方法,我们已经重写了该方法
ois.close();
}
}
运行结果如下,也就是说我们成功读取出了对象。
3、存入和读取多个对象
向文件中写入多个对象,不能向其他流一样,通过 new FileOutputStream(" ",true) 的方式,也就是在文件末继续写入对象来实现(原因比较复杂,我会重新开坑,写一篇专门介绍这个原因的博客)。
而是采用集合的方式,向集合对象中添加入多个User对象,再将集合对象写入到文件中,来实现一次性存入多个User对象。如果你还没学过集合,就先理解成集合是一个容器,可以存放对象。当然,这不是唯一的实现方式,且这是较差的一种方式,我都会在新坑里做介绍的。
我们先看看代码,注意要先把原来的 user 文件删除掉。
写入集合对象的代码如下:
public class IOTest01 {
public static void main(String[] args) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user"));
List<User> list = new ArrayList<>(); //创建一个集合
list.add(new User(111,"abc")); //add()方法是,向集合中添加对象,我们这里直接传入一个匿名对象
list.add(new User(222,"abc"));
list.add(new User(333,"abc"));
oos.writeObject(list); //将集合写入文件
oos.flush();
oos.close();
}
}
读取集合对象
public class IOTest02 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user"));
//将集合读取出来,由于readObject()方法是返回一个Object对象,因此我们这里要将Object强转成List
List list = (ArrayList) ois.readObject();
User user1 = (User) list.get(0); //集合的get()方法,可以通过传入索引来获取到对象
User user2 = (User) list.get(1);
User user3 = (User) list.get(2);
System.out.println(user1); //打印取到的User对象
System.out.println(user2);
System.out.println(user3);
ois.close();
}
}
这样,我们就取出了User对象,如下图:
这一小节的开头我有说到,使用 new FileOutputStream(" ",true) 作为参数传给 ObjectOutputStream 的构造方法,来实现添加对象的方式是行不通的。因此,如果我们还要写入更多的User对象,只能将集合读取出来,往集合中存入新的User对象,再将集合继续写入文件来实现。我们来看下面的代码,稍微修改一下IOTest02即可。
public class IOTest02 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user"));
//ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user"));
List list = (ArrayList) ois.readObject();
System.out.println(list); //这里的打印,是为了确认一下user文件集合中只有3个User对象
list.add(new User(444,"abc")); //然后我们往读取出来的集合中,再添加2个User对象
list.add(new User(555,"abc"));
ois.close();
//注意以下细节,不能在上面那个位置中定义,会报错
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user"));
oos.writeObject(list);
oos.flush();
oos.close();
}
}
再执行一下以下程序,验证我们的文件中的集合中已经有5个User对象了。
public class IOTest03 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user"));
List list = (ArrayList) ois.readObject();
System.out.println(list);
}
}
这种方式,显然过于繁琐,所以我才说这是一种比较差劲的方式。当然,这里你也可以不用深究,也没有必要深究。如果想深究的话,可以去看看其他博客,或者等我把填坑的博客写完,我会在这里加上链接。
4、transient关键字
很简单,比如你给 User 类中的 password 变量加上 transient,(private transient String password;)那么序列化 User 类对象的时候,变量 password 将不会被写入到文件中。
以下代码可以直接复制粘贴(记得删除 user 文件),没有学习的必要,主要是要知道 transient 关键字的作用即可。
public class IOTest01 {
public static void main(String[] args) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user"));
oos.writeObject(new User(111,"abc"));
oos.flush();
oos.close();
}
}
public class IOTest02 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user"));
User user = (User) ois.readObject();
System.out.println(user); //输出结果 User{account=111, password='null'}
}
}
我们取出来的 User 对象,其变量 password 的值是null,说明我们在给 User 类的 password 加上关键字 transient 之后,其就没有被写入到文件了。
5、序列化版本号
了解序列化版本号之前,我们还是先来试试代码。
我们把 User 类中的 transient 去掉,然后运行第4节中的两段代码,此时我们的 user 文件中就有一个对象,User{account=111, password=‘abc’}。现在,我们修改一下 User 类,给它新增一个成员变量 email,如下,请大家直接复制代码试验即可:
public class User implements Serializable {
private long account; //账号
private String password; //密码
private String email;
public User(long account, String password, String email) {
this.account = account;
this.password = password;
this.email = email;
}
public long getAccount() {
return account;
}
public void setAccount(long account) {
this.account = account;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "User{" +
"account=" + account +
", password='" + password + '\'' +
", email='" + email + '\'' +
'}';
}
}
改完之后,我们再去执行第4节中的第二段代码,来读取我们的 User 类对象,发现报错了。错误如下:
java.io.InvalidClassException: User; local class incompatible: stream classdesc serialVersionUID = 3094711356857122676, local class serialVersionUID = 4110144175829258817
很长,但是我们不慌,拆开来看就清晰了,如下图:
原来报错的根本原因是类的序列化版本号不一致。
那么这个序列化版本号究竟是什么呢?
Java虚拟机在看到 User 类实现了 Serializable 这个标识接口之后,就会给这个类自动生成一个序列化版本号。这个版本号的作用,是确保流中的类和文件中的类是同一个类,因为只有同一个类,序列化之后,才能被反序列化。
由于我们修改了 User 类,导致 Java虚拟机 重新为 User 类生成了一个新的序列化版本号,所以导致不一致。
但是,我们自己清楚,这两个类确实都是 User 类。所以,我们不需要 Java虚拟机 为我们自动生成序列化版本号,我们可以自己定义,且当我们自己定义的时候,便不会再自动生成。
自定义序列化版本号非常简单,只需要在类中加上 serialVersionUID 这个常量即可,如下:
public static final long serialVersionUID = 16516516543215L; //可以随便写
【小总结】:我们想要序列化和反序列化的对象,都要实现 Serializable 这个接口,且最好手动给它加上一个自定义的序列化版本号。
另外,我们在 IDEA 中也可以设置自动生成序列化对象的代码,设置方法如下:将√取消掉,然后apply,OK。
设置完之后,只要实现了 Serializable 接口的类,可以将光标停在该类上,然后按 “Alt + Enter”,就能手动添加序列化版本号了。
八、IO和Properties【重要】
第八章很重要,也许你现在学完不能理解有什么用,但是你要记住有这么个事,就是后面的重点代码我会强调,你至少要看得懂,因为学完JavaSE之后,这个知识点还会用得到,而且用得很多。
1、Properties
如果你还没有学习过集合,那也没有关系,我简单跟你介绍一下Properties是个什么玩意儿。
我们知道,数组是一种容器,比如一个 char[ ] 数组,那么它可以用来存放多个字符;同样的,集合也是一种容器,不过它是专门用来存放对象(引用数据类型)的容器。
Properties也是集合当中的一种,不过它是专门存字符串的,它可以存一个“键”,和一个“值”,键和值构成“键值对”,将键值对存入Properties对象之后,我们可以再根据“键”,来获取“值”。你先了解这些,也它有知道setProperty()和getProperty()两个方法就行,因为这是我们接下来需要用到的知识。
这么说可能有点抽象,看看代码你就很容易理解了。
public class PropertiesTest01 {
public static void main(String[] args) {
//1)创建一个Properties对象
Properties pro = new Properties();
//2)设置键值对。左边的参数就是键,右边的参数就是值。这样,键值对就存入到pro容器中了、
pro.setProperty("username","zhangsan");
pro.setProperty("password","123");
//3)然后我们从容器中,就可以通过键作为参数,来读取到值。
String username = pro.getProperty("username"); //这里用字符串类型变量来接收读取到的值
String password = pro.getProperty("password");
//4)我们将他们打印出来
System.out.println(username); //zhangsan
System.out.println(password); //123
}
}
2、属性配置文件
我们准备一个文件,文件名为 userinfo.properties,userinfo是“用户信息”的意思,但这不是我们关注的重点;我们要关注的是文件后缀 .properties,我们称其为配置文件(当然,不一定是这个文件后缀才叫配置文件,配置文件还有很多种)。
我们还注意到,红框中的图标发生了改变,这是因为IDEA识别到你的文件后缀是 .properties,它就知道是个配置文件,为了与其他文件进行区分,它就修改了图标。
我们可以打开这个文件,然后直接编写以下内容。在这里,等号左边的,我们称为“键”,英文为“key”;等号右边的,我们称为“值”,英文为“value”。
且如果内容格式为如下格式,也就是:
key1=value1
key2=value2
的配置文件,我们称为属性配置文件。
通过1、2节的学习,我们就能将其结合起来运用。我们运用 IO流 来获得文件的数据,再运用 Properties集合 来将数据存到集合对象中,再通过集合对象获取数据。
你会觉得,这不是多此一举吗?我直接用 IO流 读取数据不就得了吗,为什么还要先将数据存到集合,再读取出来?这是因为,我们编写的文件内容格式是固定的,是 “键=值” 的格式,我们在将数据存入集合后,就能通过集合,来通过键,获取值。
还是不理解?看第三节的内容。
3、结合IO流和Properties集合读取文件内容
public class IOPropertiesTest {
public static void main(String[] args) throws IOException {
//1)将文件中的数据放到流当中
FileReader reader = new FileReader("userinfo.properties");
//2)创建一个Properties对象
Properties pro = new Properties();
//3)将流中的数据加载到pro集合中,其中等号左边称为“key”,等号右边称为“value”
pro.load(reader);
//4)通过getProperty()方法,传入键,获取返回值
String username = pro.getProperty("username"); //通过传入键username,来获得值zhangsan,然后赋值给变量username
String password = pro.getProperty("password");
System.out.println(username); //输出结果是 zhangsan
System.out.println(password);
}
}
嗯,我们确实是通过键拿到了值,但是有什么用呢?
4、第八章的重要性
以后的实际开发中,一旦应用程序开发后上线供用户使用,就基本上不能再对定义好的类进行修改了。因为类一旦改变,就会相当麻烦,比如源代码需要重新编译,项目需要重新部署,服务器需要重启,且如果该类关联了其他类,其他类也可能要修改等等…
此时,我们可以在配置文件上修改啊!我们修改了配置文件上的值,就相当于修改了传入方法的字符串,我们就不需要修改代码了。
还是不理解有什么用的话,你学到后面的知识,就会慢慢理解了。