Java输入、输入、IO流 类层次关系梳理

Java输入、输入、IO流类层次关系梳

理

目录

1.Java中IO简介

2.Java中的流

3.Java中和10相关的类库层次结构

1.Java中10简介

KXInputAndOutput）在编程中是一个很常见的需求，IO即意味着我们的java程序需要和”外

部”进行通信，这个“外部"可以是很多介质

1）本地磁盘文件、远程磁盘更件

2）数据库连接

3）TCP、UDP、HTTP网络通信

4）进程间通信

5）硬件设备（犍盘、串口等）

2.Java中的流

1O是我们的目的，而要达到这一目的，我们需要一种机制来帮助我们完全，这种机制就是"

流"、或者叫“数据流”。

数据流是一串连续不断的数据的集合，就象水管里的水流，在水管的一端一点一点地供水，

而在水管的另•端看到的是股连续不断的水流。数据写入程序可以是一段、•段地向数据

流管道中写入数据，这些数据段会按先后顺序形成一个长的数据流。对数据读取程序来说，

看不到数据流在写入时的分段情况，每次可以读取其中的任意长度的数据，但只能先读取前

面的数据后，再读取后面的数据。不管写入时是将数据分多次写入，还是作为•个整体•次

写入，读取时的效果都是完全一样的。

Java的IO模型设计非常优秀，它使用Decorator模式，按功能划分Stream

记住这句话对我们在编程中选择合适的类库很重要，Java中按照功能提供不同类别的流，我

们接卜来深入学习一下java中的各个流、以及它们的层次结构关系

3.Java中和IO相关的类库层次结构

首先，java中所有的对象（包括）流对象都从Object超类继承而来，所以，所有的流类的父类

都是Object类

以下的缩进关闭表示的的类的继承关系

复制代码

Object(超类)

1.基于"字节"操作的I/O接口：

1)InputStream

InputStream类是•个absiractclass(抽象父类)，它不能被直接用于实例化进行流操作，

我们在编程中使用的是它的子类

1.1)ByteArrayinputSlream:从字方数组(byle[])中进行以字节为单位的读取

1.2)FilelnputStream:从文件中进行以字节为单位的读取

1.2.1)SockctlnpucStrcam

.io.SockellnputStream:封装了对Socket的字节型流式

读取

1.3)FiltcrInputS(rcam:用来"封装其它的输入流，并为它们提供额外的功能”

1.3.1)InflaterlnputStream

java.util.zip.InflaterlnputStream:从压缩数据源(zip)中以字节为单位读取数据

1.3.1.1)ZipInputStrcam

java.util.zip.ZipInputStream:从zip文件中以字节为单位读取数据

1.3.2)BuffcrcdlnputStrcam:开辟”内部字节数组"对输入流进行缓存，函数的返

回也是一个字节数组

1.3.3)DatalnputStream:

DatalnputStieam是用来装饰其它输入流，它"允许应用程序以与机器无关方式

从底层输入流中读取基本Java数据类型“。应用程序可以使用DalaOutputSircam(数据输出

流)

写入由DataInpulStreani(数据输入流)读取的数据。

1.4)ObjectlnpucStrcam:从输入流中读取序列化后的数据，并进行反序列化

(deserializes)

1.5)PipedlnputStreair:从管道中读取数据

2)OutputStrcam

Outputstream类是一个abstractclass(抽象父类)，它不能被直接用于实例化进行流操作，

我们在编程中使用的是它的子类

2.1)BytcArrayOulpuiSlrcain:以字节为单位将数据写入到从字节数组(bytcM)中

2.2)FileOutputStream:以字节为单位将数据写入到文件中

2.2.1)SocketOutoutStream

.io.SockctOutputStream:封装/对Socket的字节型流式

写入

2.3)FilterOutputStream:用来”封装其它的输出流，并为它们提供额外的功能”

2.3.1)ZipOutputStream:java.util.zip.ZipOutpiitStream:以字节为单位向zip文件

写入数据

2.3.2)PrintStream:

PrintStrcam是用来装饰其它输出流。它能为其他输出流添加J’功能，使它们

能够方便地打印各种数据值表示形式

2.3.3)DataOutputStream:

DataOutputStream是用来装饰其它输入流，它”允许应用程序以与机器无关方

式向底层输出流中写入基本Java数据类型"。应用程序可以使用DatalnputStream（数据输入

流）

写入由DataOulputSlream（数据输出流）写入的数据0。有点类似管道、或者

进程间通信的感觉

2.3.4）BuffcredlnputStrcain:

2.4）ObjectOutputStream:对数据进行序列化（serializes）,并向输出流中写入序列化

后的数据

2.5）PipcdOutputStrcani:向管道中写入数据

2.基于"字符"操作的I/O接口

不管是磁盘还是网络传输，最小的存储单元都是字节，而不是字符，所以I/O操作的都是

字节而不是字符，为了操作方便，java封装了一个直接写字符的I/O接口，这里就涉及到

java的流机制

中的一个很重要的概念，包装（装饰）。即所有的流操作在底层实现都是字节流的形式，以这

个底层字节流为基础，在其上封装r各种“附加功能"（缓存、字符、管道..）

1）Reader

Reader类是一个abstractclass（抽象父类），它不能被直接用于实例化进行流操作，我们

在编程中使用的是它的子类

1.1）InputStreamReader:

我们知道，字符型的流接口是在字节型的流接口基础之上进行了一次封装，提供了

一些额外的功能。所以，从名字上也可以看出来，InpuiSlrcainRcader是字节流通向字符流的

桥梁，

封装了InpulSiream在里头，它以较高级的方式，一次读取一个一个字符，以文本格

式输入/输出，可以指定编码格式。

1.1.1）FileReader:提供对文本文件（保存字符的文件）进行以字符为单位的读取

1.2）BufferedReader:

BuffercdReadcr会一次性从物理流中读取8k（默认数值，可以设置）字节内容到内存，

如果外界有请求，就会到这里存取，如果内存里没有才到物理流里再去读。即使读，也是再

8k

而直接读物理流，是按字节来读。对物理流的每次读取，都有10操作。10操作

是最耗费忖间的。BufferedReader就是减少了大量IO操作，节省了时间

1.3）CharArrayReader:

CharArrayRcader是字符数组输入流。它和ByteArraylnputStrcam类似，只不过

ByteArrayInputStream是字节数组输入流，而CharArray是字符数组输入流。

CharArrayReader是用于读取字符数组，它继承于Reader。操作的数据是以字符

为单位

L4）FikerReader:用来"封装其它的字符输入流，并为它们提供额外的功能"

1.5）PipedReader:PipedReader是字符管道输入流，它继承于Reader0

1.6）StringReader:以Siring作为数据源，进行以字符为单位的读取

2）Writer

Writer类是个abstractclass（抽象父类），它不能被直接用于实例化进行流操作，我

们在编程中使用的是它的子类

2.1）OutputStreamWriter:

2.1.1）FileWriter:提供对文本文件（保存字符的文件）进行以字符为单位的写入

2.2)BufferedWriter

2.3)StringWriter

2.4)PipcdWritcr

2.5)PrintWriter

2.6)CharArrayWriter

3.基于“磁盘"操作的I/O接口:

1)File:(文件特征与管理)：用于文件或者目录的描述信息，例如生成新目录，修改文件

名，删除文件，判断文件所在路径等，它不负贵数据的输入输出，而专门用来管理磁盘文件

与目录

1)publicbooleanexisls()判断文件或目录是否存在

2)publicbooleanisFile()判断是文件还是目录

3)publicbooleanisDircctor)^)判断是文件还是目录

4)publicStringgelNcune()返回文件名或目录名

5)publicStringgetPalh()返回文件或目录的路径。

6)publiclonglcngth()获取文件的长度

7)publicStringf]list()将目录中所有文件名保存在字符串数组中返回

8)publicbooleanrenameTo(FilenewFile);重命名文件

9)publicvoiddclctc();删除文件

10)publicbooleanmkdir();创建目录

4.基于网络操作的I/O接口：

1)Socket

复制代码

以上是按照Java官方AP【文档列出的总的目录，我们接下来逐一学习•下它们的应用场景,

因为输入、输出流在编程上具有对称性，所以我们把它们合并在一起学习

Oxi:InputStream:字节输入流

0x2:Outputstream:字节输出流

Bytc/XrraylnputStrcamxByteArrayOutputStream

ByteArrayOutputStream类是在创建它的实例时，程序内部创建•个byle型数组的缓冲区，

然后利用BytcArrayOulputStrcani和ByteArrayInputStrcam的实例向数组中写入或读出byte

型数据。在网络传输中我们往往要传输很多变量，我们可以利用ByteArrayOutputStream

所有的变量收集到•起，然后•次性把数据发送出去

复制代码

importjava.io.*;

publicclasscircle

publicstaticvoidmain(String(]args)throwsException

inta=0;

intb=l;

intc=2;

/*

*ByteArrayOulputStreamO

*Createsanewbytearrayoutputstream.

*/

ByteArrayOulputStrec.nibout=newByteArrayOulputStreamO;

/*

*writc(intb)

*Writesthespecifiedbytetothisbytearrayoutputstream.

*/

bout.write(a);

bout.write(b);

bout.write(c);

/*

"toByteAnayO

*Createsanewlyallocatedbytearray.

*返回内部保存的临时byte缓存数组

*/

byte[]buff=bout.toByteArrayO；

fbr(in(i=0;i<buff.Icngth;i++)

System.out.println(buffli]);

)

System.out.printing***********************");

/*

*ByteArrayInputStrcam(bytc[]buf)

*CreatesaByteArraylnputStreamsothatitusesbufasitsbufferarray.

*/

ByteArraylnputStreambin=newBy(cArrayInpu(Strcam(bufD:

/*

*read()

*Readsthenextbyteofdatafromthisinputstream.

*/

while((b=bin.readO)!=-1)

System.out.println(b);

复制代码

FilelnputStream、FileOutputStream

复制代码

importjava.io.File;

importjava.io.FilelnputStream;

importjava.io.FilcOutputStrcam;

publicclasscircle

publicstaticvoidmain(String[]args)throwsException

Filef=newFile("C:\l.txtH);

〃向文件里写如“Hello”字符串.

try

〃要写入的数据转换成字节数组

byte[]buf="Hello".getBytes();

/*

*FileOutputStream(Fiiefile)

*CreatesafileoutputstreamtowritetothefilerepresentedbythespecifiedFile

object.

*如果l.txt存在,则删除l.txt里面的内容，文本所有内容变为Hello

*如果l.txt不存在，在新建l.txt文本，写入Hell。

*/

FileOutputStreamout=newFileOutputStream(f);

/*

*write(byte[]b)

*Writesb.lengthbytesfromthespecifiedbytearraytothisfileoutputstream.

*/

out.writc(buf);

out.close();

catchfExccptionc)

System.out.println(e):

)

〃读取文件中的内容

*FileInputStream(Filefile)

*CreatesaFilelnputStreambyopeningaconnectiontoanactualfile,thefile

namedby(heFileobjectfileinthefilesystem.

*/

FilelnputStreamin=newFilelnputStream(f);

bytc[1buf=newbytc|10241;

/*

*read(byte[]b)

*Readsuptob.lcngthbytesofdatafromthisinputstreamintoanarrayofbytes.

*从流中读取内容

*/

in(len=in.rcad(buf)；

Stringstr=newString(buf,O,len);

〃打印f文件的内容.

Systcm.out.println(s(r);

)

catch(Exccptionc)

(

System.out.println(e);

复制代码

ZipInputStream,ZipOulpulSlrcam(包装流)

复制代码

importjava.io.File;

importjava.io.FilelnputStream;

importjava.io.InputStream;

importjava.util.zip.ZipEniry;

importjava.util.zip.ZipInputStream;

importjava.util.zip.ZipOutputStream;

importjava.io.FilcOutputStrcam;

publicclasscircle

I

publicstaticvoidmain(String[]args)throwsException

//定义要压缩的文件

Filefile=newFile("C:"+File.separator+"in.txt");

//定义压缩文件名称

FilezipFile=newFile("C:"+File.separator+"in.zip");

/*

*FileInputStream(Filefile)

*CreatesaFilelnputStreambyopeningaconnectiontoanactualfile,thefilenamed

bytheFileobjectfileinthefilesystem.

*定义文件的输入流

*/

InputStreaminput=newFilelnputStream(file);

//声明压缩流对象

ZipOutpulStreamzipOut=null;

/*

*ZipOutputS(rcam(Ou(pu(Strcamout)

*CreatesanewZIPoutputstream.

*再次体现了Java的流函数架构中的”装饰器设计模式”的强大之处，我们可以根

据我们对功能的

*需要任意组合、加载我们需要的流，用通俗的话来说，把它们层层包裹在一起

*/

zipOut=newZipOutpu(Strcam(ncwFilcOulputStrcam(zipFilc));

/*

*putNcxtEnti-y(ZipEntiyc)

*BeginswritinganewZIPfileentryandpositionsthestreamtothestartofthecniry

data.

*设置ZipEntry对象

*/

zipOut.putNextEntr)f(newZipEntiy(fiie.getName()));

inttemp=0;

/*

*read()

*Readsabyteofdatafromthisinputstream.

*从文件流中读取内容

*/

while((temp=input.read())!=-1)

(

//压缩输出

zipOut.write(temp);

)

//关闭输入流

input.close();

//关闭输出流

zipOut.close();

//readzipfileasinputstream

InputStreamis=newFileInputStream("C:"+File.separatcr+"in.zip");

//zipisreadbyZiplnputStream

ZipInputStreamzis=newZipInputStream(is);

//nowwritezipfileinextractedfile

ZipEntryze;

bytel)buff=newbyte[1024];

/*

*getNextEntry()

*ReadsthenextZIPfileentryandpositionsthestreamatthebeginningoftheentry

data.

*/

while((ze=zis.getNextEntryO)!=null)

(

//getfilename

FileOutputStreanifos=newFileOutputStream("C:"4-File.separator+"out.txt");

int1=0;

//writebuffertofile

while((l=zis.read(buff))>0)

(

fos.wri(e(buff,0,1);

}

)

zis.ciose();

)

)

复制代码

BufferedlnputStream,BufferedInpulStream(包装流)

复制代码

importjava.io.*;

publicclasscircle

(

publicstaticvoidniain(String[]args)throwsException

{

Filefilein=newFile('C:/l.png");

Filefileout=newFile("C:/out.png");

try

(

〃前面说过，File类它不负责数据的输入输出，而专门用来管理磁盘文件与目

录

if(fileout.exists()==false)

{

filcou(.crcateNcwFile();

〃要使用文件流，自然要使用文件读取流函数

FilelnputStream:n=newFilelnputStream(filein);

FileOutputStreaniout=newFileOutputStream(fileout);

bytc[1b=newbytc|l];

〃在文件流外而包一层缓冲流读取函数

BufferedlnputStreanibin=newBufteredlnputStream(in);

BuffcrcdOutputStrcambout=newBuffcrcdOutputStrcam(out);

〃缓存读取、缓存写入

while(bin.read(b)!=-1)

(

bout.write(b);

)

bout.closc();

bin.close();

out.close();

in.closcO;

)

catch(Exceptione)

(

e.prinlSlackTraceO;

复制代码

DataInpu(Strcam>DalaOutpulStrcam(包装流)

复制代码

importjava.io.DatalnputStrcam;

importjava.io.DataOutputStream;

importjava.io.FilelnputStream:

importjava.io.FilcOutputSircam;

importjava.io.IOException;

publicclasscircle

(

publicstaticvoidniain(String[]args)throwsException

{

writeDemo();

readDemo();

)

publicstaticvoidreadDemo()throwslOException

DatalnputStreamdos=newDataInputStream(newFileInputStream("C:/in.txt"));

Strings=dos.readUTF();

System.out.println(s);

publicstaticvoidwiiteDemo()throwslOException

{

/*

*DataOutputStreamlOutputStreaniout)

*Createsanewdataoutputstreamtowritedatatothespecifiedunderlyingoutput

stream.

*/

DataOutputStreamdos=newDataOutputStream(newFileOutputStream("C:/in.txt"));

/*

*writeUTF(Stringstr)

*WritesastringtotheunderlyingoutputstreamusingmodifiedUTF-8encodingina

machine-independentmanner.

*/

dos.writeUTF("你好啊)//UTF-8修改版

)

)

登制代码

ObjectInputStream、ObjcciOutputStrcam

ObjectOutputStream可以把对象直接存入到文件中，然后利用ObjeclInputSlreani读取文件还原

成对象，前提是该对象实现了Serializable接口

复制代码

importjava.io.EOFExceplion;

importjava.io.FilelnputStream;

importjava.io.FileOutputStream;

importjava.io.IOException;

importjava.io.ObjectInputStream;

importjava.io.ObjectOutputStream;

importjava.io.Scrializable;

publicclasscircle

{

publicstaticvoidmain(String[]args)throwsException

{

FileOutputStreamfop=newFileOu(pu(Strcam("C:/out.txF."):

/*

*ObjectOutputStream(Outpu(Streamout)

*CreatesanObjcctOuiputStrcam(hatwritestothespecifiedOuiputStream.

*/

ObjectOutputStreamcos=newObjectOutputStream(fop);

Peoplep=newPeople(l,"zhang");

/*

*writeObject(Objeciobj)

*WritethespecifiedobjecttotheObjectOutputStream.

*/

oos.wri(cObjcct(p);

p=newPeople(2,"li");

oos.writeObject(p);

p=newPcoplc(3,"zhao");

oos.writeObiect(p);

〃写入三个对象

oos.closc();

〃关闭输出流

FilelnputStreamfis=newFileInpu(Stream("C:/out.txt");

/*

*ObjeclInputStreaniJInputStreamin)

*CreatesanObjectlnputStreamthatreadsfromthespecifiedInputStream.

*/

ObjectlnputStreamois=newObjectlnputStream(fis);

try

(

while(true)

{

/*

*readObject()

*ReadanobjectfromtheObjectlnputStream.

*/

Peoplep2=(People)ois.readObject();

System.out.println(p2);

}

〃没有办法判断文件中对象的数量，所以，只有通过EOFException异常来中断

〃或者在写入的讨候把所有的对象都放到•个An-ayLis里，这样就不需要判断

了

)

catch(ClassNotFoundExceptione)

(

//TODOAuto-generatedcatchblock

e.printStackTrace();

}

catch(EOFExceptione)

System.oui.println("读取结束)

classPeopleimplementsSerializable

〃必须实现Serializable接口

intid;

Stringname;

People(intid,Stringname)

(

this.id=id;

=nanie;

)

publicStringtoStringO

{

return"id:"+id+"name:"+name;

登制代码

PipcdlnputStrcam、PipcdOutputStrcam

管道流内部在实现时还有大量的对同步数据的处理。管道输出流和管道输入流执行时不能互

相阻塞，所以一般要开启独立线程分别执行

复制代码

importjava.io.*;

publicclasscircle

{

publicstaticvoidmain(String[]args)throwsException

{

/*

*PipedInputStream(>

*CreatesaPipedlnpjtStreamsothatitisnotyetconnected.

*/

PipedlnputStreampin=newPipedInputStream();

PipedOutputStreampout=newPipedOutputStream();

/*

*connect(PipedOutputStreamsre)

*Causesthispipedinputstreamtobeconnectedtothepipedoutputstreamsrc.

*输入流与输出流连接

*/

pin.connect(pout);

ReadThreadreadTh=newReadThread(pin);

WriteThrcadwritcTh=newWritcThread(pout);

newThread(readTh).start();

newThread(writeTh).stan();

)

publicstaticvoidsop(Objectobj)〃打印

(

System.out.printin(obj);

classReadThreadimplementsRunnable

(

privatePipedlnputStreampin;

RcadThrcad(PipcdInputStreampin)//

{

this.pin=pin;

)

〃由于必须要覆盖run方法，所以这里不能抛，只能try

publicvoidrun()

(

try

(

sopCR读取前没有数据,阻塞中…等待数据传过来再输出到控制台

byte[]buf=newbyte[1024];

imlen=pin.rcadjbuf);//read阻塞

sop("R:读取数据成功，阻塞解除

Strings=newString(buf.O.lcn);

sop(s);〃将读取的数据流用字符串以字符串打印出来

pin.closeO；

)

catch(Exceptione)

(

thrownewRun〔inieExcep〔ion("R:管道读取流失败!”)：

publicstaticvoidsop(Objectobj)〃打印

System.out.println(obj);

classWriteThreadimplementsRunnable

]

privatePipedOutputStreampout;

WriteThread(PipedOutputStreampout)

(

this.pout=pout;

)

publicvoidrun()

{

try

sop(”W:开始将数据写入:但等个5秒让我们观察

Thread.slccp(5000);〃释放epu执行权5秒

/*

*writc(intb)

*Writesthespecifiedbyte(o(hepipedoutputstream.

*向管道写入数据.同时解除管道上的阻塞状态

*/

pout.writc("W：writePipcd数据...”.getBytes。);

pout.closeO;

}

catch(Exccptione)

(

thrownewRuntimeException("W:WriteThread写入失败...”)；

)

)

〃打印

publicstaticvoidsop(Objectobj)

|

System.out.println(obj);

)

)

复制代码

在了解了“字节型”流处理函数的应用场景后，我们接下来继续学习“字符型”流处理函数

0x3:Reader:字符输入流

0x4:Writer:字符输出流

在开始学习"字符型"流处理函数的应用场景之前，我们必须牢记一个概念，Java的流函数的

整体架构是“装饰器设计模式"，也就是说，所有的流函数都可以按照所需的功能进行任意组

合、互相嵌套、包裹。而我们的字符型流处理函数木质上也是对字节型流处理函数的一次包

裹(或者说加载了字节型流处理函数的功能)

另外数据持久化或网络传输都是以字节进行的，所以必须要有字符到字节或字节到字符的转

化。字符到字节需要转化，其中读的转化过程如下图所示：

InputStreamReader类是字节到字符的转化桥梁，InputStream到Reader的过程要指定编码

字符集，否则将采用操作系统默认字符集，很可能会出现乱码问题。StrcamDecoder正是完

成字节到字符的解码的实现类。

写入也是类似的过程如下图所示

通过OuipulStreamWriler类完成，字符到字节的编码过程，由StreamEncoder完成编码过程

InputSlreamReader、OutputStreamReader

复制代码

importjava.io.*;

publicclasscircle

(

publicstaticvoidniain(String[]args)throwsException

{

InputStreaminputStream=newFileInputStream("C:/in.txt,');

/*

*InputStrcainRcader(Inpu(Strcamin)

*CreatesanInputSlrewww.shanxiwang.nelamReaderthatusesthedefaultcharset.

*在字节型输入流之上包裹一层字符型输入流

*/

Readerreader=newInputStreamReader(inputStream);

/*

*rcad()

*Readsasinglecharacter.

*/

intdata=reader,read0:

while(data!=-1)

(

chariheChar=(char)data;

System.out.print(theChar);

data=reader.read();

reader.close();

OutputStreamoutputstream=newFileOutputStreani("C:/out.txt");

/*

*OutputStreamWriter(OutputStreaniout)

*CreatesanOutputStreamWriterthatusesthedefaultcharacterencoding.

*在字节型输出流之上包裹一层字符型输出流

*/

Writerwriter=new(XitputStreamWriter(outputStream);

/*

*write(Stringstr,intoff,intlen)

*Writesaportionofastring.

*/

writer.write("HelloWorld");

writcr.closcO;

)

)

复制代码

从上面的代码我们可以看到，我们使用字节型的文件流读取文件，然后再在上面包裹一层字

符型流读取函数。除此之外，还有另一种方法(严格来说不能算另一种方法，因为java的流

函数架构是"装饰器设计模式”，功能之间可以任意组装)，直接之用字符型文件流读取(本质

上来说，字符型文件流读取也是一些功能的组装)。

FileReader、FileWritcr

复制代码

importjava.io.*;

publicclasscircle

(

publicstaticvoidmain(String[]args)throwsException

{

/*

*FileReader(SlringfileName)

*CreatesanewFileReader,giventhenameofthefiletoreadfrom.

*/

Readerreader=newFileReader("C:/in.txt");

intdata=reader.readO；

whilc(data!=-1)

chartheChar=(char)data;

System.out.print(theChar);

data=reader.read();

)

reader.close();

Writerwriter=newFileWriter("C:/out.txt");

writer.write("HelloWorld");

writcr.closcO;

)

}

复制代码

BufferedReaderBufferedWriter

和BuffcrcdlnpuiSlrcam、BuffcrcdOulpulStrcam不同的是，BuffcrcdRcadcr、BuffcrcdWriicr提

供了ReadLine.newLine()这种以行为单位的字符读写机制

登制代码

importjava.io.*;

publicclasscircle

{

publicstaticvoidmain(Stiing[]args)throwsException

{

/*

*FileReader(StringfileName)

*CreatesanewFileReader,giventhenameofthefiletoreadfrom.

*/

Readerreader=newFileReader("C:/in.txt");

/*

*BufferedRcader(Readerin)

"Createsabufferingcharacter-inputstreamthatusesadefault-sizedinputbuffer.

*在Reader之上再包•层Buffer缓冲区的功能

*/

BufferedReaderbrd=newBufferedReader(reader);

Stringdata=brd.rcadLineO:

while(data!=null)

(

System.out.print(data);

data=brd.readLine();

bid.close();

reader.close();

Writerwriter=newFileWriter("C:/out.txt,');

/*

*BufferedWriter(Writerout)

*Createsabufferedcharwww.sm136.comacter-outputstreamthatusesadefault-sized

outputbuffer.

*/

BufferedWriterbwd=newBufferedWriter(writer);

/*

*write(Strings,inteff,intlen)

*WritesaportionofaString.

*/

bwd.write("HelloWorld");

/*

*ncwLincO

*Writesalineseparator.

♦/

bwd.ncwLine();

bwd.closeO;

writer.close();

复制代码

CharArrayReader>CharArrayWiiter

CharArrayRcader是字符数组输入流。它和ByteArraylr.putStream类似，只不过

ByteArraylnputStream是字节数组输入流，而CharArray是字符数组输入流。CharArrayReader

是用于读取字符数组，它维承于Reader。操作的数据是以字符为单位

复制代码

importjava.io.*;

publicclasscircle

publicstaticvoidmain(String[]args)throwsException

chara='a';

charb='b';

charc='c';

/*

*CharArrayWriterQ

*CreatesanewCharArrayWriter.

*/

CharAnayWritercarrWrt=newCharArrayWriter();

/*

*writc(intc)

*Writesacharacter(othebuffer.

*/

carrWrt.writc(a);

carrWrt.write(b);

carrWrt.write(c);

/*

*toCharArrayO

*Returnsacopyoftheinputdata.

*/

char[]buff=carrWrt.toCharArrayO;

fbr(inti=0;i<buff.lcngth;i++)

System.out.println(buffli])；

Sys(cm.ou(.println("***********************");

*CharArrayReader(char[]buf)

*CreatesaCharArrayReaderfromthespecifiedarrayofchars.

*/

CharArrayReadercarrRcd=newCharArrayRcadcr(buff);

/*

*read()

*Readsthenextbyteofdatafromthisinputstream.

*/

intdata;

whilc((data=carrRcdrcad())!=-1)

(

Systeni.out.println(data);

}

复制代码

FilterReader、FikerWriter

用来”封装其它的字符输入流，并为它们提供额外的功能”

PipcdRcadcr、PipcdWritcr

字符管道流，原理上和PipedlnputStream类似

PrintWriter

printwritcr是向文本输出流打印对象的格式化表示形式，它允许以一种格式化的方式进行数

据流的写入，类似C语言中的prinif()函数

复制代码

importjava.io.FilcWritcr;

importjava.io.IOException;

importjava.io.PrintWriter;

publicclasscircle

(

publicstaticvoidinain(String[]args)throwsException

(

Stringfilename="C:/out.txt";

/*

*PrintVVriter(Writerout)

*CreatesanewPrintWriter,withoutautomaticlineflushing.

*/

PrintWriterpw=newPrintWriter(newFileWriter(filename));

String[]words=newString[J!"hello","world","!"!；

for(inti=0;i<words.length;i++)

(

/*

*format(Stringformat,Object...args)

*Writesaformattedstringtothiswriterusingthespecifiedformatstringand

arguments.

*/

pw.format("words:%s\n",words[i]);

}

/*

*flush()

*Flushesthestream.

*/

pw.tlush()：

复制代码

0x5:File文件、目录操作接口

我们已经学习了关于流操作的各种函数接口，接下来我么继续学习File类，要明确的一点

是，虽然这个类名是File类，但是这个类却不负责文件流的实际读写，在我本人看来，我

更愿意叫它”文件元数据Meta操作接口”。而File类常常和文件流读写函数配合起来，进行

文件的操作

复制代码

importjava.io.*;

publicclasscircle

{

publicvoidFileOperate()

*新建目录

*(3)paramfolderPathString如c:/fqf

*@returnboolean

*/

publicvoidnewFolder(SlringfolderPath)

StringfilePath=folderPath;

filcPath=filePath.toStringO;

java.io.FilemyFilePath=newjava.io.File(filePath);

if(!myFilePath.exists())

(

myFilePath.mkdirO;

catch(Exceptione)

System.out.prindn("新建目录操作出错)

e.printStackTrace();

*新建文件

*@paramfilePathAndNameString文件路径及名称如c:/fqf.txt

*@paramfilcContcntString文件内容

*@returnboolean

*/

publicvoidncwFilc(StringfilePathAndName,StringfilcContcnt)

(

try

(

StringfilePath=filePathAndName;

filePath=filePath.toStringO；

FilemyFilcPalh=newFilc(filePath);

if(JmyFilePath.existsO)

(

myFilePath.creatcNcwFileO;

)

FileWriterresultFile=newFileWnter(myFilePath);

PrintWritcrmyFilc=newPrin(Writcr(resultFile);

StringstrContent=fileContent;

myFile.println(strContent);