IO流系统总结文档格式.docx
《IO流系统总结文档格式.docx》由会员分享，可在线阅读，更多相关《IO流系统总结文档格式.docx（20页珍藏版）》请在冰豆网上搜索。
后期编码表的不断出现，识别某一文字的码表不唯一。
比如中文，GBK&
unicode都可以识别，就出现了编码问题，为了处理文字数据，就需要通过早期的字节流+编码表结合完成。
作用：
为了更便于操作文字数据。
结论：
只要是处理纯文本数据，就要优先考虑使用字符流，除此之外都是用字节流。
2、IO分类
按照功能进行分类---------->
读和写
IO体系中的子类名称后缀大部分都是父类名称，而前缀都是体现子类功能的名字
3、字符流继承体系图
4、Reader中的常见方法
✓intread（）：
读取一个字符。
返回的是读到的那个字符（0-65535），如果读到流的末尾，返回-1
✓intread（char[]）：
将读到的字符存入指定的数组中，返回的是读到的字符个数，也就是往数组里装元素的个数，如果读到流的末尾，返回-1。
✓close（）：
读取字符用的是windows系统的功能，就希望使用完毕后，进行资源的释放。
5、Writer中的常见方法
✓voidwrite（ch）：
将一个字符写入到流中。
✓voidwrite（char[]）：
将一个字符数组写入到流中。
✓voidwrite（String）：
将一个字符串写入到流中。
✓voidflush（）：
刷新流，将流中的数据刷新到目的地中，流还存在。
✓voidclose（）：
关闭资源，在关闭前会先调用flush（），刷新流中的数据去目的地，然后关闭流。
6、FileWriter
该类没有特有的方法，只有自己的构造方法。
特点：
●用于处理文本文件；
●该类中有默认的编码表；
●该类中有临时缓冲。
构造方法：
在写入流对象初始化时，必须有一个存储数据的目的地。
◆FileWriter（Stringfilename）：
该构造函数做了什么事情呢？
A：
调用系统资源；
B：
在指定位置创建一个文件，如果该文件已经存在，将会被覆盖。
◆FileWriter（Stringfilename,booleantrue）：
该构造函数如果传入的boolean类型值为true时，会在指定文件末尾处进行数据的续写。
◆换行：
privatestaticfinalStringLINE_SEPARATOR=System.getProperties（"
line.separator"
）;
fr.writer（"
xi"
+LINE_SEPARATOR+"
7、FileReader
用于读取文本文件的流对象，用于关联文本文件。
构造函数：
在读取流对象初始化的时候，必须要指定一个被读取的文件，如果该文件不存在会发生FileNotFindException
FileReaderfr=newFileReader（Stringfilename）
基本的读写操作方式
因为数据通常都以文件的形式存在，所以就要找到IO体系中可以用于操作文件的流对象，通过名称可以更容易获取该对象。
8、将文本数据存储到一个文件中。
importjava.io.FileWriter;
importjava.io.IOException;
publicclassDemo1{
publicstaticvoidmain（String[]args）throwsIOException{
FileWriterfw=newFileWriter（"
E:
\\1.txt"
fw.write（"
abcd"
fw.flush（）;
//数据刷到目的地了，流还可以继续使用
mn"
fw.close（）;
//数据也刷到目的地了，但是流不能再被使用
}
文件中写入的数据：
abcdmn意外收获：
异常包也得导入。
对于读取或者写入流对象的构造函数，以及读写方法，还有刷新关闭功能都会抛出IOException或其子类。
所以要进行处理，要么抛出throws，要么try……catch处理。
9、完整的异常处理方式。
publicclassDemo2{
publicstaticvoidmain（String[]args）{
FileWriterfw=null;
//定义为全局，关闭的时候也要使用
try{
fw=newFileWriter（"
}catch（IOExceptione）{
e.printStackTrace（）;
}finally{
if（fw!
=null）{//防止空指针异常----->
运行时异常要做健壮性判断
thrownewRuntimeException（"
关闭异常"
小细节：
当指定绝对路径时，定义目录分隔符有两种方式：
1，反斜线，但是一定要写两个。
newFileWriter（"
c:
2，斜线，一个即可。
/1.txt"
10、读取字符流对象的两种方式
读取一个已有的文本文件，将文本数据打印出来。
方式一：
一次读取一个字符
importjava.io.FileReader;
publicclassDemo3{
FileReaderfr=null;
//1，创建一个文件读取流对象，和指定名称的文件相关联，要保证该文件是已经存在的。
如果不存在，会发生异常。
FileNotFoundException
fr=newFileReader（"
e:
//2,定义一个变量，用于记录读到的那个字符对应的二进制数值。
char在0-65535之间，不存在就-1。
intch=0;
//3,用循环读取文件中的数据
while（（ch=fr.read（））!
=-1）{
System.out.print（（char）ch）;
}catch（Exceptione）{
}finally{
if（fr!
=null）{
fr.close（）;
方式二：
将读取的字符放入一个字符数组中<
较第一种效率要高得多>
publicclassDemo4{
FileReaderfr=null;
//1,创建一个文件读取流对象，和指定名称的文件相关联，要保证该文件是已经存在的。
//2,定义一个字符数组，用于存储读到的字符。
char[]ch=newchar[1024];
//长度通常是1024的整数倍
//3,定义一个变量，用于记录读取字符的个数，读到末尾返回-1。
intlen=0;
//4,把读到的字符暂时存到buf数组中，该read（char[]）返回的是读到字符的个数。
while（（len=fr.read（ch））!
=-1）{
System.out.print（newString（ch,0,len））;
}//将字符数组转换成字符串输出
if（fr!
=null）{
11、复制文本文件的原理
首先用一个读取流对象和一个文件进行关联，然后用一个写入流对象作为目地的，为了把读取流中的文件传输到目的地流对象中，我们就提供了一个字符数组，为了关联这个数组，所以读取流对象有一个read（）方法与这个字符数组进行关联，同理，写入流对象也有一个write（）方法与这个字符数组进行关联，这样2个流对象就相连接了，而这个字符数组就相当于一个中转站
将e盘的文件复制到i盘中
publicclassCopyFileTest{
Filestartfile=newFile（"
\\a.txt"
Fileendfile=newFile（"
i:
\\hello.txt"
copyFile（startfile,endfile）;
publicstaticvoidcopyFile（Filestartfile,Fileendfile）{
//1,创建一个字符读取流读取与源数据相关联。
fr=newFileReader（startfile）;
//2,创建一个存储数据的目的地。
fw=newFileWriter（endfile）;
//3,创建一个字符数组将读取流对象和写入流对象相连接。
char[]buf=newchar[1024];
//4,每次读取的长度不一样，所以定义一个变量.
//5,用循环读取文件中的数据
while（（len=fr.read（buf））!
=-1）{//判断是否读取完没
fw.write（buf,0,len）;
//为了只写入有效的数据
}catch（Exceptione2）{
读取流关闭失败"
if（fw!
写入流关闭失败"
声明：
为了减少代码的书写，以后出现的异常全使用抛出！
三、字符流缓冲区
1、字符缓冲区的原理
其实就是将数组进行封装。
变成对象后，方便于对缓冲区的操作，提高效率。
并提供了对文本便捷操作的方法。
readLine（）&
newLine（）。
缓冲区的基本思想就是对要处理的数据进行临时存储。
譬如购物车以及篮子。
原理：
减少频繁的操作，给读取流对象和写入流对象提供中转站，相对于来回跑的麻烦，利用缓冲区的容量，可以一边先存储，满了后再写入的方式，这样就提高了效率。
BufferedWriter的特有方法：
newLine（）:
跨平台的换行符。
BufferedReader的特有方法：
readLine（）：
一次读一行，到行标记时，将行标记之前的字符数据作为字符串返回。
当读到末尾时，返回null。
（返回的字符是不带回车符的）
在使用缓冲区对象时，要明确，缓冲的存在是为了增强流的功能而存在的，所以在建立缓冲区对象时，要先有流对象存在。
其实缓冲内部就是在使用流对象的方法，只不过加入了数组对数据进行了临时存储，为了提高操作数据的效率。
2、代码上的体现
写入缓冲区对象-------->
带缓冲区的写操作，一般都要进行刷新！
建立缓冲区对象必须把流对象作为参数传递给缓冲区的构造函数。
BufferedWriterbw=newBufferedWriter（newFileWriter（"
a.txt"
））;
bw.write（"
//将数据写入缓冲区
bw.flush（）;
//对缓冲区的数据进行刷新，将数据刷到目的地中
bw.close（）;
//关闭缓冲区，其实关闭的是被包装在内部的流对象。
读取缓冲区对象
BufferedReaderbr=newBufferedReader（newFileReader（"
b.txt"
Stringline=null;
while（（line=br.readLine）!
System.out.println（line）;
br.chose（）;
3、readLine（）方法的原理
其实缓冲区中的该方法，用的还是与缓冲区关联的流对象的read方法，只不过，每一次读到一个字符，先不进行具体操作，而是进行临时存储。
当读到回车标记时，将临时容器中的数据一次性返回。
----->
StringBuilder调用了buff.read（）将缓冲区中的数据存储到了该容器中。
◆缓冲区的read（）和流对象的read（）方法的区别？
流对象：
从目的地一次读取一个字符
缓冲区：
通过流对象的read（[]）将一批数据读取到缓冲数组，然后在数组中一次取一个字符，内存比硬盘操作要高效。
4、自定义缓冲区MyBufferedReader
/*
*模拟一个缓冲区
*基于已有的缓冲区思想，我们可以从源读取用read方法。
*我们的缓冲区，应该是一个更高效的read读取方法。
*/
publicclassMyBufferedReaderextendsReader{
privateReaderr;
privatechar[]buf=newchar[1024];
//用于记录缓冲区数据的个数
privateintcount=0,pos=0;
publicMyBufferedReader（Readerr）{
this.r=r;
/**
*一次从缓冲区中取一个
*@return返回一个缓冲区中的字符
*@throwsIOException
publicintmyRead（）throwsIOException{
//1,首先判断缓冲区中是否有数据，如果没有就从源中去拿。
if（count==0）{
//读取一批数据到缓冲数组buf中
count=r.read（buf）;
pos=0;
//2,当缓冲区中没数据了且源中也没有数据时，count自减1小于0时就返回-1结束.
if（count<
0）
return-1;
//3,如果以上都不满足，那么从缓冲区中写入一个字符到新的文件中。
charch=buf[pos];
pos++;
count--;
returnch;
*按照文本特点，提供一个特有的操作文本的方法。
*一次读取一行文本，只要是到行结束符之前的文本即可。
*@return返回读取到的一行文本
*@throwsIOException
*原理：
就是从缓冲区中取出数据，并存储到一个临时容器中。
*如果取到了回车符，就将临时容器中的数据转成字符串返回。
publicStringmyReadLine（）throwsIOException{
//1,定义一个临时容器，进行临时存储
StringBuildersb=newStringBuilder（）;
//2,定义一个变量，接收读取到的字符对应的二进制数（ASCII）,0-65535
intch=0;
while（（ch=myRead（））!
=-1）{
//3,当读取到\r时，直接跳出本次循环，进行下次循环
if（ch=='
\r'
）
continue;
//4,当读取到\n时，直接跳出当前循环
\n'
returnsb.toString（）;
//5,当都没有读取到时，就将这些数据存储到临时容器中。
sb.append（（char）ch）;
//6,当临时容器中的长度不等于0时，就输出字符。
if（sb.length（）!
=0）
returnnull;
@Override
publicvoidclose（）throwsIOException{
publicintread（char[]arg0,intarg1,intarg2）throwsIOException{
return0;
5、通过缓冲区的形式，对文本文件进行拷贝
publicclassBufferCopyTest{
\\copy.txt"
while（（line=br.readLine（））!
=null）{//高效读操作
bw.write（line）;
//高效写
bw.newLine（）;
//换行符
br.close（）;
装潢设计类
装饰设计模式。
解决问题：
给已有的对象提供增强额外的功能。
还不用对原有对象进行修改。
比继承更为灵活。
|--TestWriter
|--MediaWriter
现有一个体系用于各种数据的写入。
但是，防线写入效率有点低。
想要对其进行效率的提高。
可以使用缓冲技术来完成的。
以后对象的写入方法，不够高效，可以通过派生子类的形式对齐进行复写，定义高效的写入动作。
|--BufferTextWriter
|--BufferMediaWriter
通过继承的方式提高了效率。
但是对于扩展性是一个问题。
而且所需的功能越多，子类就越多。
一旦加入新类，就需要为它提供高效。
麻烦！
如何解决这个问题呢?
优化！
既然都需要缓冲，对数据写入的效率进行提高。
可以转变一下思想，这样来做，将缓冲技术单独进行封装。
哪个对象需要缓冲，就把哪个对象传递给缓冲对象即可。
ClassBuffer{
Buffer（TestWriterw）{
Buffer（MediaWriterw）{
为了便于扩展，可以对一组对象进行缓冲。
ClassBufferWriterextendsWriter{
Buffer（Writerw）{
Publicvoidwrite（）{
体系就变成了这样：
|--TextWriter
|--BufferWriter
BufferWriter的出现，增强了Writer体系中的功能。
这种设计方式比原来更为灵活，避免了继承的臃肿。
将这样解决方式就定义了一个名称方便于后人使用：
记住：
装饰类和被装饰类都
打印流：
PrintWriter和PrintStream{可以直接操作输入流和文件。
PrintStream：
{打印流}
1：
使它们能够方便地打印各种数据值表示形式。
2：
提供了一系列的打印功能，可以打印任何数据。
3：
它的特有方法不会抛出异常。
常见的一些方法：
该流是一个处理目的的流对象。
目的：
File对象。
字符串路径。
字节输出流。
格式：
PrintStreamp=newPrintStream（"
dd\\out.txt"
使用PrintStream继承的方法，writer。
Out.wite（886）；
//write将接收到整数的最后一个自己写入到流。
使用PrintStream的特有方法。
Print。
Out.print（97）;
//print方法，可以将参数的数据表现形式打印到目录中，原理是将97转成字符串，在write到目的。
//print方法打印各种数据都会将其变成字符串，所以可以保证数据的原有数据表现形式。
PrintWriter：
字符打印流。
4：
字符输出流。
一般不用PrintWriter定义指定的编码表，为啥呢？
因为有操作编码表专用的对象。
那就是转换流。
而且转换流不仅可以写的编码表，还可以读的编码表。
序列流：
SequercelnputStream{对多个流合并}
SequercelnputStream:
字面理解：
将流按照有序的
ObjectInputStream和ObjectOutputStream
可以用流直接操作对象。
使用ObjectOutputStream
ObjectOutputStreamoos=newObjectOutputStream（newFileOutputStream（"
路径名和文件名"
））
Serializable:
接口
用于给序列化的类添加一个序列版本
升级会员 