您的位置：首页 > 编程语言 > Java开发

java Io 全解

2015-10-28 21:38 471 查看

java.lang.Object

java.io.File

boolean	canRead() 测试应用程序是否可以读取此抽象路径名表示的文件。
boolean	canWrite() 测试应用程序是否可以修改此抽象路径名表示的文件。
int	compareTo(Filepathname) 按字母顺序比较两个抽象路径名。
boolean	createNewFile() 当且仅当不存在具有此抽象路径名指定的名称的文件时，原子地创建由此抽象路径名指定的一个新的空文件。
staticFile	createTempFile(Stringprefix,Stringsuffix) 在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。
staticFile	createTempFile(Stringprefix,Stringsuffix,Filedirectory) 在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。
boolean	delete() 删除此抽象路径名表示的文件或目录。
void	deleteOnExit() 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。
boolean	equals(Objectobj) 测试此抽象路径名与给定对象是否相等。
boolean	exists() 测试此抽象路径名表示的文件或目录是否存在。
File	getAbsoluteFile() 返回抽象路径名的绝对路径名形式。
String	getAbsolutePath() 返回抽象路径名的绝对路径名字符串。
File	getCanonicalFile() 返回此抽象路径名的规范形式。
String	getCanonicalPath() 返回抽象路径名的规范路径名字符串。
String	getName() 返回由此抽象路径名表示的文件或目录的名称。
String	getParent() 返回此抽象路径名的父路径名的路径名字符串，如果此路径名没有指定父目录，则返回null。
File	getParentFile() 返回此抽象路径名的父路径名的抽象路径名，如果此路径名没有指定父目录，则返回null。
String	getPath() 将此抽象路径名转换为一个路径名字符串。
int	hashCode() 计算此抽象路径名的哈希码。
boolean	isAbsolute() 测试此抽象路径名是否为绝对路径名。
boolean	isDirectory() 测试此抽象路径名表示的文件是否是一个目录。
boolean	isFile() 测试此抽象路径名表示的文件是否是一个标准文件。
boolean	isHidden() 测试此抽象路径名指定的文件是否是一个隐藏文件。
long	lastModified() 返回此抽象路径名表示的文件最后一次被修改的时间。
long	length() 返回由此抽象路径名表示的文件的长度。
String[]	list() 返回由此抽象路径名所表示的目录中的文件和目录的名称所组成字符串数组。
String[]	list(FilenameFilterfilter) 返回由包含在目录中的文件和目录的名称所组成的字符串数组，这一目录是通过满足指定过滤器的抽象路径名来表示的。
File[]	listFiles() 返回一个抽象路径名数组，这些路径名表示此抽象路径名所表示目录中的文件。
File[]	listFiles(FileFilterfilter) 返回表示此抽象路径名所表示目录中的文件和目录的抽象路径名数组，这些路径名满足特定过滤器。
File[]	listFiles(FilenameFilterfilter) 返回表示此抽象路径名所表示目录中的文件和目录的抽象路径名数组，这些路径名满足特定过滤器。
staticFile[]	listRoots() 列出可用的文件系统根目录。
boolean	mkdir() 创建此抽象路径名指定的目录。
boolean	mkdirs() 创建此抽象路径名指定的目录，包括创建必需但不存在的父目录。
boolean	renameTo(Filedest) 重新命名此抽象路径名表示的文件。
boolean	setLastModified(longtime) 设置由此抽象路径名所指定的文件或目录的最后一次修改时间。
boolean	setReadOnly() 标记此抽象路径名指定的文件或目录，以便只可对其进行读操作。
String	toString() 返回此抽象路径名的路径名字符串。
URI	toURI() 构造一个表示此抽象路径名的file:URI。
URL	toURL() 将此抽象路径名转换成一个file:URL。

FileDemo

importjava.util.*;
importjava.io.*;
publicclassFileDemo{
publicstaticvoidmain(String[]args)throwsIOException{
Scannerscan=newScanner(System.in);
System.out.println("请输入文件或文件夹路径!");
Stringpath=scan.next();
Filefile=newFile(path);
if(file.isFile()){
System.out.printf("%s是文件\n",file.getName());
System.out.printf("%s文件%s\n",file.getName(),file.canRead()?"可读":"不可读");
System.out.printf("%s文件%s\n",file.getName(),file.canWrite()?"可写":"不可写");
System.out.printf("该文件为%d个字节\n",file.length());
}elseif(file.isDirectory()){
List<File>fileList=newArrayList<File>();
System.out.printf("%s是文件夹\n",file.getName());
File[]files=file.listFiles();
for(FiletempFile:files){
if(tempFile.isFile()){
fileList.add(tempFile);
//System.out.printf("%s\n",tempFile.getName());
}else{
System.out.printf("&&&&[%s]&&&\n",tempFile.getName());
}
}
for(Filetemfile:fileList){
System.out.printf("%s\n",temfile.getName());
}
}else{
System.out.printf("%s文件不存在",file.getName());
file.mkdirs();

}
}
}

java.lang.Object


java.io.RandomAccessFile

一个字符两个字节
一个字节八位
Int类型占4个字节
文件存取通常是循序的,每在文件中存取一次,文件的读取位置就会相对于目前的位置前进一次.然而有时必须制定文件的某个区段进行读取或写入的动作,也就是进行随机存取(RandomAccess),即要能在文件中随意第移动读取位置.这时可以使用RandomAccessFile,使用它的seek()方法来指定文件存取的位置,指定的单位是字节.
为了移动存取位置时的方便,通常在随机存取文件中会固定每一个数据的长度.例如长度固定为每一个学生个人的数据,Java中并没有直接的方法可以写入一个固定长度数据,所以在固定每一个长度方面必须自行设计.

Filefile=newFile(args[0]);
//建立RandomAccessFile实例并以读写模式开启文件
RandomAccessFilerandomAccessFile=newRandomAccessFile(file,"rw");
for(inti=0;i<students.length;i++){
//使用对应的write方法写入数据
randomAccessFile.writeChars(students[i].getName());
randomAccessFile.writeInt(students[i].getScore());
}

//使用seek()方法操作存取位置
randomAccessFile.seek((num-1)*Student.size());
Studentstuent=newStudent();
//使用对应的read方法读出数据
stuent.setName(readName(randomAccessFile));
stuent.setScore(randomAccessFile.readInt());
System.out.println("姓名:"+student.getName());
System.out.println("分数:"+student.getScore());
//设定关闭文件
randomAccessFile.close();
privatestaticStringreadName(RandomAccessFilerandomAccessfile)throwsIOException{
char[]name=newchar[15];
for(inti=0;i<name.length;i++)
name[i]=randomAccessfile.readChar();
//将空字符取代为空格符并传回
returnnewString(name).replace('\0','');
}

java.lang.StringBuilder

用来累加字符串,一个可变的字符序列。此类提供一个与
StringBuffer
兼容的API，但不保证同步。该类被设计用作
StringBuffer
的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比
StringBuffer
要快。
在
StringBuilder
上的主要操作是
append
和
insert
方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串生成器中。
append
方法始终将这些字符添加到生成器的末端；而
insert
方法则在指定的点添加字符。
例如，如果
z
引用一个当前内容为"
start
"的字符串的生成器对象，则该方法调用
z.append("le")
将使字符串生成器包含"
startle
"，而
z.insert(4, "le")
将更改字符串生成器，使之包含"
starlet
"。

void	close() 关闭此随机存取文件流并释放与该流关联的所有系统资源。
FileChannel	getChannel() 返回与此文件关联的惟一FileChannel对象。
FileDescriptor	getFD() 返回与此流关联的不透明文件描述符对象。
long	getFilePointer() 返回此文件中的当前偏移量。
long	length() 返回此文件的长度。
int	read() 从此文件中读取一个数据字节。
int	read(byte[]b) 将最多b.length个数据字节从此文件读入字节数组。
int	read(byte[]b, intoff,intlen) 将最多len个数据字节从此文件读入字节数组。
boolean	readBoolean() 从此文件读取一个boolean。
byte	readByte() 从此文件读取一个有符号的八位值。
char	readChar() 从此文件读取一个Unicode字符。
double	readDouble() 从此文件读取一个double。
float	readFloat() 从此文件读取一个float。
void	readFully(byte[]b) 将b.length个字节从此文件读入字节数组，并从当前文件指针开始。
void	readFully(byte[]b, intoff,intlen) 将正好len个字节从此文件读入字节数组，并从当前文件指针开始。
int	readInt() 从此文件读取一个有符号的32位整数。
String	readLine() 从此文件读取文本的下一行。
long	readLong() 从此文件读取一个有符号的64位整数。
short	readShort() 从此文件读取一个有符号的16位数。
int	readUnsignedByte() 从此文件读取一个无符号的八位数。
int	readUnsignedShort() 从此文件读取一个无符号的16位数。
String	readUTF() 从此文件读取一个字符串。
void	seek(longpos) 设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作。
void	setLength(longnewLength) 设置此文件的长度。
int	skipBytes(intn) 尝试跳过输入的n个字节以丢弃跳过的字节。
void	write(byte[]b) 将b.length个字节从指定字节数组写入到此文件，并从当前文件指针开始。
void	write(byte[]b, intoff,intlen) 将len个字节从指定字节数组写入到此文件，并从偏移量off处开始。
void	write(intb) 向此文件写入指定的字节。
void	writeBoolean(booleanv) 按单字节值将boolean写入该文件。
void	writeByte(intv) 按单字节值将byte写入该文件。
void	writeBytes(Strings) 按字节序列将该字符串写入该文件。
void	writeChar(intv) 按双字节值将char写入该文件，先写高字节。
void	writeChars(Strings) 按字符序列将一个字符串写入该文件。
void	writeDouble(doublev) 使用Double类中的doubleToLongBits方法将双精度参数转换为一个long，然后按八字节数量将该long值写入该文件，先定高字节。
void	writeFloat(floatv) 使用Float类中的floatToIntBits方法将浮点参数转换为一个int，然后按四字节数量将该int值写入该文件，先写高字节。
void	writeInt(intv) 按四个字节将int写入该文件，先写高字节。
void	writeLong(longv) 按八个字节将long写入该文件，先写高字节。
void	writeShort(intv) 按两个字节将short写入该文件，先写高字节。
void	writeUTF(Stringstr) 使用modified UTF-8编码以与机器无关的方式将一个字符串写入该文件。

RandomAccessFileDemo

importjava.util.*;
importjava.io.*;
publicclassRandomAccessFileDemo{
publicstaticvoidmain(String[]args)throwsFileNotFoundException,IOException{
Students1=newStudent("tom",20);
Students2=newStudent("Jack",30);
Students3=newStudent("zhang3",20);
Students4=newStudent("Liudehua",10);
Student[]students={s1,s2,s3,s4};
Scannerscan=newScanner(System.in);
System.out.println("请输入一个文件路径!");
Stringpath=scan.next();
//RandomAccessFile工具,与File文件建立关联,即打开File文件,以RW(读写)形式打开
RandomAccessFileraf=newRandomAccessFile(newFile(path),"rw");
for(Studentstudent:students){
raf.writeChars(student.getName());
raf.writeInt(student.getAge());
}

System.out.println("请选择1-4的学生");
intcount=scan.nextInt();
raf.seek((count-1)*Student.getSize());
char[]chars=newchar[10];
for(inti=0;i<10;i++){
chars[i]=raf.readChar();
}
Stringname=String.valueOf(chars);
intage=raf.readInt();
System.out.printf("第%d个学生的名字为%s,年龄为%d",count,name,age);
raf.close();
}
}

java.lang.Object


java.io.InputStream

java.io.InputStream与java.io.OutputStream

计算机中的数据都是以0与1的方式来存储,如果要在两个装置之间进行数据的存取,当然也是以0与1位的方式来进行,Java将数据于目的地及来源之间的流动抽象华为一个流(Stream),而流当中流动的则是位数据.
流里面放的都是0和1,由于位是由于0和1来表示的,所以叫做位流.
数据流动抽象化为一个串流(Stream)
InputStream是所有表示位输入串流的类之父类
System中的标准输入串流in对象就是一个InputStream类型的实例
OutputSream是所有表示位输出串流的类之父类
System中的标准输出串流对象out其类型是java.io.PrintSream,OutputStream的子类.
很少直接操作InputStream货OutputStream上的方法,这些方法比较低阶
通常会操作它们的子类:
System.out.println(“输入字符十进制表示:”+System.in.read());
建立FileInputSream或FileOutputStream的实例时,必须制定文件位置及文件名,实例被创建时文件的串流就会开启.
不适用串流时,必须关闭文件串流,以释放与串流相依的系统资源.

FileInputStreamfileInputStream=newFileInputStream(newFile(srgs[0]));
FileOutputStreamfileOutputStream=newFileOutputStream(newFile(args[1]));
...
fileInputStream.close();
fileOutputStream.close();

while(true)
{
if(fileInputStream.available()<1024)
{
//剩余的资料比1024少
//一位一位读出再写入目标文件
intremain=-1;
while((remain=fileInputStream.read())!=-1)
{
fileOutputStream.write(remain);
}
break;
}else
{
//从来源文件读取数据至缓存区
fileInputStream.read(buffer);
//将数组数据写入目标文件
fileOutputStream.write(buffer);
}
}

类FileInputStream方法摘要

int	available () 返回可以不受阻塞地从此文件输入流中读取的字节数。
void	close () 关闭此文件输入流并释放与此流有关的所有系统资源。
protected void	finalize () 确保在不再引用文件输入流时调用其 close 方法。
FileChannel	getChannel () 返回与此文件输入流有关的惟一 FileChannel 对象。
FileDescriptor	getFD () 返回表示到文件系统中实际文件的连接的 FileDescriptor 对象，该文件系统正被此 FileInputStream 使用。
int	read () 从此输入流中读取一个数据字节。
int	read (byte[]b) 从此输入流中将最多 b.length 个字节的数据读入一个字节数组中。
int	read (byte[]b, intoff,intlen) 从此输入流中将最多 len 个字节的数据读入一个字节数组中。
long	skip (longn) 从输入流中跳过并丢弃 n 个字节的数据。

类FileOutputStream方法摘要

void	close () 关闭此文件输出流并释放与此流有关的所有系统资源。
protected void	finalize () 清理到文件的连接，并确保在不再引用此文件输出流时调用此流的 close 方法。
FileChannel	getChannel () 返回与此文件输出流有关的惟一 FileChannel 对象。
FileDescriptor	getFD () 返回与此流有关的文件描述符。
void	write (byte[]b) 将 b.length 个字节从指定字节数组写入此文件输出流中。
void	write (byte[]b, intoff,intlen) 将指定字节数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
void	write (intb) 将指定字节写入此文件输出流。

importjava.util.*;
importjava.io.*;
publicclassFileStreamDemo{
publicstaticvoidmain(String[]args)throwsFileNotFoundException,IOException{
Scannerscan=newScanner(System.in);
System.out.println("请输入你要复制的文件");
StringinPath=scan.next();
System.out.println("请输入你要复制到哪里");
StringoutPath=scan.next();
FileinFile=newFile(inPath);
//创建FileInputStream对象,与FIle文件关联;
FileInputStreamfis=newFileInputStream(inFile);
//创建FileOutputStream对象,与outPath文件关联;
FileOutputStreamfos=newFileOutputStream(newFile(outPath));
System.out.println("开始复制");
longstartTime=System.currentTimeMillis();
/*for(inti=0;i<=inFile.length();i++){
intflag=fis.read();
fos.write(flag);
}*/
/*intflag=-1;
while((flag=fis.read())>=0){
fos.write(flag);
}*/
byte[]buffer=newbyte[1024*20];
while(true){
if(fis.available()<1024*20){
intflag=fis.read();
if(flag<0)break;
fos.write(flag);
}
fis.read(buffer);
fos.write(buffer);
}
longendTime=System.currentTimeMillis();
System.out.println("复制完毕");
System.out.printf("用时%d",endTime-startTime);
fis.close();
fos.close();
}
}

java.io.InputStream


java.io.FilterInputStream

BufferedInputStream与BufferedOutputStream

BufferedInputStream的资料成员buf是个位数组,默认为2048字节

BufferedOutputStream的资料成员buf是个位数组,默认为512个字节.

BufferedInputStreambufferedInputStream=newBufferedInputStream(newFileInputStream(srcFile));
BufferedOutputStreambufferedOutputStream=newBufferedOutputStream(newFileOutputStream(desFile));
System.out.println("复制文件:"+srcFile.length()+"字节");
while(bufferedInputStream.read(data)!=-1){
bufferedOutputStream.write(data);
}
//将缓冲区中的数据全部写出
bufferedOutputStream.flush();
//关闭串流
bufferedInputStream.close();
bufferedOutputStream.close();

类BufferedInputStream方法摘要

int	available () 返回可以不受阻塞地从此输入流读取的字节数。
void	close () 关闭此输入流并释放与该流关联的所有系统资源。
void	mark (intreadlimit) 参见 InputStream 的 mark 方法的常规协定。
boolean	markSupported () 测试此输入流是否支持 mark 和 reset 方法。
int	read () 参见 InputStream 的 read 方法的常规协定。
int	read (byte[]b, intoff,intlen) 在此字节输入流中从给定的偏移量开始将各字节读取到指定的byte数组中。
void	reset () 参见 InputStream 的 reset 方法的常规协定。
long	skip (longn) 参见 InputStream 的 skip 方法的常规协定。

类BufferedOutputStream方法摘要

void

flush

()

刷新此缓冲的输出流。

void

write

(byte[]b,
intoff,intlen)

将指定byte数组中从偏移量

off

开始的

len

个字节写入此缓冲的输出流。

void

write

(intb)

将指定的字节写入此缓冲的输出流。

importjava.util.*;
importjava.io.*;
publicclassBufferedStreamDemo{
publicstaticvoidmain(String[]args)throwsFileNotFoundException,IOException{
Scannerscan=newScanner(System.in);
System.out.println("请输入文件路径!");
StringinPath=scan.next();
System.out.println("请输入存放路径!");
StringoutPath=scan.next();
FileinFile=newFile(inPath);

BufferedInputStreambin=newBufferedInputStream(newFileInputStream(newFile(inPath)));
BufferedOutputStreambout=newBufferedOutputStream(newFileOutputStream(newFile(outPath)));
System.out.println("开始复制");
longstartTime=System.currentTimeMillis();
byte[]data=newbyte[1];
while((bin.read(data))!=-1){
bout.write(data);
}
longendTime=System.currentTimeMillis();
System.out.println("复制完毕");
System.out.printf("用时%d秒",(endTime-startTime)/1000);
bin.close();
bout.close();
}
}

java.io.InputStream


java.io.FilterInputStream

DataInputStream与DataOutputStream

主要是对java的基本数据类型,以及字符串提供的一些读写操作
数据输出流允许应用程序以适当方式将基本Java数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

提供一些对java基本数据型态写入的方法

DataOutputStreamdataOutputStream=newDataOutputStream(newFileOutputStream(args[0]));
for(Membermember:member)
{
//写入UTF字符串
dataOutputStream.writeUTF(member.getName());
//写入int资料
dataOutputStream.writeInt(member.getAge());
}
//清除所有数据至目的地
dataOutputStream.flush();
//关闭串流
dataOutputStream.close();

DataInputStreamdataInputStream=newDataInputStream(newFileInputStream(args[0]));
//读出数据并还原为对象
for(inti=0;i<members.length;i++){
//读出UTF字符串
Stringname=dataInputStream.readUTF();
//读出int资料
intscore=dataInputStream.readInt();
members[i]=newmember(name,score);
}
//关闭串流
dataInputStream.close();

类DataInputStream方法摘要

int	read (byte[]b) 从所包含的输入流中读取一定数量的字节，并将它们存储到缓冲区数组 b 中。
int	read (byte[]b, intoff,intlen) 从所包含的输入流中将 len 个字节读入一个字节数组中。
boolean	readBoolean () 参见 DataInput 的 readBoolean 方法的常规协定。
byte	readByte () 参见 DataInput 的 readByte 方法的常规协定。
char	readChar () 参见 DataInput 的 readChar 方法的常规协定。
double	readDouble () 参见 DataInput 的 readDouble 方法的常规协定。
float	readFloat () 参见 DataInput 的 readFloat 方法的常规协定。
void	readFully (byte[]b) 参见 DataInput 的 readFully 方法的常规协定。
void	readFully (byte[]b, intoff,intlen) 参见 DataInput 的 readFully 方法的常规协定。
int	readInt () 参见 DataInput 的 readInt 方法的常规协定。
String	readLine () 已过时。该方法无法将字节正确转换为字符。从JDK1.1开始，读取文本行的首选方法是使用 BufferedReader.readLine() 方法。对于使用 DataInputStream 类读取文本行的程序，可以转而使用 BufferedReader 类，实现方式是通过将以下形式的代码： DataInputStreamd=newDataInputStream(in); 替换为： BufferedReaderd =newBufferedReader(newInputStreamReader(in));
long	readLong () 参见 DataInput 的 readLong 方法的常规协定。
short	readShort () 参见 DataInput 的 readShort 方法的常规协定。
int	readUnsignedByte () 参见 DataInput 的 readUnsignedByte 方法的常规协定。
int	readUnsignedShort () 参见 DataInput 的 readUnsignedShort 方法的常规协定。
String	readUTF () 参见 DataInput 的 readUTF 方法的常规协定。
static String	readUTF ( DataInput in) 从流 in 中读取用UTF-8修改版格式编码的Unicode字符格式的字符串；然后以 String 形式返回此字符串。
int	skipBytes (intn) 参见 DataInput 的 skipBytes 方法的常规协定。

类DataOutputStream方法摘要

void	flush () 清空此数据输出流。
int	size () 返回计数器 written 的当前值，即到目前为止写入此数据输出流的字节数。
void	write (byte[]b, intoff,intlen) 将指定字节数组中从偏移量 off 开始的 len 个字节写入基础输出流。
void	write (intb) 将指定字节（参数 b 的八个低位）写入基础输出流。
void	writeBoolean (booleanv) 将一个 boolean 值以1-byte值形式写入基础输出流。
void	writeByte (intv) 将一个 byte 值以1-byte值形式写出到基础输出流中。
void	writeBytes ( String s) 将字符串按字节顺序写出到基础输出流中。
void	writeChar (intv) 将一个 char 值以2-byte值形式写入基础输出流中，先写入高字节。
void	writeChars ( String s) 将字符串按字符顺序写入基础输出流。
void	writeDouble (doublev) 使用 Double 类中的 doubleToLongBits 方法将double参数转换为一个 long 值，然后将该 long 值以8-byte值形式写入基础输出流中，先写入高字节。
void	writeFloat (floatv) 使用 Float 类中的 floatToIntBits 方法将float参数转换为一个 int 值，然后将该 int 值以4-byte值形式写入基础输出流中，先写入高字节。
void	writeInt (intv) 将一个 int 值以4-byte值形式写入基础输出流中，先写入高字节。
void	writeLong (longv) 将一个 long 值以8-byte值形式写入基础输出流中，先写入高字节。
void	writeShort (intv) 将一个 short 值以2-byte值形式写入基础输出流中，先写入高字节。
void	writeUTF ( String str) 以与机器无关方式使用UTF-8修改版编码将一个字符串写入基础输出流。

importjava.util.*;
importjava.io.*;
publicclassDataStreamDemo{
publicstaticvoidmain(String[]args)throwsException{
Students1=newStudent("Aldrich",25);
Students2=newStudent("zhangsan",34);
Students3=newStudent("lisi",23);
Students4=newStudent("wangwu",12);
Students5=newStudent("zhaoliu",21);
Student[]Students={s1,s2,s3,s4,s5};
Scannerscan=newScanner(System.in);
System.out.println("请输入一个文件!");
Stringpath=scan.next();
DataOutputStreamdout=newDataOutputStream(newFileOutputStream(newFile(path)));
DataInputStreamdin=newDataInputStream(newFileInputStream(newFile(path)));
for(Studentstudent:Students){
dout.writeUTF(student.getName());
dout.writeInt(student.getAge());
}
dout.flush();
for(inti=0;i<5;i++){
Stringname=din.readUTF();
intage=din.readInt();
System.out.printf("第%d个学生的名字为%s,年龄是%d\n",i+1,name,age);
}
din.close();
dout.close();
}
}

java.io.InputStream

ObjectInputStream与ObjectOutputStream

ObjectOutputStream将Java对象的基本数据类型和图形写入OutputStream。可以使用ObjectInputStream读取（重构）对象。通过使用流中的文件可以实现对象的持久存储。如果流是网络套接字流，则可以在另一台主机上或另一个进程中重构对象。
ObjectInputStream对以前使用ObjectOutputStream写入的基本数据和对象进行反序列化。
对对象直接进行读写操作
把能够实现Serializable接口的对象,表示这个对象可序列化或可串行化的
要直接储存对象,定义该对象的类必须实现java.io.Serializable接口
publicclassUserimplementsSerializable
{
privatestaticfinallongserialVersionUID=1L;
...
}
serialVersionUID代表了可串行化对象版本,从文件读回对象时两个对象的serialVersionUID不相同的话,就会丢出java.io.InvalidClassException

类ObjectInputStream方法摘要

int	available () 返回可以不受阻塞地读取的字节数。
void	close () 关闭输入流。
void	defaultReadObject () 从此流读取当前类的非静态和非瞬态字段。
protected boolean	enableResolveObject (booleanenable) 启用允许从要替代的流读取对象的流。
int	read () 读取数据字节。
int	read (byte[]buf, intoff,intlen) 读入字节数组。
boolean	readBoolean () 以boolean形式读取。
byte	readByte () 读取一个8位的字节。
char	readChar () 读取一个16位的char值。
protected ObjectStreamClass	readClassDescriptor () 从序列化流读取类描述符。
double	readDouble () 读取一个64位的double值。
ObjectInputStream.GetField	readFields () 按名称从流中读取持久字段并使其可用。
float	readFloat () 读取一个32位的float值。
void	readFully (byte[]buf) 读取字节，在读取所有字节前将发生阻塞。
void	readFully (byte[]buf, intoff,intlen) 读取字节，在读取所有字节之前将发生阻塞。
int	readInt () 读取一个32位的int值。
String	readLine () 已过时。此方法不能正确地将字节转换为字符。请参见DataInputStream以获取详细信息和替代方法。
long	readLong () 读取一个64位的long值。
Object	readObject () 从ObjectInputStream读取对象。
protected Object	readObjectOverride () 此方法由使用受保护的无参数构造方法构造ObjectOutputStream的ObjectOutputStream的受信任子类调用。
short	readShort () 读取一个16位的short值。
protected void	readStreamHeader () 提供的readStreamHeader方法允许子类读取并验证它们自己的流头部。
Object	readUnshared () 从ObjectInputStream读取“非共享”对象。
int	readUnsignedByte () 读取一个无符号的8位字节。
int	readUnsignedShort () 读取一个无符号的16位short值。
String	readUTF () 读取UTF-8修改版格式的String。
void	registerValidation ( ObjectInputValidation obj, intprio) 在返回图形前注册要验证的对象。
protected Class <?>	resolveClass ( ObjectStreamClass desc) 加载指定流类描述的本地等价类。
protected Object	resolveObject ( Object obj) 在反序列化期间，此方法允许ObjectInputStream的受信任子类使用一个对象替代另一个。
protected Class <?>	resolveProxyClass ( String []interfaces) 返回一个代理类，该类实现在代理类描述符中命名的接口；子类可以实现此方法，以便从流及动态代理类的描述符中读取自定义数据，允许它们使用接口和代理类的替换加载机制。
int	skipBytes (intlen) 跳过字节，在跳过所有字节之前将发生阻塞。

类ObjectOutputStream方法摘要

protected void	annotateClass ( Class <?>cl) 子类可以实现此方法，从而允许在流中存储类数据。
protected void	annotateProxyClass ( Class <?>cl) 一些子类可以实现此方法，从而在流中存储定制数据和动态代理类的描述符。
void	close () 关闭流。
void	defaultWriteObject () 将当前类的非静态和非瞬态字段写入此流。
protected void	drain () 排空ObjectOutputStream中的所有已缓冲数据。
protected boolean	enableReplaceObject (booleanenable) 允许流对流中的对象进行替换。
void	flush () 刷新该流的缓冲。
ObjectOutputStream.PutField	putFields () 检索用于缓冲写入流中的持久存储字段的对象。
protected Object	replaceObject ( Object obj) 在序列化期间，此方法允许ObjectOutputStream的受信任子类使用一个对象替代另一个对象。
void	reset () 重置将丢弃已写入流中的所有对象的状态。
void	useProtocolVersion (intversion) 指定要在写入流时使用的流协议版本。
void	write (byte[]buf) 写入一个字节数组。
void	write (byte[]buf, intoff,intlen) 写入字节的子数组。
void	write (intval) 写入一个字节。
void	writeBoolean (booleanval) 写入一个boolean值。
void	writeByte (intval) 写入一个8位字节。
void	writeBytes ( String str) 以字节序列形式写入一个String。
void	writeChar (intval) 写入一个16位的char值。
void	writeChars ( String str) 以char序列形式写入一个String。
protected void	writeClassDescriptor ( ObjectStreamClass desc) 将指定的类描述符写入ObjectOutputStream。
void	writeDouble (doubleval) 写入一个64位的double值。
void	writeFields () 将已缓冲的字段写入流中。
void	writeFloat (floatval) 写入一个32位的float值。
void	writeInt (intval) 写入一个32位的int值。
void	writeLong (longval) 写入一个64位的long值。
void	writeObject ( Object obj) 将指定的对象写入ObjectOutputStream。
protected void	writeObjectOverride ( Object obj) 子类用于重写默认writeObject方法的方法。
void	writeShort (intval) 写入一个16位的short值。
protected void	writeStreamHeader () 提供writeStreamHeader方法，这样子类可以将其部分追加或预加到流中。
void	writeUnshared ( Object obj) 将“未共享”对象写入ObjectOutputStream。
void	writeUTF ( String str) 以UTF-8修改版格式写入此String的基本数据。

importjava.util.*;
importjava.io.*;
publicclassObjectStreamDemo{
publicstaticvoidmain(String[]args)throwsException{
Students1=newStudent("tom",20);
Students2=newStudent("Jack",30);
Students3=newStudent("zhang3",20);
Students4=newStudent("Liudehua",10);
Student[]students={s1,s2,s3,s4};
Scannerscan=newScanner(System.in);
System.out.println("请输入一个路径!");
Stringpath=scan.next();
ObjectOutputStreamoout=newObjectOutputStream(newFileOutputStream(newFile(path)));
ObjectInputStreamoin=newObjectInputStream(newFileInputStream(newFile(path)));
for(Studentstudent:students){
oout.writeObject(student);
}
oout.flush();
for(inti=0;i<4;i++){
Studentstudent=(Student)oin.readObject();
System.out.printf("第%d个学生的名字为%s,年龄为%d\n",i+1,student.getName(),student.getAge());
}
oout.close();
oin.close();
}
}

java.util.Dictionary<K,V>



java.util.Hashtable<Object,Object>

Properties

Properties

类表示了一个持久的属性集。

Properties

可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
属性文件的读写
以properties为扩展名的文件叫属性文件
key=value的形式(value不用用引号)
#为单行注释
java.util.Properties
load()加载属性文件
getProperty("key")获取value

类Properties方法摘要

String	getProperty (Stringkey) 用指定的键在此属性列表中搜索属性。
String	getProperty (Stringkey,StringdefaultValue) 用指定的键在属性列表中搜索属性。
void	list (PrintStreamout) 将属性列表输出到指定的输出流。
void	list (PrintWriterout) 将属性列表输出到指定的输出流。
void	load (InputStreaminStream) 从输入流中读取属性列表（键和元素对）。
void	loadFromXML (InputStreamin) 将指定输入流中由XML文档所表示的所有属性加载到此属性表中。
void	save (OutputStreamout,Stringcomments) 已过时。如果在保存属性列表时发生I/O错误，则此方法不抛出IOException。保存属性列表的首选方法是通过 store(OutputStream out,Stringcomments) 方法或 storeToXML(OutputStream os,Stringcomment) 方法来进行。
Object	setProperty (Stringkey,Stringvalue) 调用 Hashtable 的方法 put 。
void	store (OutputStreamout,Stringcomments) 以适合使用 load 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
void	storeToXML (OutputStreamos,Stringcomment) 发出一个表示此表中包含的所有属性的XML文档。
void	storeToXML (OutputStreamos,Stringcomment,Stringencoding) 使用指定的编码发出一个表示此表中包含的所有属性的XML文档。

importjava.util.Properties;
importjava.io.*;
publicclassPropertiesDemo{
publicstaticvoidmain(Stringargs[])throwsException{
//构建Properties工具对象
Propertiesprop=newProperties();
//加载属性文件
prop.load(newFileInputStream(newFile("d:\\src\\school.properties")));
Stringname=prop.getProperty("name");
Stringaddress=prop.getProperty("address");
System.out.println(name);
System.out.println(address);
}
}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签： java io File RandomAccessFile FileInputStream

相关文章推荐

新的分享

章节导航