Java IO流:深入理解与总结
Java IO流:深入理解与总结
Valyn前言
一直想对IO流有更深入的了解,于是便有了以下的内容以便往后复习
IO流
(1)明确要操作的数据是数据源还是数据目的(要读还是要写)
源:
InputStream Reader
目的:
OutputStream Writer
(2)明确要操作的设备上的数据是字节还是文本
源:
字节: InputStream
文本: Reader
目的:
字节: OutputStream
文本: Writer
(3)明确数据所在的具体设备
源设备:
硬盘:文件
File
开头内存:数组,字符串
键盘:
System.in
网络:
Socket
对应目的设备:
硬盘:文件
File
开头内存:数组,字符串
屏幕:
System.out
网络:
Socket
(4)明确是否需要额外功能
源设备:
需要转换—— 转换流 InputStreamReader 、OutputStreamWriter
需要高效—— 缓冲流Bufferedxxx
多个源—— 序列流 SequenceInputStream
对象序列化—— ObjectInputStream、ObjectOutputStream
保证数据的输出形式—— 打印流PrintStream 、Printwriter
操作基本数据,保证字节原样性——DataOutputStream、DataInputStream
IO流分类
File类
File概述
java.io.File
类是专门对文件进行操作的类,只能对文件本身进行操作,不能对文件内容进行操作。java.io.File
类是文件和目录路径名的抽象表示,主要用于文件和目录的创建、查找和删除等操作。
构造方法
在java中,一切皆是对象,File类也不例外,不论是哪个对象都应该从该对象的构造说起。
常用:
1、 public File(String pathname)
:通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
2、 public File(String parent, String child)
:从父路径名字符串和子路径名字符串创建新的 File实例。
3、 public File(File parent, String child)
:从父抽象路径名和子路径名字符串创建新的 File实例。
1 | 1. 一个File对象代表硬盘中实际存在的一个文件或者目录。 |
File类的注意点:
- 一个File对象代表硬盘中实际存在的一个文件或者目录。
- File类构造方法不会给你检验这个文件或文件夹是否真实存在,因此无论该路径下是否存在文件或者目录,都不影响File对象的创建。
常用方法
File的常用方法主要分为获取功能、获取绝对路径和相对路径、判断功能、创建删除功能的方法。
获取功能的方法
1、public String getAbsolutePath()
:返回此File的绝对路径名字符串。
2、public String getPath()
:将此File转换为路径名字符串。
3、public String getName()
:返回由此File表示的文件或目录的名称。
4、public long length()
:返回由此File表示的文件的长度。
1 | public class FileGet { |
注意:length()
,表示文件的长度。但是File
对象表示目录时,则返回未指定。
绝对路径与相对路径
绝对路径:一个完整的路径,以盘符开头,例如F://aaa.txt
。
相对路径:一个简化的路径,不以盘符开头,例如//aaa.txt//b.txt
。
1、路径是不区分大小写
2、路径中的文件名称分隔符windows使用反斜杠,反斜杠是转义字符,两个反斜杠代表一个普通的反斜杠
1 | //绝对路径 |
判断功能的方法
1、 public boolean exists()
:此File表示的文件或目录是否实际存在。
2、 public boolean isDirectory()
:此File表示的是否为目录。
3、public boolean isFile()
:此File表示的是否为文件。
1 | public class FileIs { |
创建删除功能的方法
public boolean createNewFile()
:文件不存在,创建一个新的空文件并返回true
,文件存在,不创建文件并返回false
。public boolean delete()
:删除由此File表示的文件或目录。public boolean mkdir()
:创建由此File表示的目录。public boolean mkdirs()
:创建由此File表示的目录,包括任何必需但不存在的父目录。
其中,mkdirs()
和mkdir()
方法类似,但mkdir()
,只能创建一级目录,mkdirs()
可以创建多级目录比如//a//b//c
,所以开发中一般用mkdirs()
;
这些方法中值得注意的是createNewFile方法以及mkdir与mkdirs的区别。
1 | public class FileCreateDelete { |
注意:delete
方法,如果此File
表示目录,则目录必须为空才能删除。
目录的遍历
public String[] list()
:返回一个String数组,表示该File目录中的所有子文件或目录。public File[] listFiles()
:返回一个File数组,表示该File目录中的所有的子文件或目录。
1 | public class FileFor { |
listFiles在获取指定目录下的文件或者文件夹时必须满足下面两个条件
1、指定的目录必须存在
2、指定的必须是目录。否则容易引发返回数组为null,出现NullPointerException异常
递归遍历文件夹下所有文件以及子文件
1 | package File; |
OutputStream与InputStream的继承关系
文件的世界里一切皆为字节
我们必须明确一点的是,一切文件数据(文本、图片、视频等)在存储时,都是以二进制数字的形式保存,都一个一个的字节,那么传输时一样如此。所以,字节流可以传输任意文件数据。在操作流的时候,我们要时刻明确,无论使用什么样的流对象,底层传输的始终为二进制数据。
字节输出流(OutputStream)
java.io.OutputStream
抽象类是表示字节输出流的所有类的超类(父类),将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。
字节输出流的基本共性功能方法:
1、 public void close()
:关闭此输出流并释放与此流相关联的任何系统资源。
2、 public void flush()
:刷新此输出流并强制任何缓冲的输出字节被写出。
3、 public void write(byte[] b)
:将 b.length个字节从指定的字节数组写入此输出流。
4、 public void write(byte[] b, int off, int len)
:从指定的字节数组写入 len字节,从偏移量 off开始输出到此输出流。 也就是说从off个字节数开始读取一直到len个字节结束
5、 public abstract void write(int b)
:将指定的字节输出流。
FileOutputStream类
OutputStream
有很多子类,我们从最简单的一个子类FileOutputStream开始。看名字就知道是文件输出流,用于将数据写出到文件。
FileOutputStream构造方法
1、 public FileOutputStream(File file)
:根据File对象为参数创建对象。
2、 public FileOutputStream(String name)
: 根据名称字符串为参数创建对象。
1 | FileOutputStream outputStream = new FileOutputStream("abc.txt"); |
注意:
创建输出流对象的时候,系统会自动去对应位置创建对应文件,而创建输出流对象的时候,文件不存在则会报FileNotFoundException异常,也就是系统找不到指定的文件异常。
当你创建一个流对象时,必须直接或者间接传入一个文件路径。比如现在我们创建一个FileOutputStream
流对象,在该路径下,如果没有这个文件,会创建该文件。如果有这个文件,会清空这个文件的数据。有兴趣的童鞋可以测试一下,具体代码如下:
1 | public class FileOutputStreamConstructor throws IOException { |
1.1 FileOutputStream写出字节数据
使用FileOutputStream写出字节数据主要通过Write
方法,而write
方法分如下三种
1 | public void write(int b) |
写出字节:
write(int b)
方法,每次可以写出一个字节数据,代码如下:1
2
3
4
5
6
7
8
9
10
11
12
13
14public class IoWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 写出数据
fos.write(97); // 写出第1个字节
fos.write(98); // 写出第2个字节
fos.write(99); // 写出第3个字节
// 关闭资源
fos.close();
}
}
输出结果:
abc- 虽然参数为int类型四个字节,但是只会保留一个字节的信息写出。
- 流操作完毕后,必须释放系统资源,调用close方法,千万记得。
写出字节数组:
write(byte[] b)
,每次可以写出数组中的数据,代码使用演示:1
2
3
4
5
6
7
8
9
10
11
12
13
14public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 字符串转换为字节数组
byte[] b = "麻麻我想吃烤山药".getBytes();
// 写出字节数组数据
fos.write(b);
// 关闭资源
fos.close();
}
}
输出结果:
麻麻我想吃烤山药写出指定长度字节数组:
write(byte[] b, int off, int len)
,每次写出从off
索引开始,len
个字节,代码如下:1
2
3
4
5
6
7
8
9
10
11
12
13
14public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 字符串转换为字节数组
byte[] b = "abcde".getBytes();
// 写出从索引2开始,2个字节。索引2是c,两个字节,也就是cd。
fos.write(b,2,2);
// 关闭资源
fos.close();
}
}
输出结果:
cd
FileOutputStream实现数据追加续写、换行
经过以上的代码测试,每次程序运行,每次创建输出流对象,都会清空目标文件中的数据。如何保留目标文件中数据,还能继续追加新数据呢?并且实现换行呢?其实很简单,这个时候我们又要再学习FileOutputStream
的另外两个构造方法了,如下:
- public FileOutputStream(File file, boolean append)
- public FileOutputStream(String name, boolean append)
这两个构造方法,第二个参数中都需要传入一个boolean类型的值,true
表示追加数据,false
表示不追加也就是清空原有数据。这样创建的输出流对象,就可以指定是否追加续写了,至于Windows换行则是 \n\r
,下面将会详细讲到。
实现数据追加续写代码如下:
1 | public class FOSWrite { |
Windows系统里,换行符号是\r\n
,具体代码如下:
1 | public class FOSWrite { |
字节输入流(InputStream)
java.io.InputStream
抽象类是表示字节输入流的所有类的超类(父类),可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
字节输入流的基本共性功能方法:
1、
public void close()
:关闭此输入流并释放与此流相关联的任何系统资源。
2、public abstract int read()
: 从输入流读取数据的下一个字节。3、
public int read(byte[] b)
: 该方法返回的int值代表的是读取了多少个字节,读到几个返回几个,读取不到返回-1
FileInputStream类
java.io.FileInputStream
类是文件输入流,从文件中读取字节。
FileInputStream的构造方法
1、
FileInputStream(File file)
: 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的 File对象 file命名。
2、FileInputStream(String name)
: 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名name命名
1 | FileInputStream inputStream = new FileInputStream("a.txt"); |
当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有该文件,会抛出FileNotFoundException
。
构造举例,代码如下:
1 | public class FileInputStreamConstructor throws IOException{ |
FileInputStream读取字节数据
读取字节:
read
方法,每次可以读取一个字节的数据,提升为int类型,读取到文件末尾,返回-1
,代码测试如下【read.txt文件中内容为abcde】:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象
FileInputStream fis = new FileInputStream("read.txt");//read.txt文件中内容为abcde
// 读取数据,返回一个字节
int read = fis.read();
System.out.println((char) read);
read = fis.read();
System.out.println((char) read);
read = fis.read();
System.out.println((char) read);
read = fis.read();
System.out.println((char) read);
read = fis.read();
System.out.println((char) read);
// 读取到末尾,返回-1
read = fis.read();
System.out.println( read);
// 关闭资源
fis.close();
}
}
输出结果:
a
b
c
d
e
-1循环改进读取方式,代码使用演示:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象
FileInputStream fis = new FileInputStream("read.txt");
// 定义变量,保存数据
int b ;
// 循环读取
while ((b = fis.read())!=-1) {
System.out.println((char)b);
}
// 关闭资源
fis.close();
}
}
输出结果:
a
b
c
d
e使用字节数组读取:
read(byte[] b)
,每次读取b的长度个字节到数组中,返回读取到的有效字节个数,读取到末尾时,返回-1
,代码使用演示:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象.
FileInputStream fis = new FileInputStream("read.txt"); // read.txt文件中内容为abcde
// 定义变量,作为有效个数
int len ;
// 定义字节数组,作为装字节数据的容器
byte[] b = new byte[2];
// 循环读取
while (( len= fis.read(b))!=-1) {
// 每次读取后,把数组变成字符串打印
System.out.println(new String(b));
}
// 关闭资源
fis.close();
}
}
输出结果:
ab
cd
ed由于
read.txt
文件中内容为abcde
,而错误数据d
,是由于最后一次读取时,只读取一个字节e
,数组中,上次读取的数据没有被完全替换【注意是替换,看下图】,所以要通过len
,获取有效的字节。代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象.
FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
// 定义变量,作为有效个数
int len ;
// 定义字节数组,作为装字节数据的容器
byte[] b = new byte[2];
// 循环读取
while (( len= fis.read(b))!=-1) {
// 每次读取后,把数组的有效字节部分,变成字符串打印
System.out.println(new String(b,0,len));// len 每次读取的有效字节个数
}
// 关闭资源
fis.close();
}
}
输出结果:
ab
cd
e在开发中一般强烈推荐使用数组读取文件,代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29package io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class input2 {
public static void main(String args[]){
FileInputStream inputStream = null;
try {
inputStream = new FileInputStream("a.txt");
int len = 0 ;
byte[] bys = new byte[1024];
while ((len = inputStream.read(bys)) != -1) {
System.out.println(new String(bys,0,len));
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字节流FileInputstream复制图片
复制图片原理
代码实现
复制图片文件,代码如下:
1 | public class Copy { |
注:复制文本、图片、mp3、视频等的方式一样。
到这里,已经从File类讲到了字节流OutputStream与InputStream,而现在将主要从字符流Reader和Writer的故事开展。
字符流Reader和Writer的故事
字符流Reader和Writer的故事从它们的继承图开始,啥都不说了,直接看图。
字符流
字符流的由来:因为数据编码的不同,因而有了对字符进行高效操作的流对象,字符流本质其实就是基于字节流读取时,去查了指定的码表,而字节流直接读取数据会有乱码的问题(读中文会乱码)。
1 | package IO; |
String
构造方法有解码功能,并且默认编码是utf-8
,代码如下:
1 | this.value = StringCoding.decode(bytes, offset, length); |
尽管字节流也能有办法决绝乱码问题,但是还是比较麻烦,于是java就有了字符流,字符为单位
读写数据,字符流专门用于处理文本
文件。如果处理纯文本的数据优先考虑字符流,其他情况就只能用字节流了(图片、视频、等等只文本
例外)。
从另一角度来说:字符流 = 字节流 + 编码表
字符输入流(Reader)
java.io.Reader
抽象类是字符输入流的所有类的超类(父类),可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。
字符输入流的共性方法:
1、
public void close()
:关闭此流并释放与此流相关联的任何系统资源。
2、public int read()
: 从输入流读取一个字符。
3、public int read(char[] cbuf)
: 从输入流中读取一些字符,并将它们存储到字符数组cbuf
中
FileReader类
java.io.FileReader
类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
构造方法
1、
FileReader(File file)
: 创建一个新的 FileReader ,给定要读取的File对象。
2、FileReader(String fileName)
: 创建一个新的 FileReader ,给定要读取的文件的字符串名称。
1 | public class FileReaderConstructor throws IOException{ |
FileReader读取字符数据
读取字符:
read
方法,每次可以读取一个字符的数据,提升为int类型,读取到文件末尾,返回-1
,循环读取,代码使用演示:1
2
3
4
5
6
7
8
9
10
11
12
13
14public class FRRead {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileReader fr = new FileReader("a.txt");
// 定义变量,保存数据
int b ;
// 循环读取
while ((b = fr.read())!=-1) {
System.out.println((char)b);
}
// 关闭资源
fr.close();
}
}
字符输出流(Writer)
java.io.Writer
抽象类是字符输出流的所有类的超类(父类),将指定的字符信息写出到目的地。它同样定义了字符输出流的基本共性功能方法。
字符输出流的基本共性功能方法:
1、
void write(int c)
写入单个字符。
2、void write(char[] cbuf)
写入字符数组。
3、abstract void write(char[] cbuf, int off, int len)
写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
4、void write(String str)
写入字符串。
5、void write(String str, int off, int len)
写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
6、void flush()
刷新该流的缓冲。
7、void close()
关闭此流,但要先刷新它。
FileWriter类
java.io.FileWriter
类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
构造方法
1、 FileWriter(File file)
: 创建一个新的 FileWriter,给定要读取的File对象。
2、FileWriter(String fileName)
: 创建一个新的 FileWriter,给定要读取的文件的名称。
依旧是熟悉的构造举例,代码如下:
1 | public class FileWriterConstructor { |
FileWriter写出数据
写出字符:write(int b)
方法,每次可以写出一个字符数据,代码使用演示:
1 | public class FWWrite { |
【注意】关闭资源时,与FileOutputStream不同。 如果不关闭,数据只是保存到缓冲区,并未保存到文件。
关闭close和刷新flush
因为内置缓冲区的原因,如果不关闭输出流,无法写出字符到文件中。但是关闭的流对象,是无法继续写出数据的。如果我们既想写出数据,又想继续使用流,就需要flush
方法了。
flush
:刷新缓冲区,流对象可以继续使用。close
:先刷新缓冲区,然后通知系统释放资源。流对象不可以再被使用了。
flush还是比较有趣的,童鞋们不自己运行一下还真不好体会,现在博主就写个程序让你体会体会:
字符流
1 | public class FlushDemo { |
flush()
这个函数是清空的意思,用于清空缓冲区的数据流,进行流的操作时,数据先被读到内存中,然后再用数据写到文件中,那么当你数据读完时,我们如果这时调用close()
方法关闭读写流,这时就可能造成数据丢失,为什么呢?因为,读入数据完成时不代表写入数据完成,一部分数据可能会留在缓存区中,这个时候flush()
方法就格外重要了。
接下来close使用代码如下:
1 | public class FWWrite { |
即便是flush方法写出了数据,操作的最后还是要调用close方法,释放系统资源。
FileWriter的续写和换行
续写和换行:操作类似于FileOutputStream操作(上一篇博客讲到过),直接上代码:
1 | public class FWWrite { |
FileReader和FileWriter类完成文本文件复制
1 | import java.io.FileReader; |
最后再次强调:
字符流,只能操作文本文件,不能操作图片,视频等非文本文件。当我们单纯读或者写文本文件时 使用字符流 其他情况使用字节流
IO异常的处理
我们在学习的过程中可能习惯把异常抛出,而实际开发中并不能这样处理,建议使用try...catch...finally
代码块,处理异常部分,格式代码如下:
1 | public class HandleException1 { |
缓冲流【掌握】
缓冲流的基本原理:
1、使用了底层流对象从具体设备上获取数据,并将数据存储到缓冲区的数组内。
2、通过缓冲区的read()方法从缓冲区获取具体的字符数据,这样就提高了效率。
3、如果用read方法读取字符数据,并存储到另一个容器中,直到读取到了换行符时,将另一个容器临时存储的数据转成字符串返回,就形成了readLine()功能。
也就是说在创建流对象时,会创建一个内置的默认大小的缓冲区数组,通过缓冲区读写,减少系统IO次数,从而提高读写的效率。
缓冲书写格式为BufferedXxx
,按照数据类型分类:
- 字节缓冲流:
BufferedInputStream
,BufferedOutputStream
- 字符缓冲流:
BufferedReader
,BufferedWriter
字节缓冲流
构造方法
public BufferedInputStream(InputStream in)
:创建一个新的缓冲输入流,注意参数类型为InputStream。public BufferedOutputStream(OutputStream out)
: 创建一个新的缓冲输出流,注意参数类型为OutputStream。
构造举例代码如下:
1 | //构造方式一: 创建字节缓冲输入流【但是开发中一般常用下面的格式申明】 |
感受缓冲流的高效
缓冲流读写方法与基本的流是一致的,我们通过复制370多MB的大文件,测试它的效率。
基本流,代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23public class BufferedDemo {
public static void main(String[] args) throws FileNotFoundException {
// 记录开始时间
long start = System.currentTimeMillis();
// 创建流对象
try (
FileInputStream fis = new FileInputStream("py.exe");//exe文件够大
FileOutputStream fos = new FileOutputStream("copyPy.exe")
){
// 读写数据
int b;
while ((b = fis.read()) != -1) {
fos.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
}
}
不好意思十分钟过去了还在玩命复制中..缓冲流,代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24public class BufferedDemo {
public static void main(String[] args) throws FileNotFoundException {
// 记录开始时间
long start = System.currentTimeMillis();
// 创建流对象
try (
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("py.exe"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copyPy.exe"));
){
// 读写数据
int b;
while ((b = bis.read()) != -1) {
bos.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("缓冲流复制时间:"+(end - start)+" 毫秒");
}
}
缓冲流复制时间:8016 毫秒有的童鞋就要说了,我要更快的速度!最近看速度与激情7有点上头,能不能再快些?答案是当然可以
想要更快可以使用数组的方式,代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24public class BufferedDemo {
public static void main(String[] args) throws FileNotFoundException {
// 记录开始时间
long start = System.currentTimeMillis();
// 创建流对象
try (
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("py.exe"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copyPy.exe"));
){
// 读写数据
int len;
byte[] bytes = new byte[8*1024];
while ((len = bis.read(bytes)) != -1) {
bos.write(bytes, 0 , len);
}
} catch (IOException e) {
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("缓冲流使用数组复制时间:"+(end - start)+" 毫秒");
}
}
缓冲流使用数组复制时间:521 毫秒
字符缓冲流
构造方法
相同的来看看其构造,其格式以及原理和字节缓冲流是一样一样的!
public BufferedReader(Reader in)
:创建一个新的缓冲输入流,注意参数类型为Reader。public BufferedWriter(Writer out)
: 创建一个新的缓冲输出流,注意参数类型为Writer。
构造举例,代码如下:
1 | // 创建字符缓冲输入流 |
字符缓冲流特有方法
字符缓冲流的基本方法与普通字符流调用方式一致,这里不再阐述,我们来看字符缓冲流具备的特有方法。
- BufferedReader:
public String readLine()
: 读一行数据。 读取到最后返回null - BufferedWriter:
public void newLine()
: 换行,由系统属性定义符号。
readLine
方法演示代码如下:
1 | public class BufferedReaderDemo { |
newLine
方法演示代码如下:
1 | public class BufferedWriterDemo throws IOException { |
转换流【掌握】
编码问题导致乱码
在java开发工具IDEA中,使用FileReader
读取项目中的文本文件。由于IDEA的设置,都是默认的UTF-8
编码,所以没有任何问题。但是,当读取Windows系统中创建的文本文件时,由于Windows系统的默认是GBK编码,就会出现乱码。
1 | public class ReaderDemo { |
那么如何读取GBK编码的文件呢? 这个时候就得讲讲转换流了!
InputStreamReader类—–(字节流到字符流的桥梁)
转换流java.io.InputStreamReader
,是Reader
的子类,从字面意思可以看出它是从字节流到字符流的桥梁。它读取字节,并使用指定的字符集将其解码为字符。它的字符集可以由名称指定,也可以接受平台的默认字符集。
构造方法
InputStreamReader(InputStream in)
: 创建一个使用默认字符集的字符流。InputStreamReader(InputStream in, String charsetName)
: 创建一个指定字符集的字符流。
构造代码如下:
1 | InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt")); |
使用转换流解决编码问题
1 | public class ReaderDemo2 { |
OutputStreamWriter类—–(字符流到字节流的桥梁)
转换流java.io.OutputStreamWriter
,是Writer的子类,字面看容易混淆会误以为是转为字符流,其实不然,OutputStreamWriter为从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定,也可以接受平台的默认字符集。
构造方法
OutputStreamWriter(OutputStream in)
: 创建一个使用默认字符集的字符流。OutputStreamWriter(OutputStream in, String charsetName)
: 创建一个指定字符集的字符流。
构造举例,代码如下:
1 | OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("a.txt")); |
指定编码构造代码
1 | public class OutputDemo { |
为了达到最高效率,可以考虑在 BufferedReader
内包装 InputStreamReader
1 | BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); |
序列化流【理解】
(1)可以把对象写入文本文件或者在网络中传输
(2)如何实现序列化呢?
让被序列化的对象所属类实现序列化接口。
该接口是一个标记接口。没有功能需要实现。
(3)注意问题:
把数据写到文件后,在去修改类会产生一个问题。
如何解决该问题呢?
在类文件中,给出一个固定的序列化id值。
而且,这样也可以解决黄色警告线问题
(4)面试题:
什么时候序列化?
如何实现序列化?
什么是反序列化?
何谓序列化
Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象,该字节序列包含该对象的数据
、对象的类型
和对象中存储的属性
等信息。字节序列写出到文件之后,相当于文件中持久保存了一个对象的信息。
反之,该字节序列还可以从文件中读取回来,重构对象,对它进行反序列化。对象的数据
、对象的类型
和对象中存储的数据
信息,都可以用来在内存中创建对象。看图理解序列化:
ObjectOutputStream类
java.io.ObjectOutputStream
类,将Java对象的原始数据类型写出到文件,实现对象的持久存储。
构造方法
public ObjectOutputStream(OutputStream out)
: 创建一个指定OutputStream的ObjectOutputStream。
构造代码如下:
1 | FileOutputStream fileOut = new FileOutputStream("aa.txt"); |
序列化操作
- 一个对象要想序列化,必须满足两个条件:
该类必须实现java.io.Serializable
接口,Serializable
是一个标记接口,不实现此接口的类将不会使任何状态序列化或反序列化,会抛出NotSerializableException
。
该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的,则该属性必须注明是瞬态的,使用transient
关键字修饰。
1 | public class Employee implements java.io.Serializable { |
- 写出对象方法
public final void writeObject (Object obj)
: 将指定的对象写出。
1 | public class SerializeDemo{ |
ObjectInputStream类
ObjectInputStream反序列化流,将之前使用ObjectOutputStream序列化的原始数据恢复为对象。
构造方法
public ObjectInputStream(InputStream in)
: 创建一个指定InputStream的ObjectInputStream。
反序列化操作1
如果能找到一个对象的class文件,我们可以进行反序列化操作,调用ObjectInputStream
读取对象的方法:
public final Object readObject ()
: 读取一个对象。
1 | public class DeserializeDemo { |
对于JVM可以反序列化对象,它必须是能够找到class文件的类。如果找不到该类的class文件,则抛出一个 ClassNotFoundException
异常。
反序列化操作2
另外,当JVM反序列化对象时,能找到class文件,但是class文件在序列化对象之后发生了修改,那么反序列化操作也会失败,抛出一个InvalidClassException
异常。发生这个异常的原因如下:
1、该类的序列版本号与从流中读取的类描述符的版本号不匹配
2、该类包含未知数据类型
2、该类没有可访问的无参数构造方法
Serializable
接口给需要序列化的类,提供了一个序列版本号。serialVersionUID
该版本号的目的在于验证序列化的对象和对应类是否版本匹配。
1 | public class Employee implements java.io.Serializable { |
打印流【掌握】
何谓打印流
平时我们在控制台打印输出,是调用print
方法和println
方法完成的,各位用了这么久的输出语句肯定没想过这两个方法都来自于java.io.PrintStream
类吧,哈哈。该类能够方便地打印各种数据类型的值,是一种便捷的输出方式。
打印流分类:
字节打印流PrintStream,字符打印流PrintWriter
打印流特点:
A:只操作目的地,不操作数据源
B:可以操作任意类型的数据
C:如果启用了自动刷新,在调用println()方法的时候,能够换行并刷新
D:可以直接操作文件
这个时候有同学就要问了,哪些流可以直接操作文件呢?答案很简单,如果该流的构造方法能够同时接收File和String类型的参数,一般都是可以直接操作文件的!
PrintStream是OutputStream的子类,PrintWriter是Writer的子类,两者处于对等的位置上,所以它们的API是非常相似的。二者区别无非一个是字节打印流,一个是字符打印流。
字节输出打印流PrintStream复制文本文件
1 | import java.io.BufferedReader; |
字符输出打印流PrintWriter复制文本文件
1 | import java.io.BufferedReader; |
Properties属性类
我想各位对这个Properties类多多少少也接触过了,首先Properties类并不在IO包下,那为啥要和IO流一起讲呢?原因很简单因为properties类经常和io流的联合一起使用。
(1)是一个集合类,Hashtable的子类
(2)特有功能
A:public Object setProperty(String key,String value)
B:public String getProperty(String key)
C:public Set stringPropertyNames()
(3)和IO流结合的方法
把键值对形式的文本文件内容加载到集合中
public void load(Reader reader)
public void load(InputStream inStream)
把集合中的数据存储到文本文件中
public void store(Writer writer,String comments)
public void store(OutputStream out,String comments)
Properties概述
java.util.Properties
继承于Hashtable
,来表示一个持久的属性集。它使用键值结构存储数据,每个键及其对应值都是一个字符串。该类也被许多Java类使用,比如获取系统属性时,System.getProperties
方法就是返回一个Properties
对象。
Properties类
构造方法
public Properties()
:创建一个空的属性列表。
基本的存储方法
public Object setProperty(String key, String value)
: 保存一对属性。public String getProperty(String key)
:使用此属性列表中指定的键搜索属性值。public Set<String> stringPropertyNames()
:所有键的名称的集合。
1 | public class ProDemo { |
与流相关的方法
public void load(InputStream inStream)
: 从字节输入流中读取键值对。
参数中使用了字节输入流,通过流对象,可以关联到某文件上,这样就能够加载文本中的数据了。现在文本数据格式如下:
1 | filename=Properties.txt |
加载代码演示:
1 | public class ProDemo { |
文本中的数据,必须是键值对形式,可以使用空格、等号、冒号等符号分隔。
后记
整理与转载自: