文件和流

<!-- end of article title -->

文件和流

lingwen20 整理更新：2006-11-13 03:50:46版本: 1.0

<!--start of article content -->

文件和流
JavaI/O系统的类实在是太多了，这里我们只学习一些基本的和常用的，相信能够掌握这些就可以解决我们以后的普通应用了

1.什么是数据流?
数据流是指所有的数据通信通道
有两类流，InputStreamandOutputStream，Java中每一种流的基本功能依赖于它们
InputStream用于read,OutputStream用于write,读和写都是相对与内存说的，读就是从其他地方把数据拿进内存，写就是把数据从内存推出去
这两个都是抽象类，不能直接使用
2.InputStream的方法有：
read()从流中读入数据有3中方式：
intread()一次读一个字节
intread(byte[])读多个字节到数组中
intread(byte[],intoff,intlen)指定从数组的哪里开始，读多长
skip()跳过流中若干字节
available()返回流中可用字节数，但基于网络时无效，返回0
markSupported()判断是否支持标记与复位操作
mark()在流中标记一个位置，要与markSupported()连用
reset()返回标记过的位置
close()关闭流
3.OutputStream的方法:
write(int)写一个字节到流中
write(byte[])将数组中的内容写到流中
write(byte[],intoff,intlen)将数组中从off指定的位置开始len长度的数据写到流中
close()关闭流
flush()将缓冲区中的数据强制输出
4.File类
File可以表示文件也可以表示目录，File类控制所有硬盘操作
构造器：
File(Fileparent,Stringchild)用父类和文件名构造
File(Stringpathname)用绝对路径构造
File(Stringparent,Stringchild)用父目录和文件名构造
File(URIuri)用远程文件构造
常用方法：
booleancreateNewFile();
booleanexists();

例子：
//建立test.txt文件对象，判断是否存在，不存在就创建
importjava.io.*;

publicclassCreateNewFile{
publicstaticvoidmain(Stringargs[]){
Filef=newFile("test.txt");
try{
if(!f.exists())
f.createNewFile();
else
System.out.println("exists");
}catch(Exceptione){
e.printStackTrace();
}
}
}

booleanmkdir()/mkdirs()
booleanrenameTo(Filedestination)
例子：//看一下这mkdir()/mkdirs()的区别和renameTo的用法
importjava.io.*;
publicclassCreateDir{
publicstaticvoidmain(Stringargs[]){
Filef=newFile("test.txt");
Filef1=newFile("Dir");
Filef2=newFile("Top/Bottom");
Filef3=newFile("newTest.txt");
try{
f.renameTo(f3);
f1.mkdir();
f2.mkdirs();
}catch(Exceptione){
e.printStackTrace();
}
}
}

StringgetPath()/getAbsolutePath()
StringgetParent()/getName()
例子：//硬盘上并没有parent目录和test.txt文件，但我们仍然可以操作，因为我们创建了他们的对象，是对对象进行操作
importjava.io.*;
publicclassTest{
publicstaticvoidmain(Stringargs[]){
Filef=newFile("parent/test.txt");
Filef1=newFile("newTest.txt");
try{
System.out.println(f.getParent());
System.out.println(f.getName());
System.out.println(f1.getPath());
System.out.println(f1.getAbsolutePath());
}catch(Exceptione){
e.printStackTrace();
}
}
}

Stringlist[]//显示目录下所有文件
longlastModified()//返回1970.1.1到最后修改时间的秒数
booleanisDirectory()
例子：//列出目录下的所有文件和目录，最后修改时间，是目录的后面标出<DIR>,是文件的后面标出文件长度
importjava.io.*;
importjava.util.*;
publicclassDir{
publicstaticvoidmain(Stringargs[]){
Filef=newFile("Dir");
String[]listAll=null;
Filetemp=null;
try{
listAll=f.list();
for(inti=0;i<listAll.length;i++){
temp=newFile(listAll<i>);
System.out.print(listAll<i>+"/t");
if(temp.isDirectory())
System.out.print("/t<DIR>/t");
else
System.out.print(temp.length()+"/t");
System.out.println(newDate(temp.lastModified()));
}
}catch(Exceptione){
e.printStackTrace();
}
}
}



5.文件流的建立
Filef=newFile("temp.txt");
FileInputStreamin=newFileInputStream(f);
FileOutputStreamout=newFileOutputStream(f);

例子：文件拷贝
importjava.io.*;
publicclassCopy{
publicstaticvoidmain(Stringargs[]){
FileInputStreamfis=null;
FileOutputStreamfos=null;
try{
fis=newFileInputStream("c2.gif");
fos=newFileOutputStream("c2_copy.gif");
intc;
while((c=fis.read())!=-1)
fos.write(c);
}catch(Exceptione){
e.printStackTrace();
}finally{
if(fis!=null)try{fis.close();}catch(Exceptione){e.printStackTrace();}
if(fos!=null)try{fos.close();}catch(Exceptione){e.printStackTrace();}
}
}
}


6.缓冲区流
BufferedInputStream
BufferedOutputStream
他们是在普通文件流上加了缓冲的功能，所以构造他们时要先构造普通流
例子：文件拷贝的缓冲改进

importjava.io.*;
publicclassCopy{
publicstaticvoidmain(Stringargs[]){
BufferedInputStreambis=null;
BufferedOutputStreambos=null;
bytebuf[]=newbyte[100];
try{
bis=newBufferedInputStream(newFileInputStream("persia.mp3"));
bos=newBufferedOutputStream(newFileOutputStream("persia_copy.mp3"));
intlen=0;
while(true){
len=bis.read(buf);
if(len<=0)break;
bos.write(buf,0,len);
}
bos.flush();//缓冲区只有满时才会将数据输出到输出流，用flush()将未满的缓冲区中数据强制输出
}catch(Exceptione){
e.printStackTrace();
}finally{
if(bis!=null)try{bis.close();}catch(Exceptione){e.printStackTrace();}
if(bos!=null)try{bos.close();}catch(Exceptione){e.printStackTrace();}
}
}
}


7.原始型数据流
DataInputStream
DataOutputStream
他们是在普通流上加了读写原始型数据的功能，所以构造他们时要先构造普通流
方法：
readBoolean()/writeBoolean()
readByte()/writeByte()
readChar()/writeByte()
......

例子：//这个流比较简单，要注意的就是读时的顺序要和写时的一样
importjava.io.*;
publicclassDataOut{
publicstaticvoidmain(Stringargs[]){
DataOutputStreamdos=null;
try{
dos=newDataOutputStream(newFileOutputStream("dataout.txt"));
dos.writeInt(1);
dos.writeBoolean(true);
dos.writeLong(100L);
dos.writeChar('a');
}catch(Exceptione){
e.printStackTrace();
}finally{
if(dos!=null)
try{
dos.close();
}catch(Exceptione){
}
}
}
}

importjava.io.*;
publicclassDataIn{
publicstaticvoidmain(Stringargs[]){
DataInputStreamdis=null;
try{
dis=newDataInputStream(newFileInputStream("dataout.txt"));
System.out.println(dis.readInt());
System.out.println(dis.readBoolean());
System.out.println(dis.readLong());
System.out.println(dis.readChar());
}catch(Exceptione){
e.printStackTrace();
}finally{
if(dis!=null)
try{
dis.close();
}catch(Exceptione){
}
}
}
}

8.对象流
串行化：对象通过写出描述自己状态的数值来记述自己的过程叫串行话
对象流：能够输入输出对象的流
将串行化的对象通过对象流写入文件或传送到其他地方
对象流是在普通流上加了传输对象的功能，所以构造对象流时要先构造普通文件流
注意：只有实现了Serializable接口的类才能被串行化
例子：
importjava.io.*;
classStudentimplementsSerializable{
privateStringname;
privateintage;

publicStudent(Stringname,intage){
this.name=name;
this.age=age;
}

publicvoidgreeting(){
System.out.println("hello,mynameis"+name);
}

publicStringtoString(){
return"Student["+name+","+age+"]";
}
}
publicclassObjectOutTest{
publicstaticvoidmain(Stringargs[]){
ObjectOutputStreamoos=null;
try{
oos=newObjectOutputStream(
newFileOutputStream("student.txt"));
Students1=newStudent("Jerry",24);
Students2=newStudent("Andy",33);

oos.writeObject(s1);
oos.writeObject(s2);
}catch(Exceptione){
e.printStackTrace();
}finally{
if(oos!=null)
try{
oos.close();
}catch(Exceptione){
e.printStackTrace();
}
}
}
}

importjava.io.*;
publicclassObjectInTest{
publicstaticvoidmain(Stringargs[]){
ObjectInputStreamois=null;
Students=null;
try{
ois=newObjectInputStream(
newFileInputStream("student.txt"));
System.out.println("--------------------");
s=(Student)ois.readObject();
System.out.println(s);
s.greeting();
System.out.println("--------------------");
s=(Student)ois.readObject();
System.out.println(s);
s.greeting();
}catch(Exceptione){
e.printStackTrace();
}finally{
if(ois!=null)
try{
ois.close();
}catch(Exceptione){
e.printStackTrace();
}
}
}
}


9.字符流InputStreamReader/OutputStreamWriter
上面的几种流的单位是byte，所以叫做字节流，写入文件的都是二进制字节，我们无法直接看，下面要学习的是字节流
Java采用Unicode字符集，每个字符和汉字都采用2个字节进行编码，ASCII码是Unicode编码的自集
InputStreamReader是字节流到字符桥的桥梁（byte->char读取字节然后用特定字符集编码成字符)
OutputStreamWriter是字符流到字节流的桥梁（char->byte)
他们是在字节流的基础上加了桥梁作用，所以构造他们时要先构造普通文件流
我们常用的是:
BufferedReader方法：readLine()
PrintWriter方法：println()

例子：
importjava.io.*;
publicclassPrintWriterTest{
publicstaticvoidmain(Stringargs[]){
PrintWriterpw=null;
try{
pw=newPrintWriter(
newOutputStreamWriter(
newFileOutputStream("bufferedwriter.txt")));
pw.println("helloworld");
}catch(Exceptione){
e.printStackTrace();
}finally{
if(pw!=null)
try{
pw.close();
}catch(Exceptione){
e.printStackTrace();
}
}
}
}

importjava.io.*;
publicclassBufferedReaderTest{
publicstaticvoidmain(Stringargs[]){
BufferedReaderbr=null;
try{
br=newBufferedReader(
newInputStreamReader(
newFileInputStream("bufferedwriter.txt")));
System.out.println(br.readLine());
}catch(Exceptione){
e.printStackTrace();
}finally{
if(br!=null)
try{
br.close();
}catch(Exceptione){
e.printStackTrace();
}
}
}
}

10.随机存取文件RandomAccessFile
可同时完成读写操作
支持随机文件操作的方法:
readXXX()/writeXXX()
seek()将指针调到所需位置
getFilePointer()返回指针当前位置
length()返回文件长度
例子：把若干个32位的整数写到一个名为“temp.txt”的文件中,然后利用seek方法,以相反的顺序再读取这些数据
importjava.io.*;
publicclassRandomFile{
publicstaticvoidmain(Stringargs[]){
RandomAccessFileraf=null;
intdata[]={12,31,56,23,27,1,43,65,4,99};
try{
raf=newRandomAccessFile("temp.txt","rw");
for(inti=0;i<data.length;i++)
raf.writeInt(data<i>);
for(inti=data.length-1;i>=0;i--){
raf.seek(i*4);
System.out.println(raf.readInt());
}
}catch(Exceptione){
e.getMessage();
}finally{
if(raf!=null)
try{
raf.close();
}catch(Exceptione){
e.getMessage();
}
}
}
}