Java语言程序设计：JAVA-9-输入输出

输入/输出本章内容File类FileInputStream类与FileOutputStream类FileReader类与FileWriter类BufferedReader类与BufferedWriter类RandomAccessFile类DataInputStream类与DataOutputStream类ObjectInputStream类与ObjectOutputStream类序列化与克隆I/O流的基本原理与分类流：连接到文件的“管道”，分为输入流和输出流。Java应用程序使用输入流对象和输出流对象来完成数据的读写。广义文件：磁盘文件，键盘，显示器，网络等显示器打印机磁盘文件网络键盘鼠标Java程序向文件写数据从文件读数据输出流输入流形象地说，输入流对象和输出流对象是两个管道，当需要读写文件时就打开阀门（调用write()方法和read()方法）I/O流分类1根据数据的流动方向分为输入流与输出流2根据流处理的数据类型可分为字节流【二进制数据，声音图像等】与字符流【文本数据】。JDK1.5字节流字符流输入流InputStreamReader输出流OutputStreamWriter节点流与处理流根据流的功能层次分为节点流（底层流）与过滤流（上层流）

节点流一般用于直接从指定的位置进行读/写操作，例如磁盘文件，内存区域，网络连接等。过滤流（也称处理流）用于对其他输入/输出流进行封装，是面向用户的。在实际应用中，通常将节点流与过滤流结合起来使用。File类1File类是同文件或者目录相关的一个类。

File对象主要用来获取文件本身的一些信息，不涉及对文件的读写操作。2File类的构造函数：publicFile(Stringpathname)//使用pathname指定的路径创建一个File对象publicFile(Stringparent,Stringchild)//使用parent+child指定的路径创建一个File对象publicFile(Fileparent,Stringchild)//使用parent.toString()+child指定的路径创建一个File对象Java虚拟机是根据构造函数指定的字符串来和实际文件或文件夹关联。如果文件或文件夹存在，则关联成功，否则不发生关联。文件的属性File类的下列方法获取文件本身的一些信息。

publicStringgetName()

获取文件的名字。publicboolean

canRead()

判断文件是否是可读的。publicboolean

canWrite()

判断文件是否可被写入。publicbooleanexits()

判断文件是否存在。publiclonglength()

获取文件的长度（单位是字节）。publicStringgetAbsolutePath()获取文件的绝对路径。publicStringgetParent()获取文件的父目录。publicboolean

isFile()

判断文件是否是一个普通文件，而不是目录。publicboolean

isDirectroy()

判断文件是否是一个目录。publicboolean

isHidden()

判断文件是否是隐藏文件。publiclonglastModified()

获取文件最后修改的时间。File举例importjava.io.*;

publicclassE{ publicstaticvoidmain(String[]args){ Filef1=newFile(“D:\\3000\\a.java”);//假设不存在该文件 Filef2=newFile("c:\\1000"); System.out.println(f1.getName()+"的长度："+f1.length()); System.out.println(f1.getName()+"绝对路径：

"+f1.getAbsolutePath()); System.out.println(f2.getName()+“是文件吗："+f2.isFile()); } }a.java的长度：0a.java绝对路径：D:\3000\a.java1000是文件吗：falseimportjava.io.*;publicclassExample10_1{publicstaticvoidmain(String

args[]){Filef=newFile("C:\\ch10","Example10_1.java");

System.out.println(f.getName()+"是可读的吗:"+f.canRead());

System.out.println(f.getName()+"的长度:"+f.length());

System.out.println(f.getName()+"的绝对路径"+f.getAbsolutePath());

Filefile=newFile("new.txt");

System.out.println("在当前目录下创建新文件"+file.getName());

if(!file.exists()){try{

file.createNewFile();

System.out.println("创建成功");}

catch(IOExceptionexp){}}}}1．创建目录publicboolean

mkdir()2．列出目录中的文件

publicString[]list()

用字符串形式返回目录下的全部文件。

publicFile[]listFiles()

用File对象形式返回目录下的全部文件。

publicString[]list(FilenameFilter

obj)

用字符串形式返回目录下的指定类型的所有文件。

publicFile[]listFiles(FilenameFilter

obj)

用File对象形式返回目录下的指定类型所有文件。上述两方法的参数FilenameFilter是一个接口，该接口有一个方法：

publicbooleanaccept(Filedir,Stringname);目录当使用File类创建一个文件对象后，例如

Filefile=newFile("c:\\myletter","letter.txt");

◆如果c:\myletter目录中没有名字为letter.txt文件，文件对象file调用方法publicboolean

createNewFile();

可以在c:\myletter目录中建立一个名字为letter.txt的文件。

◆文件对象调用方法publicbooleandelete()

可以删除当前文件，例如：

file.delete();

文件的创建与删除文件与目录创建举例1importjava.io.*;publicclassB{publicstaticvoidmain(String[]args){Filef1=newFile("E:\\java\\a.java");try{

f1.createNewFile();}catch(Exceptione){}f1=newFile("E:\\java\\b.java");try{

f1.mkdir();}catch(Exceptione){}}}publicString[]list()//用字符串的形式返回目录下所有的文件publicString[]listFiles()//用File对象形式返回目录下的全部文件。publicString[]list(FilenameFilter

obj)//用字符串形式返回目录下的指定类型的所有文件。publicFile[]listFiles(FilenameFilter

obj)//用File对象形式返回目录下的指定类型所有文件。参数FilenameFilter是一个接口，该接口有一个方法：publicboolean

accept(File

dir,Stringname);列出目录中的文件importjava.io.*;classFileAcceptimplementsFilenameFilter{Stringstr=null;

FileAccept(Strings){

str="."+s;}publicboolean

accept(File

dir,Stringname){returnname.endsWith(str);}}举例publicclassExample9_1{publicstaticvoidmain(String

args[]){Filedir=newFile("D:/ch9);

//不可写成D:\ch9，可以写成D:\\ch9或D/ch9

FileAccept

acceptCondition=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());}}用Runtime类声明一个对象(Runtime类在java.lang包)

Runtimeec;然后使用该类的getRuntime()静态方法创建这个对象：

ec=Runtime.getRuntime();ec可以调用exec(Stringcommand)方法打开本地机的可执行文件或执行一个操作。运行可执行文件举例importjava.io.*;publicclassExample10_3{publicstaticvoidmain(String

args[]){try{Runtimece=Runtime.getRuntime();Filefile=newFile("c:/windows","Notepad.exe");

ce.exec(file.getAbsolutePath());file=newFile("C:\\ProgramFiles\\Internet

Explorer","IEXPLORE

");

ce.exec(file.getAbsolutePath());}

catch(Exceptione){

System.out.println(e);}}}文件流

java.io包提供了大量的流类，Java把InputStream抽象类的子类创建的流对象称作字节输入流、OutputStream抽象类的子类创建的流对象称作字节输出流，Java把Reader抽象类的子类创建的流对象称作字符输入流、Writer抽象类的子类创建的流对象称作字符输出流。针对不同的源或目的地，java.io包为程序提供了相应的输入流或输出流，这些输入、输出流绝大部分都是InputStream、OutputStream、Reader或Writer的子类。FileInputStream类

FileInputStream类是InputStream的子类，称为文件字节输入流。按字节读取文件中的数据。该类的所有方法都是从InputStream类继承来的。使用输入流通常包括4个基本步骤：(1)设定输入流的源(2)创建指向源的输入流(3)让输入流读取源中的数据(4)关闭输入流。1．构造方法

使用FileInputStream类的下列构造方法创建指向文件的输入流。

FileInputStream(Stringname);

FileInputStream(Filefile);参数name和file指定的文件称为输入流的源。

例如，为了读取一个名为myfile.dat的文件，建立一个文件输入流对象，代码如下：

try{FileInputStreamins=newFileInputStream("myfile.dat");}catch(IOExceptione){

System.out.println(e);}try{Filef=newFile("myfile.dat");

FileInputStream

istream=newFileInputStream(f);}catch(IOExceptione){

System.out.println(e);}2．使用输入流读取字节

文件字节流可以调用从父类继承的read方法顺序地读取文件，只要不关闭流，每次调用read方法就顺序地读取文件中的其余内容，直到文件的末尾或文件字节输入流被关闭。◆intread()

读取单个字节的数据，返回字节值（0~255整数），如果未读出字节就返回-1。◆

intread(byteb[])

读取b.length个字节到字节数组b中，返回实际读取的字节数。如果到达文件的末尾，则返回-1。◆

intread(byteb[],intoff,int

len)

读取len个字节到字节数组b中，并返回实际读取的字节数目。如果到达文件的末尾，则返回-1，参数off指定从字节数组的某个位置开始存放读取的数据。举例importjava.io.*;publicclassExample10_4{publicstaticvoidmain(String

args[]){

intn=-1;byte[]a=newbyte[100];try{Filef=newFile("Example10_4.java");

InputStreamin=newFileInputStream(f);

while((n=in.read(a,0,100))!=-1){Strings=newString(a,0,n);

System.out.print(s);}

in.close();}

catch(IOExceptione){

System.out.println("FilereadError"+e);}}}与FileInputStream类相对应的类是FileOutputStream类。

FileOutputStream提供了基本的文件写入能力，是OutputStream的子类，称为文件字节输出流。文件字节输出流按字节将数据写入到文件中。FileOutputStream类

使用输出流通常包括4个基本步骤：(1)给出输出流的目的地(2)创建指向目的地的输出流(3)让输出流把数据写入到目的地(4)关闭输出流。1．构造方法

使用FileOutputStream类的下列具有刷新功能的构造方法创建指向文件的输出流。FileOutputStream(Stringname);FileOutputStream(Filefile);参数name和file指定的文件称为输出流的目的地

输出流的wirie方法以字节单位向目的地写数据。

voidwrite(intn)

向目的地写入单个字节。

voidwrite(byteb[])

向目的地写入一个字节数组。

voidwrite(byteb[],int

off,int

len)

从字节数组中偏移量off处取len个字节写到目的地。FileOutputStream流顺序地写文件，只要不关闭流，每次调用write方法就顺序地向目的地写入内容，直到流被关闭。

2．使用输出流写字节

3．关闭流

通过调用close()方法，可以保证操作系统把流缓冲区的内容写到它的目的地，即关闭输出流可以把该流所用的缓冲区的内容冲洗掉(通常冲洗到磁盘文件上)。importjava.io.*;publicclassExample9_3{publicstaticvoidmain(String

args[]){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);}}}importjava.io.*;publicclassExample10_5{publicstaticvoidmain(String

args[]){byte[]a="新年快乐".getBytes();byte[]b="HappyNewYear".getBytes();Filefile=newFile("a.txt");//输出的目的地try{

OutputStreamout=newFileOutputStream(file);//指向目的地的输出流System.out.println(file.getName()+"的大小:"+file.length()+"字节");//0字节

out.write(a);//向目的地写数据

out.close();out=newFileOutputStream(file,true);//准备向文件尾加内容System.out.println(file.getName()+"的大小:"+file.length()+"字节");//8字节out.write(b,0,b.length);System.out.println(file.getName()+"的大小:"+file.length()+"字节");//22字节

out.close();}

catch(IOExceptione){

System.out.println("Error"+e);}}}

FileReader类是Reader的子类，称为文件字符输入流。文件字符输入流按字符读取文件中的数据。为了创建FileReader类的对象，可以使用下列构造方法：

FileReader(Stringname)和FileReader(Filefile)

。

构造方法参数指定的文件称为输入流的源，输入流通过使用read()方法从输入流读出源中的数据。

FileReader类

Reader类提供的read方法以字符为单位顺序地读取源中的数据。

◆intread()：输入流调用该方法从源中读取一个字符，该方法返回一个整数

.

◆intread(charb[])：输入流调用该方法从源中读取b.length个字符到字符数组b中，返回实际读取的字符数目。

◆intread(charb[],intoff,int

len)：输入流调用该方法从源中读取len个字符并存放到字符数组b中，返回实际读取的字符数目。FileWriter类

FileWriter提供了基本的文件写入能力。FileWriter类是Writer的子类，称为文件字符输出流。文件字符输出流按字符将数据写入到文件中。为了创建FileWriter类的对象，可以使用下列构造方法：

FileWriter(Stringname);

FileWriter(Filefile);：构造方法参数指定的文件称为输出流的目的地。

如果输出流指向的文件不存在，Java会创建该文件，如果文件已存在，输出流将刷新该文件（使得文件的长度为0）。

输出流使用write()方法把数据写入输出流到达目的地。◆

publicvoidwrite(charb[])——写b.length个字符到输出流。◆

publicvoid.write(charb[],int

off,int

len)——从给定字符数组中起始于偏移量off处写len个字符到输出流，参数b是存放了数据的字符数组。◆

voidwrite(Stringstr)——把字符串中的全部字符写入到输出流。◆

voidwrite(Stringstr,int

off,int

len)——从字符串str中起始于偏移量off处写len个字符到输出流。只要不关闭流，每次调用writer()方法就顺序地向文件写入内容，直到流被关闭.importjava.io.*;publicclassEample9_4{publicstaticvoidmain(String

args[]){Filefile=newFile("hello.txt");charb[]="欢迎welcome".toCharArray();try{FileWriterout=newFileWriter(file,true);

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);}}}importjava.io.*;publicclassExample10_6{publicstaticvoidmain(String

args[]){FilesourceFile=newFile("a.txt");//读取的文件FiletargetFile=newFile("b.txt");//写入的文件charc[]=newchar[19];//char型数组

try{Writerout=newFileWriter(targetFile,true);Readerin=newFileReader(sourceFile);

intn=-1;

while((n=in.read(c))!=-1){out.write(c,0,n);}

out.flush();

out.close();}

catch(IOExceptione){

System.out.println("Error"+e);}}

}importjava.io.*;publicclassE{

publicstaticvoidmain(String[]args){

chara[]="四月十二日10点发起总攻".toCharArray();

//转换为字符数组

intn=0,m=0;

try{

Filef=newFile("secret.txt");

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

a[i]=(char)(a[i]^'R');//按位异或，加密

FileWriterout=newFileWriter(f);

out.write(a,0,a.length);//将a中所有字符写到文件中

out.close();

FileReaderin=newFileReader(f);

chartom[]=newchar[10];

System.out.println("密文:");

while((n=in.read(tom,0,10))!=-1){

//一次读10个字符，放到数组中，n为实际读到字符的个数

Strings=newString(tom,0,n);//将字符数组转化为字符串

System.out.println(s);

}

in.close();

in=newFileReader(f);

System.out.println("开始解密：");

System.out.println("明文：");

while((n=in.read(tom,0,10))!=-1) {

for(inti=0;i<n;i++)

tom[i]=(char)(tom[i]^'R'); Strings=newString(tom,0,n);

System.out.println(s); }

in.close(); }catch(IOExceptione){

} } }能够以行为单位读写文件BufferedReader和BufferedWriter类创建的对象称作缓冲输入、输出流。二者的源和目的地必须是字符输入流和字符输出流。缓存文件底层流上层流缓冲流

BufferedReader类创建的对象称为缓冲输入流，该输入流的指向必须是一个Reader流，称为BufferedReader流的底层流，底层流负责将数据读入缓冲区。BufferedReader流的源就是这个缓冲区，缓冲输入流再从缓冲区中读取数据。将BufferedReader与FileReader连接，然后BufferedReader就可以按行读取FileReader指向的文件。◆

BufferedReader的构造方法如下BufferedReader(Readerin)◆

BufferedReader流能够读取文本行，方法是readLine()。◆可以向BufferedReader传递一个Reader对象（如FileReader的实例）来创建一个BufferedReader对象：

FileReader

inOne=newFileReader("Student.txt")

BufferedReader

inTwo=newBufferedReader(inOne);然后inTwo调用readLine()顺序读取文件“Student.txt”的一行。

BufferedReader类

可以将BufferedWriter流和FileWriter流连接在一起，然后使用BufferedWriter流将数据写到目的地。例如，

FileWriter

tofile=newFileWriter("hello.txt");

BufferedWriterout=newBufferedWriter(tofile);◆

BufferedReader流调用方法：

write(Stringstr)write(Strings,int

off,int

len)把字符串s或s的一部分写入到目的地。◆

BufferedWriter调用newLine()

向文件写入一个回行.◆BufferedWriter调用flush()

刷新缓冲区。BufferedWriter类

importjava.io.*;publicclassExample9_5{publicstaticvoidmain(String

args[]){FilereadFile=newFile("Student.txt"),

writeFile=newFile("Hello.txt");try{FileReader

inOne=newFileReader("Student.txt");

BufferedReader

inTwo=newBufferedReader(inOne);

FileWriter

tofile=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);}}}例如：test.txt是一套标准化考试的试题文件

.1.北京奥运是什么时间开幕的？

A.2008-08-08B.2008-08-01C.2008-10-01D.2008-07-08********************2.下列哪个国家不属于亚洲？

A.沙特B.印度C.巴西D.越南********************3.下列哪个国家最爱足球？

A.刚果B.越南C.老挝D.巴西********************4.下列哪种动物属于猫科动物？

A.鬣狗B.犀牛C.大象D.狮子********************使用输入流读取试题文件，每次显示试题文件中的一道题目。当读取到字符*时，暂停读取，等待用户从键盘输入答案。用户做完全部题目后，程序给出用户的得分。importjava.io.*;importjava.util.Scanner;publicclassExample9_6{publicstaticvoidmain(String

args[]){ScannerinputAnswer=newScanner(System.in);

intscore=0;

StringBufferanswer=newStringBuffer();//存放用户的回答Stringresult="ACDD";//存放正确的答案try{

FileReader

inOne=newFileReader("test.txt");

BufferedReader

inTwo=newBufferedReader(inOne);Strings=null;

while((s=inTwo.readLine())!=null){

if(!s.startsWith("*"))

System.out.println(s);else{

System.out.print("输入选择的答案(A,B,C,D):");Stringstr=inputAnswer.nextLine();

try{charc=str.charAt(0);

answer.append(c);}

catch(StringIndexOutOfBoundsExceptionexp){

answer.append("*");}}}

inOne.close();

inTwo.close();}

catch(IOExceptionexp){}

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

if(result.charAt(i)==answer.charAt(i)||

result.charAt(i)==answer.charAt(i)-32)score++;}

System.out.printf("最后的得分:%d\n",score);}}

例如：由英语句子构成的文件english.txt（每句占一行）：

Thearrowmissedthetarget.Theyrejectedtheuniondemand.Wheredoesthisroadgoto?按行读取english.txt

，并在该行的后面尾加上该英语句子中含有的单词数目，然后再将该行写入到一个名字为englishCount.txt的文件中。程序运行效果如图。importjava.io.*;importjava.util.*;publicclassExample10_7{publicstaticvoidmain(String

args[]){FilefRead=newFile("english.txt");FilefWrite=newFile("englishCount.txt");try{Writerout=newFileWriter(fWrite);

BufferedWriter

bufferWrite=newBufferedWriter(out);Readerin=newFileReader(fRead);

BufferedReader

bufferRead=newBufferedReader(in);Stringstr=null;

while((str=bufferRead.readLine())!=null){

StringTokenizer

fenxi=newStringTokenizer(str);

intcount=fenxi.countTokens();

str=str+"句子中单词个数:"+count;

bufferWrite.write(str);

bufferWrite.newLine();}

bufferWrite.close();

out.close();in=newFileReader(fWrite);

bufferRead=newBufferedReader(in);Strings=null;

System.out.println(fWrite.getName()+"内容:");

while((s=bufferRead.readLine())!=null){

System.out.println(s);}

bufferRead.close();

in.close();}

catch(IOExceptione){

System.out.println(e.toString());}}}publicDataInputStream(InputStreamin)创建的数据输入流指向一个由参数in指定的底层输入流publicDataOutputStream(OutputStreamout)创建的数据输出流指向一个由参数out指定的底层输出流数据流

DataInputStream和DataOutputStream类创建的对象称为数据输入流和数据输出流。构造方法:importjava.io.*;publicclassExample10_11{publicstaticvoidmain(String

args[]){Filefile=newFile("apple.txt");try{

FileOutputStream

fos=newFileOutputStream(file);

DataOutputStream

outData=newDataOutputStream(fos);outData.writeInt(100);outData.writeLong(123456);outData.writeFloat(3.1415926f);outData.writeDouble(987654321.1234);

outData.writeBoolean(true);

outData.writeChars("Howareyoudoing");}

catch(IOExceptione){}

try{

FileInputStream

fis=newFileInputStream(file);

DataInputStream

inData=newDataInputStream(fis);

System.out.println(inData.readInt());//读取int数据

System.out.println(inData.readLong());//读取long数据

System.out.println(+inData.readFloat());//读取float数据

System.out.println(inData.readDouble());//读取double数据

System.out.println(inData.readBoolean());//读取boolean数据charc='\0';

while((c=inData.readChar())!='\0'){//'\0'表示空字符。

System.out.print(c);}}

catch(IOExceptione){}}}对象流ObjectInputStream和ObjectOutputStream类创建的对象称为对象输入流和对象输出流。它的构造方法是：publicObjectInputStream(InputStreamin)publicObjectOutputStream(OutputStreamout)◆对象输出流调用writeObject(Object

obj)将一个对象obj写入输出流送往目的地

◆对象输入流调用readObject()从源中读取一个对象到程序中对象流只有序列化的对象才可以被写到文件中。如果类中有类类型的成员变量，则必须保证该成员变量对应的类也是可序列化的。序列化：一个类如果实现了Serializable接口，那么这个类创建的对象就是所谓序列化的对象。

importjava.io.*;publicclassTVimplementsSerializable{Stringname;

intprice;publicvoidsetName(Strings){name=s;}publicvoidsetPrice(intn){price=n;}publicStringgetName(){returnname;}publicint

getPrice(){returnprice;}}importjava.io.*;publicclassExample10_13{publicstaticvoidmain(String

args[]){TVchanghong=newTV();

changhong.setName("长虹电视");changhong.setPrice(5678);Filefile=newFile("television.txt");try{

FileOutputStream

fileOut=newFileOutputStream(file);

ObjectOutputStream

objectOut=newObjectOutputStream(fileOut);

objectOut.writeObject(changhong);

objectOut.close();

FileInputStream

fileIn=newFileInputStream(file);

ObjectInputStream

objectIn=newObjectInputStream(fileIn);

TVxinfei=(TV)objectIn.readObject();

objectIn.close();

xinfei.setName("新飞电视");xinfei.setPrice(6666);

System.out.println("changhong的名字:"+changhong.getName());

System.ou