JavaIO基本概念
本文内容纲要：
JavaIO基本概念
JavaIO：即Java输入/输出系统。
区分Java的输入和输出：把自己当成程序，当你从外边读数据到自己这里就用输入（InputStream/Reader），向外边写数据就用输出（OutputStream/Writer）。
Stream：Java中将数据的输入输出抽象为流，流是一组有顺序的，单向的，有起点和终点的数据集合，就像水流。按照流中的最小数据单元又分为字节流和字符流。
1，字节流：以8位（即1byte，8bit）作为一个数据单元，数据流中最小的数据单元是字节。
2，字符流：以16位（即1char，2byte，16bit）作为一个数据单元，数据流中最小的数据单元是字符，Java中的字符是Unicode编码，一个字符占用两个字节。
IO的分类
流式部分和非流式部分
Java的IO主要包含两个部分：
1.流式部分：是IO的主体部分，也是本文介绍的重点，流式部分根据流向分为输入流（InputStream/Reader）和输出流（OutputStream/Writer），根据数据不同的操作单元，分为字节流（InputStream/OutputStream）和字符流（Reader/Writer），依据字节流和字符流，Java定义了用来操作数据的抽象基类InputStream/OutputStream和Reader/Writer，再根据不同应用场景（或功能），在这两种抽象基类上基于数据载体或功能派上出很多子类，用来满足文件，网络，管道等不同场景的IO需求，从而形成了Java的基本IO体系。
下面是JavaIO体系中常用的流类：
2.非流式部分：主要包含一些辅助流式部分的类，如：SerializablePermission类、File类、RandomAccessFile类和FileDescriptor等；
节点流和处理流
Javaio分类方式有很多，根据是否直接处理数据，Javaio又分为节点流和处理流，节点流是真正直接处理数据的；处理流是装饰加工节点流的。
节点流
- 文件流：FileInputStream，FileOutputStrean，FileReader，FileWriter，它们都会直接操作文件，直接与OS底层交互。因此他们被称为节点流，注意：使用这几个流的对象之后，需要关闭流对象，因为java垃圾回收器不会主动回收。不过在Java7之后，可以在try()括号中打开流，最后程序会自动关闭流对象，不再需要显示地close。
- 数组流：ByteArrayInputStream，ByteArrayOutputStream，CharArrayReader，CharArrayWriter，对数组进行处理的节点流。
- 字符串流：StringReader，StringWriter，其中StringReader能从String中读取数据并保存到char数组。
- 管道流：PipedInputStream，PipedOutputStream，PipedReader，PipedWrite，对管道进行处理的节点流。
处理流
处理流是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader。
处理流的构造方法总是要带一个其他的流对象做参数。
常用处理流（通过关闭处理流里面的节点流来关闭处理流）
- 缓冲流：BufferedImputStrean，BufferedOutputStream，BufferedReader，BufferedWriter，需要父类作为参数构造，增加缓冲功能，避免频繁读写硬盘，可以初始化缓冲数据的大小，由于带了缓冲功能，所以就写数据的时候需要使用flush方法，另外，BufferedReader提供一个readLine()方法可以读取一行，而FileInputStream和FileReader只能读取一个字节或者一个字符，因此BufferedReader也被称为行读取器。
- 转换流：InputStreamReader，OutputStreamWriter，要inputStream或OutputStream作为参数，实现从字节流到字符流的转换，我们经常在读取键盘输入（System.in）或网络通信的时候，需要使用这两个类。
- 数据流：DataInputStream，DataOutputStream，提供将基础数据类型写入到文件中，或者读取出来。
字节流
字节输入流
下面是IO中输入字节流的继承关系。
InputStream
- ByteArrayInputStream
- FileInputStream
- FilterInputStream
- PushbackInputStream
- DataInputStream
- BufferedInputStream
- LineNumberInputStream
- ObjectInputStream
- PipedInputStream
- SequenceInputStream
- StringBufferInputStream
总结：
- InputStream是所有的输入字节流的父类，它是一个抽象类。
- PushbackInputStream、DataInputStream和BufferedInputStream都是处理流，他们的的父类是FilterInputStream。
- ByteArrayInputStream、StringBufferInputStream、FileInputStream是三种基本的介质流，它们分别从Byte数组、StringBuffer、和本地文件中读取数据。PipedInputStream是从与其它线程共用的管道中读取数据。
InputStream中的三个基本的读方法
- abstractintread()：读取一个字节数据，并返回读到的数据，如果返回-1，表示读到了输入流的末尾。
- intread(byte[]b)：将数据读入一个字节数组，同时返回实际读取的字节数。如果返回-1，表示读到了输入流的末尾。
- intread(byte[]b,intoff,intlen)：将数据读入一个字节数组，同时返回实际读取的字节数。如果返回-1，表示读到了输入流的末尾。off指定在数组b中存放数据的起始偏移位置；len指定读取的最大字节数。
字节输出流
下面是IO中输出字节流的继承关系。
OutputStream
- ByteArrayOutputStream
- FileOutputStream
- FilterOutputStream
- BufferedOutputStream
- DataOutputStream
- PrintStream
- ObjectOutputStream
- PipedOutputStream
总结：
- OutputStream是所有的输出字节流的父类，它是一个抽象类。
- ByteArrayOutputStream、FileOutputStream是两种基本的介质流，它们分别向Byte数组、和本地文件中写入数据。
- PipedOutputStream是向与其它线程共用的管道中写入数据。
- BufferedOutputStream、DataOutputStream和PrintStream都是处理流，他们的的父类是FilterOutputStream。
outputStream中的三个基本的写方法
- abstractvoidwrite(intb)：往输出流中写入一个字节。
- voidwrite(byte[]b)：往输出流中写入数组b中的所有字节。
- voidwrite(byte[]b,int?off,int?len)：往输出流中写入数组b中从偏移量off开始的len个字节的数据。
其它重要方法：
- voidflush()：刷新输出流，强制缓冲区中的输出字节被写出。
- voidclose()：关闭输出流，释放和这个流相关的系统资源。
字节流的输入与输出的对应
javaio的输入和输出是高度对应的，下图表示字节流的输入与输出的对应关系。
上图中蓝色的为主要的对应部分，红色的部分是不对应部分。紫色的虚线部分代表这些流一般要搭配使用。
我们主要看看这些字节流中不对称的几个类：
- PushbackInputStream为另一个输入流添加性能，即“推回（pushback）”或“取消读取（unread）”一个字节的能力。
- SequenceInputStream可以认为是一个工具类，将两个或者多个输入流当成一个输入流依次读取。完全可以从IO包中去除，还完全不影响IO包的结构。
- PrintStream也可以认为是一个辅助工具。主要可以向其他输出流，或者FileInputStream写入数据，本身内部实现还是带缓冲的。本质上是对其它流的综合运用的一个工具而已。一样可以从IO包中去除！System.io和System.out就是PrintStream的实例！
- StringBufferInputStream和StringBufferInputStream已经过时，还允许它存在只是为了保持版本的向下兼容而已。
搭配使用的三对类：ObjectInputStream/ObjectOutputStream和DataInputStream/DataOutputStream主要是要求写对象/数据和读对象/数据的次序要保持一致，否则可能不能得到正确的数据，甚至抛出异常（一般会如此）；PipedInputStream/PipedOutputStream在创建时一般就一起创建，调用它们的读写方法时会检查对方是否存在，或者关闭！
字符流
字符输入流Reader
下面是IO中输入字符流的继承关系。
Reader
- BufferedReader
- LineNumberReader
- CharArrayReader
- FilterReader
- PushbackReader
- InputStreamReader
- FileReader
- PipedReader
- StringReader
总结：
- Reader是所有的输入字符流的父类，它是一个抽象类。
- CharReader、StringReader是两种基本的介质流，它们分别将Char数组、String中读取数据。PipedReader是从与其它线程共用的管道中读取数据。
- BufferedReader很明显就是一个装饰器，它和其子类负责装饰其它Reader对象。
- FilterReader是所有自定义具体装饰流的父类，其子类PushbackReader对Reader对象进行装饰，会增加一个行号。
- InputStreamReader是一个连接字节流和字符流的桥梁，它将字节流转变为字符流。
Reader基本的三个读方法（和字节流对应）：
(1)publicintread()throwsIOException;读取一个字符，返回值为读取的字符。
(2)publicintread(charcbuf[])throwsIOException;读取一系列字符到数组cbuf[]中，返回值为实际读取的字符的数量。
(3)publicabstractintread(charcbuf[],intoff,intlen)throwsIOException;读取len个字符，从数组cbuf[]的下标off处开始存放，返回值为实际读取的字符数量，该方法必须由子类实现。
字符输出流Writer
下面是IO中输出字符流的继承关系。
Writer
- BufferedWriter
- CharArrayWriter
- FilterWriter
- OutputStreamWriter
- FileWriter
- PipedWriter
- PrintWriter
- StringWriter
总结（和字节输出流对应）：
- Writer是所有的输出字符流的父类，它是一个抽象类。
- CharArrayWriter、StringWriter是两种基本的介质流，它们分别向Char数组、String中写入数据。PipedWriter是向与其它线程共用的管道中写入数据。
- BufferedWriter是一个装饰器为Writer提供缓冲功能。
- PrintWriter和PrintStream极其类似，功能和使用也非常相似。
- OutputStreamWriter是OutputStream到Writer转换的桥梁，它的子类FileWriter其实就是一个实现此功能的具体类。
writer的主要写方法：
- publicvoidwrite(intc)throwsIOException；//写单个字符
- publicvoidwrite(charcbuf[])throwsIOException；//将字符数组cbuf[]写到输出流。
- publicabstractvoidwrite(charcbuf[],intoff,intlen)throwsIOException；//将字符数组cbuf[]中的从索引为off的位置处开始的len个字符写入输出流。
- publicvoidwrite(Stringstr)throwsIOException；//将字符串str中的字符写入输出流。
- publicvoidwrite(Stringstr,intoff,intlen)throwsIOException；//将字符串str中从索引off开始处的len个字符写入输出流。
字符流的输入与输出的对应
可参照（字节流的输入与输出的对应）记忆
JavaIO常见用法
1、读取键盘输入，打印到控制台在刷题网站刷算法题的时候，在程序开头都需要和键盘进行交互，常常用到行夺取器BufferedReader和转换流InputStreamReader。
publicstaticvoidkeyInAndPrintConsole()throwsIOException{
PrintWriterout=null;
BufferedReaderbr=null;
try{
System.out.println("请输入:");
out=newPrintWriter(System.out,true);
br=newBufferedReader(newInputStreamReader(System.in));
Stringline=null;
while((line=br.readLine())!=null){
if(line.equals("exit")){
System.exit(1);
}
out.println(line);
}
}catch(IOExceptione){
e.printStackTrace();
}finally{
out.close();
br.close();
}
}
运行结果：
2、用字节流读写文件
因为是用字节流来读媒介，所以对应的流是InputStream和OutputStream，并且媒介对象是文件，所以用到子类是FileInputStream和FileOutputStream，这里还可以通过BufferedInputStream用缓冲流来读取文件。
publicstaticvoidreadAndWriteByteToFile()throwsIOException{
InputStreamis=null;
OutputStreamos=null;
try{
//在try()中打开文件会在结尾自动关闭
is=newFileInputStream("D:/FileInputStreamTest.txt");
os=newFileOutputStream("D:/FileOutputStreamTest.txt");
byte[]buf=newbyte[4];
inthasRead=0;
while((hasRead=is.read(buf))>0){
os.write(buf,0,hasRead);
}
System.out.println("writesuccess");
}catch(Exceptione){
e.printStackTrace();
}finally{
os.close();
is.close();
}
}
运行结果:
3、用字符流进行读写操作
（1）FileReader和FileWriter
//在try()中打开的文件，JVM会自动关闭
publicstaticvoidreadAndWriteCharToFile()throwsIOException{
Readerreader=null;
Writerwriter=null;
try{
FilereadFile=newFile("d:/FileInputStreamTest.txt");
reader=newFileReader(readFile);
FilewriteFile=newFile("d:/FileOutputStreamTest.txt");
writer=newFileWriter(writeFile);
char[]byteArray=newchar[(int)readFile.length()];
intsize=reader.read(byteArray);
System.out.println("大小:"+size+"个字符;内容:"+newString(byteArray));
writer.write(byteArray);
}catch(Exceptione){
e.printStackTrace();
}finally{
reader.close();
writer.close();
}
}
运行结果:
（2）StringReader和StringWriter
publicstaticvoidstringNode()throwsIOException{
StringReadersr=null;
StringWritersw=null;
try{
Stringstr="学习不刻苦
"+"不如卖红薯;
";
char[]buf=newchar[32];
inthasRead=0;
//StringReader将以String字符串为节点读取数据
sr=newStringReader(str);
while((hasRead=sr.read(buf))>0){
System.out.print(newString(buf,0,hasRead));
}
//由于String是一个不可变类，因此创建StringWriter时，实际上是以一个StringBuffer作为输出节点
sw=newStringWriter();
sw.write("黑夜给了我黑色的眼睛
");
sw.write("我却用它寻找光明
");
//toString()返回sw节点内的数据
System.out.println(sw.toString());
}catch(Exceptione){
e.printStackTrace();
}finally{
sw.close();
sr.close();
}
}
运行结果：
4、字节流转换为字符流
在例3中用字符流读文件时，打印到控制台的中文会乱码，使用转换流可以解决这一问题。
publicstaticvoidconvertByteToChar()throwsIOException{
InputStreamis=null;
Readerreader=null;
try{
Filefile=newFile("d:/FileInputStreamTest.txt");
is=newFileInputStream(file);
reader=newInputStreamReader(is,"gbk");
char[]byteArray=newchar[(int)file.length()];
intsize=reader.read(byteArray);
System.out.println("大小:"+size+";内容:"+newString(byteArray));
}catch(Exceptione){
e.printStackTrace();
}finally{
reader.close();
is.close();
}
}
运行结果:
5、随机读写文件使用RandomAccessFile可以实现对文件的随机读取，主要是通过seek（）方法实现指针偏移。
publicstaticvoidrandomAccessFileReadAndWrite()throwsIOException{
RandomAccessFilerandomAccessFile=null;
try{
//创建一个RandomAccessFile对象
randomAccessFile=newRandomAccessFile("d:/File.txt","rw");
//通过seek方法来移动指针
randomAccessFile.seek(10);
//获取当前指针
longpointerBegin=randomAccessFile.getFilePointer();
//从当前指针开始读
byte[]contents=newbyte[10];
randomAccessFile.read(contents);
longpointerEnd=randomAccessFile.getFilePointer();
System.out.println("pointerBegin:"+pointerBegin+"
"+"pointerEnd:"+pointerEnd+"
"+newString(contents));
randomAccessFile.seek(20);
//获取当前指针
longbegin=randomAccessFile.getFilePointer();
randomAccessFile.write(contents);
longend=randomAccessFile.getFilePointer();
System.out.println("begin:"+begin+"
"+"end:"+end+"
");
}catch(Exceptione){
e.printStackTrace();
}finally{
randomAccessFile.close();
}
}
运行结果:
操作前文件内容如下图：
操作后控制台打印信息：
操作后的文件内容：
6、读写管道
管道流要成对使用
publicstaticvoidpiped()throwsIOException{
finalPipedOutputStreamoutput=newPipedOutputStream();
finalPipedInputStreaminput=newPipedInputStream(output);
Threadthread1=newThread(newRunnable(){
@Override
publicvoidrun(){
try{
output.write("Helloworld,pipe!".getBytes());
}catch(IOExceptione){
}
}
});
Threadthread2=newThread(newRunnable(){
@Override
publicvoidrun(){
try{
intdata=input.read();
while(data!=-1){
System.out.print((char)data);
data=input.read();
}
}catch(IOExceptione){
}finally{
try{
input.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}
});
thread1.start();
thread2.start();
}
运行结果:
7、将多个输入流当成一个输入流依次读取
publicstaticvoidsequeue()throwsIOException{
FileInputStreamfistream1=null;
FileInputStreamfistream2=null;
SequenceInputStreamsistream=null;
FileOutputStreamfostream=null;
try{
fistream1=newFileInputStream("d:/A.txt");
fistream2=newFileInputStream("d:/B.txt");
sistream=newSequenceInputStream(fistream1,fistream2);
fostream=newFileOutputStream("d:/C.txt");
inttemp;
while((temp=sistream.read())!=-1){
System.out.print((char)temp);
fostream.write(temp);
}
}catch(Exceptione){
e.printStackTrace();
}finally{
fostream.close();
sistream.close();
fistream1.close();
fistream2.close();
}
}
运行结果:
8、推回输入流使用实例
publicstaticvoidpushback()throwsFileNotFoundException,IOException{
try(PushbackReaderpr=newPushbackReader(newFileReader("D:/A.txt"),64)){
char[]buf=newchar[32];
StringlastContent="";
inthasRead=0;
while((hasRead=pr.read(buf))>0){
Stringcontent=newString(buf,0,hasRead);
inttargetIndex=0;
if((targetIndex=(lastContent+content).indexOf("A"))>0){
System.out.println(targetIndex);
pr.unread((lastContent+content).toCharArray());
if(targetIndex>32){
buf=newchar[targetIndex];
}
pr.read(buf,0,targetIndex);
System.out.println(newString(buf,0,targetIndex));
System.out.println(newString(buf,targetIndex,buf.length-targetIndex));
System.exit(0);
}else{
System.out.println(lastContent);
lastContent=content;
}
}
}catch(IOExceptione){
e.printStackTrace();
}
}
运行结果:
JavaIO常见面试题
1、字节流和字符流的区别？
（1）读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
（2）处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
（3）字节流没有缓冲区，是直接输出的，而字符流是输出到缓冲区的。因此在输出时，字节流不调用colse()方法时，信息已经输出了，而字符流只有在调用close()方法关闭缓冲区时，信息才输出。要想字符流在未关闭时输出信息，则需要手动调用flush()方法。
2、什么是节点流，什么是处理流,它们各有什么用处，处理流的创建有什么特征？
见上文：节点流和处理流；
注意：处理流的构造器必须要传入节点流的子类
3、什么叫对象序列化，什么是反序列化，实现对象序列化需要做哪些工作？
- 对象序列化：将对象以二进制的形式保存在硬盘上；
- 反序列化：将二进制的文件转化为对象读取；
- 实现serializable接口可以实现对象序列化，其中没有需要实现的方法，implementsSerializable只是为了标注该对象是可被序列化的。
例如，在web开发中，如果对象被保存在了Session中，tomcat在重启时要把Session对象序列化到硬盘，这个对象就必须实现Serializable接口。如果对象要经过分布式系统进行网络传输，被传输的对象就必须实现Serializable接口。
4、什么是Filter流有哪些？
FilterStream是一种IO流，主要作用是用来对存在的流增加一些额外的功能，像给目标文件增加源文件中不存在的行数，或者增加拷贝的性能等。在java.io包中主要由4个可用的filterStream。两个字节filterstream，两个字符filterstream.
分别是：FilterInputStream，FilterOutputStream，FilterReaderandFilterWriter.这些类是抽象类，不能被实例化的。
FilterInputStream流的子类：
- DataInputStream可以把包括基本类型在内的数据和字符串按顺序从数据源读入，它有一些特殊的方法如readInt()，readDouble()和readLine()等可以读取一个int，double和一个string。
- BufferedInputStream增加性能。
- PushbackInputStream推送要求的字节到系统中。
- 注：其它子类见Javaio分类图。
6、说说RandomAccessFile?
它在java.io包中是一个特殊的类，既不是输入流也不是输出流，它两者都可以做到。他是Object的直接子类。通常来说，一个流只有一个功能，要么读，要么写。但是RandomAccessFile既可以读文件，也可以写文件。
而且RandomAccessFile支持对文件的随机访问，实例可见上文：例5，随机读写文件。
总结
很多初学者刚刚学习java的IO时会比较茫然，确实IO类很多，不容易记忆，不过我们可以尝试对其进行总结记忆，把流式部分概括为：两对应一桥梁一随机。
两个对应指：
- 字节流（ByteStream）和字符流（CharStream）的对应；
- 输入和输出的对应。
- 一个桥梁指：从字节流到字符流的桥梁。对应于输入和输出为InputStreamReader和OutputStreamWriter；
- 一个随机是：RandomAccessFile。可以随机读取文件。
总结记忆会使Javaio清晰好记许多，大家也可以尝试按照自己的方式进行总结，印象会更加深
本文内容总结：
原文链接：https://www.cnblogs.com/CQqf/p/10795656.html