第9章输入输出流

复习编写线程程序的主要方法？编写线程程序的主要步骤？讲解编写线程程序的主要方法？继承Thread类实现Runnable接口编写线程程序的主要步骤？继承Thread类或实现Runnable接口重写run方法定义线程对象启动线程分析程序的执行过程(五个状态)？程序执行机制解析？run（）方法的出处？run（）方法的调用过程？第九章输入、输出流

本章导读1.文件2.文件字节流3.文件字符流4.从键盘读取数据5．缓冲流6．数组流7．字符串流8．数据流9．管道流10．对象流11.序列化与对象克隆12.随机读写流13.文件锁

java语言提供了丰富的流类（输入输出类：java.io包中），用于完成基本的输入输出到文件操作（文件及文件夹的管理）。一、基本概念

流的概念：是指计算机各部件的数据流动。在java语言中，将不同类型的输入输出源（键盘、屏幕、文件、打印机等）抽象为流或数据流。按传输方向可分为：输入流、输出流

采用数据流处理输入输出的好处是，使输入输出操作独立于相关设备，隐藏了具体的实现细节，用户只需在程序中操作统一规范的类及相关方法即可。

流式输入输出的特点是数据的的获取和发送沿着数据序列的顺序进行，每次数据的读写都必须等待它前面的数据读写完毕之后才能读写。输入源输出源程序读取输入流输出流写入输入输出流按内容可分为：字符流、字节流

字节流：将数据以二进制的原始方式读写，不能分解、重组和理解这些数据，每次读写8位二进制，因此称为二进制字节流或位流。字节流可以变换恢复到原来有意义的状态。（处理字节数据，二进制文件，基本处理类为InputStream、OutputStream类）

字符流：一次读写16位二进制，并将其作为一个字符处理。（处理字符数据，文本文件，基本处理类为Reader、Write）

缓冲流：若对数据流的每次操作以字节为单位进行，每次读出一个字节，每次写入一个字节，需要反复操作文件或设备。通常使用缓冲区（缓冲流）处理，当写入数据时，先写入到缓冲区，等缓冲区慢后在写入外部设备；读出数据时每次，先读尽可能多的数据到缓冲区中，然后再从缓冲区读出数据。用于避免反复读写外部设备、提高输入输出效率。二、输入输出流类库（importjava.io.*）

InputStream、OutputStream、Reader、Writer是抽象类，一般不直接使用这些类，而直接使用子类对应某种设备；前两个字节输入输出类常用于读写图片、声音等二进制文件，后两个字符输入输出文件用于文本文件。

File用于对磁盘文件与文件夹的管理。

RandomAccessFile用于磁盘文件的随机读写。

9.1文件操作类一、File类概述对磁盘文件与文件夹的管理，建立磁盘文件建立File类对象，为磁盘指定文件名和程序中文件输入输出流操作做连接准备

二、文件的属性、目录、创建及删除、执行例9-1importjava.io.*;classFileAcceptimplementsFilenameFilter{Stringstr=null;FileAccept(Strings){str="."+s;}publicbooleanaccept(Filedir,Stringname){returnname.endsWith(str);}}//设置文件过滤publicclassExample9_1{publicstaticvoidmain(Stringargs[]){Filedir=newFile("D:\\javats");FileAcceptacceptCondition=newFileAccept("java");FilefileName[]=dir.listFiles(acceptCondition);for(inti=0;i<fileName.length;i++){System.out.printf("\n文件名称:%s,长度:%d",fileName[i].getName(),fileName[i].length());}booleanboo=false;if(fileName.length>0)boo=fileName[0].delete();if(boo)System.out.printf("\n文件:%s被删除:",fileName[0].getName());}}列出指定文件夹下的文件，并删除第一个文件publicclassExample9_1j1{publicstaticvoidmain(String[]args){intcs=0;Filedir=newFile("d:\\java");

filelist(dir,cs);}publicstaticvoidfilelist(Filedir,intcs){FilefileName[]=dir.listFiles();for(inti=0;i<fileName.length;i++){if(fileName[i].isDirectory()){System.out.println();for(intj=0;j<cs;j++)System.out.print("

");System.out.printf("目录:%s",fileName[i].getName());

filelist(fileName[i],cs+1);}else{System.out.println();for(intj=0;j<cs;j++)System.out.print("

");System.out.printf("文件:%s",fileName[i].getName());}}}}importjava.io.File;classFileop{privateFilerootdir=newFile("D:\\TestFile");publicFileop(){System.out.println("根目录:"+rootdir.getAbsolutePath());if(!rootdir.exists()){rootdir.mkdirs();

}createFile(rootdir,1);listFile(rootdir,1);delFile(rootdir,1);rootdir.delete();

}publicvoidcreateFile(FilecurrentFile,intnum){if(num<5){FiletmpFile=newFile(currentFile.getAbsolutePath()+"\\"+String.valueOf(num)+".txt");if(!tmpFile.exists()){try{tmpFile.createNewFile();

}catch(Exceptione){e.printStackTrace();

}

}tmpFile=newFile(currentFile.getAbsolutePath()+"\\"+String.valueOf(num));if(!tmpFile.exists()){tmpFile.mkdirs();createFile(tmpFile,num+1);

}

}

}publicvoidlistFile(Filefile,intnum)

{File[]files=file.listFiles();for(inti=0;i<files.length;i++){StringBufferkg=newStringBuffer();for(intj=0;j<num;j++){kg.append("");

}if(files[i].isDirectory()){System.out.println(kg+"第"+num+"级子文件夹:"+files[i].getAbsolutePath());

}else{System.out.println(kg+"第"+num+"级子文件:"+files[i].getAbsolutePath());

}

}for(inti=0;i<files.length;i++){if(files[i].isDirectory())listFile(files[i],num+1);

}

}publicvoiddelFile(Filefile,intnum)

{File[]files=file.listFiles();for(inti=0;i<files.length;i++){if(files[i].isDirectory()){delFile(files[i],num+1);

}files[i].delete();

}

}}publicclassExample9_1j2{publicstaticvoidmain(String[]args){newFileop();

}}例9-2importjava.io.*;publicclassExample9_2{publicstaticvoidmain(Stringargs[]){try{Runtimece=Runtime.getRuntime();//获取当前JVM的运行环境ce.exec("javacExample9_1.java");Filefile=newFile("C:\\windows","Notepad.exe");ce.exec(file.getAbsolutePath());}catch(Exceptione){}}}9.2字节文件流操作(字节文件读写操作)按自己读取文件中的数据，基本处理类为InputStream、OutputStream类,例9-3importjava.io.*;public

class

Example9_3{

public

static

voidmain(Stringargs[]){Filefile=newFile("hello.txt");

byteb[]="欢迎welcome".getBytes();

try{FileOutputStreamout=newFileOutputStream(file);out.write(b);out.close();FileInputStreamin=newFileInputStream(file);

intn=0;

while((n=in.read(b,0,2))!=-1){Stringstr=newString(b,0,n);System.out.println(str);}

in.close();}

catch(IOExceptione){System.out.println(e);}}}publicclassExample9_3j1{privateFilef1=newFile("d:\\yhl.jpg");privateInputStreamfis;privateOutputStreamfos;publicExam(){try{Filef2=newFile("d:\\ml\\yhl.jpg");if(!f2.exists())f2.createNewFile();System.out.println("源文件路径："+f1.getAbsolutePath());System.out.println("目标文件路径："+f2.getAbsolutePath());System.out.println("下面开始复制文件**************");fis=newFileInputStream(f1);//文件字节输入流

fos=newFileOutputStream(f2);//文件字节输出流

inttmp=fis.read();while(tmp!=-1){fos.write(tmp);tmp=fis.read();}fis.close();fos.close();System.out.println("文件复制完成****************");}catch(FileNotFoundExceptione){System.out.println("文件没找到！");e.printStackTrace();}catch(IOExceptione){e.printStackTrace();}}publicstaticvoidmain(String[]args){newExam();}}用字节流实现文件的复制publicclassExample9_3j2{publicstaticvoidmain(String[]args){try{Filef1=newFile("考拉.jpg");Filef2=newFile("考拉2.jpg");if(!f2.exists())f2.createNewFile();FileInputStreamfis;FileOutputStreamfos;fis=newFileInputStream(f1);fos=newFileOutputStream(f2);System.out.println("源文件路径："+f1.getAbsolutePath());System.out.println("目标文件路径："+f2.getAbsolutePath());System.out.println("文件的大小："+fis.available()+"字节");System.out.println("文件复制开始**************");byte[]b=newbyte[fis.available()];fis.read(b);fos.write(b);System.out.println("文件复制完成**************");fis.close();fos.close();

}catch(FileNotFoundExceptione){System.out.println("文件没找到！");e.printStackTrace();

}catch(IOExceptione){e.printStackTrace();

}

}}用字节流实现文件的复制9.3字符文件流操作(字符文件读写操作)按字符读写文件，一个汉字当一个字符，基本处理类为Reader、Write,例9-4publicclassExample9_4{publicstaticvoidmain(Stringargs[]){Filefile=newFile("hello.txt");charb[]="欢迎welcome".toCharArray();try{FileWriterout=newFileWriter(file);out.write(b);out.write("来到北京!");out.close();FileReaderin=newFileReader(file);intn=0;while((n=in.read(b,0,2))!=-1){Stringstr=newString(b,0,n);System.out.print(str);}in.close();}catch(IOExceptione){System.out.println(e);}}}9.4缓冲流

若对数据流的每次操作以字节为单位进行，每次读出一个字节，每次写入一个字节，需要反复操作文件或设备。通常使用缓冲区（缓冲流）处理，当写入数据时，先写入到缓冲区，等缓冲区慢后在写入外部设备；读出数据时每次，先读尽可能多的数据到缓冲区中，然后再从缓冲区读出数据。用于避免反复读写外部设备、提高输入输出效率。

BufferedInputStream、BufferedReader

BufferedOutputStream、BufferedWriter

flush例9-5publicclassExample9_5{publicstaticvoidmain(Stringargs[]){try{FileReaderinOne=newFileReader("d:\\Student.txt");BufferedReaderinTwo=newBufferedReader(inOne);FileWritertofile=newFileWriter("d:\\hello.txt");BufferedWriterout=newBufferedWriter(tofile);Strings=null;inti=0;while((s=inTwo.readLine())!=null){i++;out.write(i+""+s);out.newLine();}out.flush();//刷新缓冲区，强制写出所有数据

out.close();tofile.close();inOne=newFileReader("d:\\hello.txt");inTwo=newBufferedReader(inOne);while((s=inTwo.readLine())!=null){System.out.println(s);}inOne.close();inTwo.close();}catch(IOExceptione){System.out.println(e);}}}9.8对象流将对象进行输入输出保证对象必须是序列化的,并且对象成员也必须是支持序列化的ObjectInputStream类

writeObject()方法ObjectOutputStream类

readObject()方法序列化：把一个对象完全转成字节序列，方便传输。

就像你寄一箱饼干，因为体积太大，就全压成粉末紧紧地一包包寄出去，这就是序列化的作用。只不过JAVA的序列化是可以完全还原的。例9-10importjava.io.*;classGoodsimplementsSerializable{Stringname=null;doubleprice;Goods(Stringname,doubleprice){=name;this.price=price;}publicStringgetName(){returnname;}publicdoublegetPrice(){returnprice;}}publicclassExample9_10{publicstaticvoidmain(Stringargs[]){Goodstv1=newGoods("HaierTV",3468);Filefile=newFile("d:\\text.txt");if(!file.exists()){try{file.createNewFile();}catch(IOExceptione){e.printStackTrace();}}try{FileOutputStreamfos=newFileOutputStream(file);//创建文件输出流对象

ObjectOutputStreamoos=newObjectOutputStream(fos);//创建对象输出流对象

oos.writeObject(tv1);

FileInputStreamfis=newFileInputStream(file);//创建文件输入流对象

ObjectInputStreamois=newObjectInputStream(fis);//创建对象输入流对象

Goodstv2=(Goods)ois.readObject();

System.out.println(tv2.getName());System.out.println(tv2.getPrice());}catch(Exceptionevent){System.out.println(event);}}}classStudentimplementsSerializable{intxh;Stringxm;intcj;Student(){}Student(intxh,Stringxm,intcj){this.xh=xh;this.xm=xm;this.cj=cj;}publicStringtoString(){Stringstr="学号："+xh+",姓名："+xm+",成绩："+cj;returnstr;}}publicclassExample9_10j1{@SuppressWarnings("unchecked")publicstaticvoidmain(String[]args)throwsIOException,ClassNotFoundException{Filefile=newFile("d:\\text.txt");if(!file.exists()){file.createNewFile();}FileOutputStreamfos=newFileOutputStream(file);//创建文件输出流对象ObjectOutputStreamoos=newObjectOutputStream(fos);//创建对象输出流对象FileInputStreamfis=newFileInputStream(file);//创建文件输入流对象ObjectInputStreamois=newObjectInputStream(fis);//创建对象输入流对象ArrayList<Student>list=newArrayList<Student>();list.add(newStudent(1,"王平",95));//向容器类添加数据

list.add(newStudent(2,"李娜",89));list.add(newStudent(3,"张华",85));list.add(newStudent(4,"刘丽",88));list.add(newStudent(5,"刘曾",95));//向容器类添加数据

oos.writeObject(list);ArrayList<Student>listd=newArrayList<Student>();

listd=(ArrayList<Student>)ois.readObject();System.out.println("全部数据:");for(inti=0;i<listd.size();i++){System.out.println(listd.get(i).toString());}}}例10-加1：ArrayList容器类读写publicclassExample9_10j2{publicstaticvoidmain(String[]args)throwsIOException,ClassNotFoundException{Filefile=newFile("d:\\text.txt");if(!file.exists()){file.createNewFile();}FileOutputStreamfos=newFileOutputStream(file);//创建文件输出流对象ObjectOutputStreamoos=newObjectOutputStream(fos);//创建对象输出流对象FileInputStreamfis=newFileInputStream(file);//创建文件输入流对象ObjectInputStreamois=newObjectInputStream(fis);//创建对象输入流对象Students[]={newStudent(1,"王平",95),//向容器类添加数据

newStudent(2,"李娜",89),newStudent(3,"张华",85),newStudent(4,"刘丽",88)};//向容器类添加数据}oos.writeObject(s);Studento[]=(Student[])ois.readObject();System.out.println("全部数据:");for(inti=0;i<o.length;i++){System.out.println(o[i].toString());}}}例10-加2：对象数组读写结束数据流流：源于UNIX操作系统对数据的理解有结构的数据流式数据反映到文件对应有相应的流式操作例如重定向、管道数据流数据流是指所有的数据通信通道，或是程序和外界进行数据交换的通道。输入源输出源程序读取输入流输出流写入输入流：用于输入数据到程序的流。输出流：用于从程序输出数据的流；输入输出是针对程序而言JavaAPI中通过类库java.io和java.nio(JDK1.4)来实现I/O处理。字节流stream从InputStream和OutputStream派生出来的一系列类。这类流以字节(byte)为基本处理单位。字符流reader&writer从Reader和Writer派生出的一系列类，这类流以16位的Unicode码表示的字符为基本处理单位。InputStream 抽象的字节输入流类OuputStream 抽象的字节输出流类Reader 抽象的字符输入流类Writer 抽象的字符输出流9.1文件（java.io包）File的构造方法：File(Stringfilename);File(StringdirectoryPath,Stringfilename);File(Filef,Stringfilename);文件常用方法PublicStringgetName()获取文件的名字。PublicbooleancanRead()判断文件是否是可读PublicbooleancanWrite()判断文件是否可被写入Publicbooleanexits()判断文件是否存在。Publiclonglength()获取文件的长度（字节）。PublicStringgetAbsolutePath()获取文件的绝对路径。PublicStringgetParent()获取文件的父目录。PublicbooleanisFile()判断文件是否是一个文件而不是目录。PublicbooleanisDirectroy()判断文件是否是一个目录。PublicbooleanisHidden()判断文件是否是隐藏文件。PubliclonglastModified()获取文件最后修改的时间目录创建目录publicbooleanmkdir()：创建一个目录，如果创建成功返回true。列出目录中的文件publicString[]list()用字符串形式返回目录下的全部文件。publicFile[]listFiles()用File对象形式返回目录下的全部文件。publicString[]list(FilenameFilterobj)该方法用字符串形式返回目录下的指定类型的所有文件。publicFile[]listFiles(FilenameFilterobj)该方法用File对象返回目录下的指定类型所有文件。当需要列出目录下指定类型文件如.java、.txt等时FilenameFilter是个接口publicinterfaceFilenameFilter{booleanaccept(File

dir,String

name)}list方法执行时不断回调接口方法，当返回true时将文件放入数组，故使用时需实现accept方法。参数name为目录中的文件名参数dir为调用list的当前对象3．文件的创建与删除当使用File类创建一个文件对象后文件对象调用方法：

publicbooleancreateNewFile()建立文件。文件对象调用方法：

publicbooleandelete()删除当前文件。importjava.io.*;publicclassDemoCreateFile{publicstaticvoidmain(String[]args){FiledirFile;FilecrateFile;booleandirExits;dirExits=false;try{dirFile=newFile("E:\\test");dirExits=dirFile.exists();if(dirExits==true){System.out.println("目录已经存在不需要创建");}else{System.out.println("目录不存在需要创建");dirExits=dirFile.mkdir();

if(dirExits==true){System.out.println("创建成功");}else{System.out.println("不能创建目录");System.exit(0);}}System.out.println("开始创建文件");crateFile=newFile("E:\\test\\letter.txt");dirExits=crateFile.createNewFile();}catch(IOExceptione){}if(dirExits==true)System.out.println("文件创建成功");}}crateFile=newFile("E:\\test","letter.txt");importjava.io.*;classFileAcceptimplementsFilenameFilter{Stringstr=null;FileAccept(Strings){str="."+s;}publicbooleanaccept(Filedir,Stringname){returnname.endsWith(str);}}列出指定类型文件和删除文件publicclassExample9_1{publicstaticvoidmain(Stringargs[]){Filedir=newFile("D:/ch8");FileAcceptacceptCondition=newFileAccept("java");FilefileName[]=dir.listFiles(acceptCondition);for(inti=0;i<fileName.length;i++){System.out.printf("\n文件名称:%s,长度:%d",fileName[i].getName(),fileName[i].length());}booleanboo=false;if(fileName.length>0)boo=fileName[0].delete();if(boo)System.out.printf("\n文件:%s被删除:",fileName[0].getName());}}不可写成D:\ch8，可以写D:\\ch8

4．运行可执行文件（Runtime类）创建Runtime类对象Runtimeec=Runtime.getRuntime();ec调用exec(Stringcommand)方法打开本地机的可执行文件或执行一个操作。importjava.io.*;publicclassExample9_2{publicstaticvoidmain(Stringargs[]){try{Runtimece=Runtime.getRuntime();ce.exec("javacExample9_1.java");Filefile=newFile("C:\\windows","Notepad.exe");ce.exec(file.getAbsolutePath());}catch(Exceptione){}}}9.2文件字节流FileInputStream类（InputStream子类）

构造方法：FileInputStream（Stringname）FileInputStream(Filefile)

try{FileInputStreamins=newFileInputStream(“myfile.dat”);}catch(IOExceptione){}try{Filef=newFile(“myfile.dat”);FileInputStreamistream=newFileInputStream(f);}catch(IOExceptione){}可能抛出FileNotFoundException方法：publicintread()throwsIOException

read方法从输入流中顺序读取单个字节的数据。该方法返回字节值，读取位置到达文件末尾则返回-1publicvoidclose()throwsIOException关闭此文件输入流并释放与此流有关的所有系统资源

publicintavailable()输入流中剩余字节数

publiclongskip(long

n)从输入流中跳过并丢弃n个字节的数据publicintread(byte[]

b)publicintread(byte[]

b,int

off,int

len)返回读取字节数2．FileOutputStream类构造方法：FileOutputStream（Stringname）FileOutputStream(Filefile)输出流通过使用write()方法把数据写入输出流到达目的地。写入时若文件存在则刷新，不存在创建。其它方法参考FileInputStreamwrite(int

b)write(byte[]

b)write(byte[]

b,int

off,int

len)抛出IOException可能抛出FileNotFoundExceptionimportjava.io.*;publicclassExample9_3{publicstaticvoidmain(Stringargs[]){Filefile=newFile("hello.txt");byteb[]="欢迎welcome".getBytes();try{FileOutputStreamout=newFileOutputStream(file);out.write(b);out.close();FileInputStreamin=newFileInputStream(file);intn=0;while((n=in.read(b,0,2))!=-1){Stringstr=newString(b,0,n);System.out.println(str);}}catch(IOExceptione){System.out.println(e);}}}while((n=in.read())!=-1){System.out.println((char)n);}作业显示Java源程序实现Java源程序的复制选作：按照16进制显示Java源程序，把显示结果另存为一个文件。3改进：参照UltraEdit样式显示源程序9.3文件字符流FileReader类(

Reader子类)构造方法：FileReader(

Stringname)FileReader(Filefile)可能抛出FileNotFoundExceptionintread()

从源中读取一个字符，该方法返回一个整数（Unicode字符值），如果未读出字符就返回-1。

intread(charb[])

从源中读取b.length个字符到字符数组b中，返回实际读取的字符数目。如果到达文件的末尾，则返回-1。intread(charb[],intoff,intlen)

从源中读取len个字符并存放到字符数组b中，返回实际读取的字符数目。如果到达文件的末尾，则返回-1。

2．FileWriter类构造方法：FileWriter（Stringname）FileWriter(Filefile)输出流通过使用write()方法把字符数据写入输出流到达目的地。可能抛出FileNotFoundExceptionwrite的用法：publicvoidwrite(charb[])程序写b.length个字符到输出流。publicvoid.write(charb[],intoff,intlen)程序从给定字符数组中起始于偏移量off处写len个字符到输出流，参数b是存放了数据的字符数组。voidwrite(Stringstr)程序把字符串中的全部字符写入到输出流。voidwrite(Stringstr,intoff,intlen)程序从字符串str中起始于偏移量off处写len个字符到输出流。importjava.io.*;publicclassExample9_4{publicstaticvoidmain(Stringargs[]){Filefile=newFile("hello.txt");charb[]="欢迎welcome".toCharArray();try{FileWriterout=newFileWriter(file);out.write(b);out.write("来到北京!");out.close();FileReaderin=newFileReader(file);intn=0;while((n=in.read(b,0,2))!=-1){Stringstr=newString(b,0,n);System.out.println(str);}in.close();}catch(IOExceptione){System.out.println(e);}}}while((n=in.read())!=-1){System.out.println((char)n);}作业显示Java源程序实现Java源程序的复制要求：使用Reader、Writer实现作业显示Java源程序实现Java源程序的复制要求：使用Reader、Writer实现9.4从键盘读取数据java.lang包中的System类有两个重要的类成员：in和out，分别是输入流和输出流类型的对象。in的源是键盘，in可以读取用户从键盘键入的数据。

Scanner类可以使用in初始化一个对象：Scannerreader=newScanner(System.in);

reader对象调用方法，读取用户在命令行输入的各种数据类型。out流的目的地是命令行窗口，out调用方法可以将数据送到命令行窗口。练习题目：从键盘读入x、y的值，显示x+y的结果分析输入：x、y计算：x+y输出：结果9.5缓冲流BufferedReader类构造方法：BufferedReader（Readerin）通过向BufferedReader传递一个Reader对象来创建一个BufferedReader对象。BufferedReader流除了有read()方法外，还能够读取文本行，使用方法readLine()。FileReaderinOne=newFileReader(“Student.txt”)；BufferedReaderinTwo=newBufferedReader(inOne)；2．BufferedWriter类构造方法：publicBufferedWriter(Writer

out)BufferedReader流常用方法：

voidwrite(Stringstr)voidwrite(Strings,intoff,intlen)把字符串s或s的一部分写入到目的地。voidflush()刷新该流的缓冲

voidnewLine()写入一个行分隔符。

FileWritertofile=newFileWriter("hello.txt");BufferedWriterout=newBufferedWriter(tofile);importjava.io.*;publicclassExample9_5{publicstaticvoidmain(Stringargs[]){ try{ FileReaderinOne=newFileReader("Student.txt");BufferedReaderinTwo=newBufferedReader(inOne);FileWritertofile=newFileWriter("hello.txt");BufferedWriterout=newBufferedWriter(tofile);Strings=null;inti=0;while((s=inTwo.readLine())!=null){i++;out.write(i+""+s);out.newLine();}

out.flush();out.close();tofile.close();inOne=newFileReader("hello.txt");inTwo=newBufferedReader(inOne);while((s=inTwo.readLine())!=null){System.out.println(s);}inOne.close();inTwo.close();}catch(IOExceptione){System.out.println(e);}}}练习题目：设计一个二进制文件复制的例子分析二进制文件与文本文件的异同复制的实现过程测试性能改进每次实现一块的复制9.6数组流字节输入流：ByteArrayInputStream字节输出流：ByteArrayOutputStream分别使用字节数组作为流的源和目标。ByteArrayInputStream流构造方法：ByteArrayInputStream(byte[]buf)ByteArrayInputStream(byte[]buf,intoffset,intlength)

数组字节流读写操作不会发生IOException异常ByteArrayOutputStream流的构造方法：

ByteArrayOutputStream()ByteArrayOutputStream(intsize)数组字节输出流调用publicbyte[]toByteArray()方法，可以返回输出流写入到缓冲区的全部字节。importjava.io.*;publicclassExample9_6{publicstaticvoidmain(Stringargs[]){intn=-1;ByteArrayOutputStreamout=newByteArrayOutputStream();for(inti=1;i<=127;i++){out.write(i);}ByteArrayInputStreamin=newByteArrayInputStream(out.toByteArray());while((n=in.read())!=-1){if(n%2==0){System.out.printf("\n");}System.out.printf("\t字节%d,对应字符\'%c\'",n,(char)n);}}}与数组字节流对应的是数组字符流：CharArrayReader与CharArrayWriter类。数组字符流分别使用字符数组作为流的源和目标。与数组字节流不同的是，数组字符流的读操作可能发生IOException异常。importjava.io.*;publicclassExample9_7{publicstaticvoidmain(Stringargs[]){intn=-1;CharArrayWriterout=newCharArrayWriter();for(inti=20320;i<=20520;i++){out.write(i);}CharArrayReaderin=newCharArrayReader(out.toCharArray());try{while((n=in.read())!=-1){if(n%2==0){System.out.printf("\n");}System.out.printf("\t位置%d,字符\'%c\'",n,(char)n);}}catch(IOExceptione){}}}9.7字符串流StringReader使用字符串作为流的源。构造方法：publicStringReader(Strings)方法：publicintread()publicintread(char[]buf,intoff,intlen)字符串输出流StringWriter将内存作为目的地。构造方法：publicStringWriter()publicStringWriter(int

initialSize)向缓冲区写入字符方法：publicvoidwrite(intb)publicvoidwrite(char[]b,intoff,intlen)publicvoidwrite(Stringstr)publicvoidwrite(Stringstr,intoff,intlen)publicStringtoString()返回输出流写入到缓冲区的全部字符；publicvoidflush()刷新缓冲区。9.8数据流1．DataInputStream类和DataOutputStream类数据输入流和数据输出流允许程序以与机器无关方式从底层输入流中读取基本Java数据类型。2．DataInputStream类和DataOutputStream的构造方法（1）DataInputStream（InputStreamin）将创建的数据输入流指向一个由参数in指定的输入流，以便从后者读取数据。（2）DataOutputStream（OutnputStreamout）将创建的数据输出流指向一个由参数out指定的输出流，然后通过这个数据输出流把Java数据类型的数据写到输出流out。

DataInputStream类和DataOutputStream类的常用方法。P184

importjava.io.*;publicclassExample9_8{publicstaticvoidmain(Stringargs[]){try{FileOutputStreamfos=newFileOutputStream("jerry.dat");DataOutpu