欢迎您的光临,本博所发布之文章皆为作者亲测通过,如有错误,欢迎通过各种方式指正。

教程  Java语言学习—第十三章 Java输入与输出(I/O)[Java基础]

Java 原创 1018 0评论

内容概要

1.File类

2.流(stream)

3.filter stream

4.字符流

5.RandomAccessFile类

6.对象序列化 


输入(Input)与输出(output)是奇偶指向某个方向的流动数据流。java.io包提供了众多与输入输出相关的类。

 

1.File类

File类提供了与文件或目录相关的信息。在介绍此类之前,我们要先弄明白何为路径(path)?,路径是指文件的路径,它既可以是文件,也可以是目录。

path指目录:“C:\.","C:\Think\"

path指文件:“abc.txt","C:Think\HelloJava.java"


File类的构造函数:

public File(String pathname):——使用指定的路径pathname创建一个File对象。

public File(String parent,String child):——使用指定路径与字符串创建一个File对象。

public File(File parent,String child):——使用一个File对象parent与字符串创建一个File对象。

File f=new File(“C:\\abc.txt"); 

File f=new File(“C:\\","abc.txt");

File f=new File(“C:\\");

字符“\”与其他字符相结合,会产生某种特殊的功能。在这里使用双斜杠表示单个"\".不这样表示会发生错误。

“\n"表示换行,我们把这种反斜杠开头,后面跟上转义符,再由单引号括起来的字符序列,称为转义符(escape字符)。


File的常用方法之一:

public boolean CanRead(),public boolean canWrite()—测试当前文件是否可读写。若可以读或写返回true,否则返回false。 

public boolean createNewFile() throws IOException—若当前对象所指文件不存在,则创建之,并返回true;若存在返回false。

public static File createTempFile(String prefix,String suffix) throws IOException—在临时目录中,创建以prefix为文件名,suffix为扩展名临时文件。eg:File a=File.createTempFile("abc",".txt");

public static File createTempFile(String prefix,String suffix,File directory) throws IOException—在directory既定目录中创建临时文件。

public boolean delete()—删除当前对象所指文件。删除成功返回true,否则返回false。

public void deleteOnExit()—JVM终止时(程序执行完毕)删除当前对象所指文件。

public boolean exists()—测试当前对象所指文件是否存在,存在就返回true,否则返回false。

下面实例测试文件是否存在,不存在就创建它。

import java.io.File;
import java.io.IOException;public class File1 {
public static void main(String[] args) {
File f=new File("c:\\abc.txt");.................//创建文件对象f
if(f.exists()).................//若文件已存在 
System.out.println("文件已存在");
else{
try{f.createNewFile();.................//创建文件
System.out.println("文件创建完毕");
}catch(IOException e){}
}}}


File的常用方法之二:

public String getName(),public String getParent(),public String getPath();—获取文件或目录名称(不含路径),获取文件所在目录名称,获取文件或目录名称。

public boolean isDirectory()—测试当前对象是否为目录,若当前对象代表一个有效目录,返回true,否则返回false。

public boolean isFile()—测试当前对象是否为文件,若当前对象代表一个有效文件,返回true,否则返回false。

public boolean isHidden()—测试当前对象所代表的文件是否是隐藏文件,若是则返回true,否则返回false。

public long lastModified()—返回文件最后修正日期(long型)。

public long length()—返回文件的大小(bytes)。

import java.io.File;
public class File2 {
public static void main(String[] args) {
File f=new File("c:\\abc.txt");
System.out.println(f.isFile());.....................//若是文件,返回true
System.out.println("名称:"+f.getName());....................//文件名称
System.out.println("目录:"+f.getParent());....................//文件所在目录 
System.out.println("路径:"+f.getPath());....................//文件路径
System.out.println("大小:"+f.length()+"bytes");....................//文件长度
}}


File的常用方法之三:

public String[] list()—若当前对象代表目录,则将此目录内所有文件名存储于list数组中,并返回true;若对象为非目录,返回null

public File[] listFiles()—若当前对象代表目录,则将此目录内所有文件转换为File对象,然后返回File数组;若对象为非目录,返回null

public boolean mkdir()—使用当前对象说指定的路径,创建一目录。

public boolean renameTo(File dest)—将当前对象所指定的文件名转换为dest。

public boolean setReadOnly()—将当前文件设为只读。

public class File3 {
public static void main(String[] args) {
File f=new File("c:\\");
File[] fs=f.listFiles();........................//读出文件目录
for(int i=0;i<fs.length;i++){
if(fs[i].isDirectory()).......................//判断是否为有效目录
System.out.println("目录:");
else
System.out.println("文件:");
System.out.println(fs[i]);
}}}

 

2.流(stream)

(1)字节流:字节流提供了对字节进行输入输出处理的方法。层次结构如下:

InputStreamFileInputStreamLineNumberInputStream,DataInputStream,BufferedInputStream,PushbackInputStream
PipedInputStream
FilterInputStream
ByteArrayInputStream
SequenceInputStream
StringBufferInputStream
ObjectInputStream
OutputStreamFileOutputStreamDataOutputStream,BufferdOutputStream,PushbackOutputStream
PipedOutputStream
FilterOutputStream
ByteArrayOutputStream
ObjectOutputStream


(2)字符流:提供对字符进行输入输出的方法。字节流是最基本的,所有的InputStream和OutputStream的子类都是,主要处理二进制数据,是按字节来处理的。但实际中很多的数据都是文本,所以提出了字符流的概念,它是按虚拟机encode来处理的,也是要进行字符集的转化。

ReaderBufferedReaderLineNumberReader
CharArrayReader
InputStreamReaderFileReader
FilterReaderPushbackReader
PipedReader
StringReader
WriterBufferWriter
CharArrayWriter
OuputStreamWriterFileWriter
FilterWriter
PipedWriter
StringWriter
PrintWriter


(3)预定义流:Java程序会自动导入java.lang包,该包有一个System类,其中包含三个预定义静态常量:in、out和err,可以通过System。System.in是标准输入流,默认设备是键盘。System.out标准输出流,System.err标准错误流,默认设备都是控制台。其中,System.in被定义为public static final InputStream类型,它是InputStream的一个对象。System.out和System.err被定义为public static final PrinterStream类型,它是PrinterStream的一个对象。三者都是字节流。

System.in读取字节的方法有如下三个:

int read() throws IOException:从输入流读取一个字节,返回值为下一个字节的整型值。当达到流的末尾时返回-1。

int read(byte data[])throws IOException:从输入流读取字节放到字节数组data中,直到数组满时,到达流的末尾或者发生异常时为止,返回值为读入的字节数,当到达流的末尾时返回-1。

int read(byte data[],int off,int length)throws IOException:从输入流的第off个字节开始尝试读取length个字节放到字节数组data中,直到数组满时,到达流的末尾或者发生异常为止,返回值为读入的字节数,当到达流的末尾时返回-1.从System.in读取字节时,按回车键会产生一个流的结束符。


InputStream与OutputStream

InputStream和OutputStream是所有类的基类,且都是抽象类,无法创建对象。我们可以使用其子类创建对象再使用它们。由于它们所提供的方法都是以byte为单位写数据,因此两个类的子类都是以byte为单位进行输入输出操作。

InputStream类中的常用方法

方法描述
public abstract int read() throws IOException自输入流读取一个字节,并返回0-255之间的一个int型数,若文件读取完毕或再无读取数据就返回-1.
public int read(byte b[]) throws IOException自输入流中读取数据并存在指定的自己数组b中,此函数实际返回是读取的byte数,若再无可读数据返回-1.
public int read(byte b[],int off,int len)throws IOExceoption自输入流中读取len个字节数据,并存入指定字节数组b中,(从b[off]中开始存储)此函数实际返回是所有读取的字节数,若再无可读数据,返回-1.
public void close() throws IOExceoption关闭输入流,并释放于此输入流相关的系统资源(内存)
public int available() throws IOException返回当前可读的输入字节数
public void mark(int numBytes) throws IOException在输入流的当前点放置一个标记。该流在读取numBytes个字节前都保持游戏。
public boolean markSupport() throws IOException如果调用的流支持mark()/reset()就返回true
public void reset() throws IOException重新设置输入指针到先前设置的标志处
public long skip(long numBytes)throws IOException忽略numBytes个输入字节,返回实际忽略的字节数

OutputStream类中的常用方法

方法描述
public abstract void write(int b) throws IOException将b转换为字节,然后写入到输入流,每次一个自己。
public void write(byte b[]) throws IOExcepton将字节数组b中的数据写到输出流。
public int write(byte b[],int off,int len)throws IOExceoption将字节数组b中从素养off位置开始的,长度为len个字节的数据写到输出流中。
public vlid close() throws IOException关闭输出流,并释放所占用的系统资源。
public void flush()throws IOException定制输出状态以使每个缓冲器都被清除,也就是刷新输出缓冲区
public void write(byte buffer[],int offset,int numBytes)写数组buffer以buffer[offset]为起点的numBytes个字节区域的内容。


FileInputStream类与FileOutputStream类


FileInputStream是InputStream类的子类,常用的构造方法如下:

public FileInputstream(String name) throws FileNotFoundException——使用指定的文件名name创建一个FileInputStream的对象,若文件不存在会产生FileNotFoundException

FileInputStream(File File) throws FileNotFoundException——使用指定的文件对象创建一个FileInputStream的对象,从指定的文件file中读取数据。如果文件不存在会产生FileNotFoundException

FileInputStream重载了抽象类InputStream的六个方法,mark()和reset()方法不被重载,任何关于使用FileInputStream的reset()尝试都会生成IOException异常。


FileOutputStream是OutputStream类的子类,常用的构造方法如下:

public FileOutputStream(String name) throws FileNotFoundException——使用指定的文件名name创建一个FileOutputStream的对象,若文件不存在则创建它;若存在,原文件会被新写的内容覆盖掉。若name代表一个目录或其他原因造成文件无法创建会抛出异常。

public FileOutputStream(File file) throws FileNotFoundException——使用指定的文件对象file创建一个FileOutputStream的对象。

public FileOutputStream(String name,boolean append)——使用指定字符串name,创建FileOutputStream对象。若文件存在且append为真时,新写入的数据将追加在原数据之后;append为假时,新数据将原文件数据覆盖掉。

public FileOutputStream(File file,boolean append)——使用指定的文件对象file,创建FileOutputStream流对象。若文件存在且append为真时,新写入的数据将追加在原数据之后;append为假时,新数据将原文件数据覆盖掉。


FileOutputStream的创建不依赖于文件是否存在。在创建对象时FileOutputStream在打开输出文件之前创建它。在这种情况下如果你试图打开一个只读文件,会引发一个IOException的异常。

eg:创建文件并写入数据:

public class File4{
public static void main(String[] args) throws Exception{................//抛出异常
FileOutputStream fos=new FileOutputStream("c:\\abcd.txt");
for(int i='A';i<='Z';i++)
fos.write(i);...............//若向fos传送数据,fos会将其写入文件中
fos.close();..................//使用完毕,关闭文件输出流
}}

eg:读取文件中的字符:

FileOutputStream fos=new FileOutputStream("c:\\abcd.txt",true);
for(int i='a';i<='z';i++)
fos.write(i);
fos.close();
}}

eg:读取文件数据:

File f=new File("c:\\abcd.txt");
FileInputStream fis=new FileInputStream(f);
char a;
for(int i=0;i<f.length();i++){........//读取文件所有数据
a=(char)fis.read();........//read()方法每次读取一个
System.out.print(a);
fis.close();
}}


3.filter stream(过滤流)

InputStream类与OutputStream类皆以byte为单位读写数据,很难处理诸如:char,int,double,String型的数据。然而,若使用了filter stream类,则能使非常方便的处理它们。filter stream流分为FilterInputStream和FileOutputStream两个分类。


Filter Stream的构造函数如下:

protected FilterInputStream(InputStream in)

protected FilterOutputStream(OutputStream out)

它们的形式分别接受InputStream对象和OutputStream对象,原因在于Filter Stream只是将数据传送给Input/Output Stream对象。eg:

File f=new File("c:\\大写字母.txt");.............//创建文件对象f

FileOutputStream fos=new FileOutputStream(f);.............//创建FileOutputStream对象fos,用于向文件写入字节数据。

FilterOutputStream filter=new FilterOutputStream(fos);.............//创建FilterOutputStream对象filter。

for(int i='A';i<'Z';i++)

filter.write(i);.............//将数据传送入filter对象。接受数据的filter会将数据传送给fos对象。fos再将数据写入至文件中。

filter.close();

观察FilterInputStream的方法,会发现它从OutputStream类继承而来的write(),write(byte b[]),write(byte b[],int off,int len)方法,此外,并无更多方法。所以使用FilterInputStream与FilterOutputStream类很难处理如int,long,String型数据,不过可以通过它们的子类很好的解决。


DataInputStream与DataOutputStream

它们分别继承与FilterInputStream与FilterOutputStream类,并且,它们分别实现了DataInput接口与DataOutput接口。下面是两个类的头部分。

DataInputStream extends FilterInputStream implements DataInput

DataOutputStream extends FilterOutputStream implements DataOutput


DataInput接口的常用方法:

boolean readBoolean() throws IOException;

byte readByte() throws IOException;

char readChar() throws IOException;

short readShort() throws IOException;

int readInt() throws IOException;

long readLong() throws IOException;

float readFloat() throws IOException;

double readDouble() throws IOException;

从流(Stream)中,读取有关数据,并返回。

String readUTF() throws IOException;

读取UTF-8(Unicode的一种)形式字符串,并以String的形式返回。


DataOutput接口的常用方法:

void write(int b) throws IOException;.................//将b轴转换为byte

void writeBoolean(boolean v) throws IOException;

void writeByte(int v) throws IOException;.............//将v轴转换为byte

void writeChar(int v) throws IOException;.............//将v轴转换为char

void writeShort(int v) throws IOException;.............//将v轴转换为short

void writeInt(int v) throws IOException;

void writeLong(long v) throws IOException;

void writeFloat(float v) throws IOException;

void writeDouble(double v) throws IOException;

将给定的流存入数据库中

void writeUTF(String str) throws IOException;

将字符串str转换为UTF-8字符串,存入流中。


DataInputStream类与DataOutputStream类的构造函数如下:

public DataInputStream(InputStream in)

public DataOutputStream(OutputStream out)

此两类继承Filter Stream,故也是Filter Stream,并且分别实现了DataInput接口与DataOutput接口,故也可以输入输出基本类型数据。

数据的存入与读取实例:

File f=new File("c:\\abc.dat");
FileOutputStream fos=new FileOutputStream(f);
DataOutputStream dos=new DataOutputStream(fos);
dos.writeUTF("洪吉通");...........//将字符串"洪吉通"格式写入到输入流
dos.writeInt(20);................//将int型数据20写入到输入流
dos.writeInt(180);
dos.writeUTF("韩国");

读取:

File f=new File("c://abc.dat");
FileInputSteam fis=new FileInputStream(f);
DataOutputStream dis=new DataOutputStream(fis);
String name,country;
int age,height;
name=dis.readUTF();
age=dis.readInt();
height=dis.readInt():
country=dis.readUTF();


4.字符流

Reader类与Writer类皆为抽象类,本身无法创建对象,必须使用它们的子类覆盖其抽象方法,其构造函数分别为:

public abstract class Reader{.....}

public abstract class Writer{.....}

它们的主要子类如下:

以字符为单位进行输入输出的流

public class InputStreamReader extends Reader{...}

public class OutputStreamWriter extends Writer{...}

以行为为单位进行输入输出的流

public class BufferedReader extends Reader{...}

public class BufferedWriter extends Writer{...}


Reader类的常用方法

方法描述
public abstract void close() throws IOException关闭输入源,关闭后的读取将会产生IOException异常
public void mark(int mumChars) throws IOException在输入流当前位置设立一个标志。该输入流在numChars个字符被读取之前有效
public boolean markSupport() throws IOException该流支持mark()/reset()则返回true
public int read()throws IOException如果调用的输入流的下一个字符可读则返回一个整数。遇到文件尾时,返回-1
public int readchar buffer[]) throws IOException试图buffer中的buffer.length个字符。返回实际成功读取的字符数。遇到文件尾返回-1
public abstract int read(char buffer[],int offset,int mumChars) throws IOException试图读取buffer中从buffer[offset]开始的numChars个字符,返回实际成功读取的字符数。遇到文件尾返回-1
public boolean ready() throws IOException如果下一个输入请求不等待则返回true,否则返回false
public void reset() throws IOException设置输入指针到先前设立的标志处
public long skip(long numChars) throws IOException跳过numChars个输入字符,返回跳过的字符数

Writer类的常用方法

方法描述
public abstract void close() throws IOException关闭输出源,关闭后的写入将会产生IOException异常
public abstract void flush() throws IOException定制输出状态以使每个缓冲器都被清除,也就是刷新缓冲区
public void writeint ch) throws IOException想输入流写入单个字符,注意参数是一个整数,它允许你不必把参数换成字符型就可以调用write()
public void write(char buffer[]) throws IOException向一个输入流写一个完整的字符数组
public abstract int write(char buffer[],int offset,int mumChars) throws IOException向调用输出流写入数组buffer以buffer[offset]为起点的numChars个字符区域的内容
public void write(String str) throws IOException向调用的输出流写str
public void write(String str,int offset,int numChars)throws IOException写数组str中以定制的offset为起点的长度位numChars个字符区域内的内容


FileReader类与FileWriter类

FileReader类是Reader类的子类,可以对文件进行读取,常用的构造方法如下:

FileReader(String name)——使用指定的文件名name创建一个FileReader的对象,如果文件不存在会产生FileNotFoundException异常

FileReader(File file)——使用指定的文件对象创建一个FileReader的对象,如果文件不存在会产生FileNotFoundException异常

下面的例子创建了两个使用同样磁盘文件且各含一个构造方法的FileReader对象:

FileReader f1=new FileReader("hello.txt");

File f=new File("hello.txt");

FileReader f2=new FileReader(f);

FileWriter类是Writer类的子类,可以对文件进行写入,常用的构造方法如下:

FileWriter(File file)—— 使用指定的文件对象创建一个FilWriter的对象,FileWriter类的创建不依赖于文件存在与否。


InputStreamReader类与OutputStreamWriter类

这两个类分别继承自Reader类与Writer类,提供字符的读写功能。主要构造函数如下:

public InputStreamReader(InputStream in)

public OutputStreamWriter(OutputStream out)

观察构造函数会发现同Filter Stream类处于同一位置,下图将字符数据存入文件过程。

字符数据→OutputStreamWriter→OutputStream→文件


BufferedReader类与BufferedWriter类

这两个类分别继承Reader类与Writer类。这两个类由于内部使用了缓冲(Buffer)机制,所以他们可以以行为进行输入输出。主要构造函数如下:

public BufferedReader(Reader in)

public BufferedWriter(Writer out)

从构造函数可知,他们的对象位于Writer或者Reader对象之前。下图将字符数据存入文件过程。

字符数据→BufferedWriter→OutputStreamWriter→OutputStream→文件


BufferedReader的常用方法

public String readLine() throws IOException——从输入流读取一行字符,并将其返回为字符串。若无数据可读,则返回null。


BufferedWriter类的常用方法

public void write(String str)throws IOException——将字符串str写入输出流中。

public void flush() throws IOException——将缓冲内的数据强制写入输出流。

public void newLine() throws IOException——想输出流写入一个行结束标记(可简单将其理解为换行符/n)

即使调用write()方法,数据也非立刻被写入输出流中,而首先进入缓冲区buffer中。以后,随时将缓冲区中的数据写入至输出流中。所以,想立刻将缓冲区中的数据写入输出流中,一定要用flush()方法。

import java.io.*;
public class File12 {
public static void main(String[] args) throws Exception {
FileOutputStream fos=new FileOutputStream("c:\\abc.txt");
OutputStreamWriter osw=new OutputStreamWriter(fos);
java.io.BufferedWriter bw=new BufferedWriter(osw);
bw.write("你好");...................//将字符串写入输出流中
bw.newLine();.......................//向输出流写入一个行结束标记 
bw.write("很高兴");
bw.newLine();
bw.close();
FileInputStream fis=new FileInputStream("c:\\abc.txt");
InputStreamReader isr=new InputStreamReader(fis);
BufferedReader br=new BufferedReader(isr);
System.out.println(br.readLine());..............//读取一行
System.out.println(br.readLine());
br.close();
}}

//结果:你好!很高兴

循环读取文件行:String s; 

while((s=br.readLine())!=null) System.out.pritln(s);//只要s为非空,循环往复


FileReader类与FileWriter类

分别继承自InputStreamReader与OutputStreamReader类,提供了将字符写入文件或从文件读出的简便方法。

使用FileReader类可以将简化

FileInputStream fis=new FileInputStream("c:\\abc.txt");

InputStreamReader isr=new InputStreamReader(fis);

BufferedReader br=new BufferedReader(isr);

简化后:

FileReader fr=new FileReader("c:\\abc.txt");

BufferedReader br=new BufferedReader(fr)

从System.in获取数据

java.lang.System类的in属性声明如下:

public final static InputStream in=new InputStream();

in对应于系统的输入,用于从标准输入设备(键盘)读入数据。

读取键盘输入的数据

System.out.println("输入一个字符,并按回车键结束");

int r= System.in.read(); 

System.out.println("输入的字符串为"+(char)r);

利用BufferedReader类,从键盘读取一行数据。

import java.io.IOException;
import java.io.*;
public class Keyboard2 {
public static void main(String[] args) throws IOException{
System.out.println("输入一个字符,并按回车键结束");
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
String r=br.readLine();
System.out.println("输入的字符串为:"+r);
}}

从键盘上读取一行数据,并输出至文件(c:/abc.txt)的过程。

import java.io.*;
public class Keyboard3 {
public static void main(String[] args) throws IOException {
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);..........................//键盘输入流
FileWriter fw=new FileWriter("c:\\abc.txt");
BufferedWriter bw=new BufferedWriter(fw);...........................//文件输入流
System.out.println("请输入内容(结束:eof):");
String data;
while(true){........................................//循环
data=br.readLine();...............................//从键盘读取一行数据,存入data中
if(data.equals("eof")) break;
bw.write(data);..............................//将data中的数据存入文件
bw.newLine();
}
bw.close();
System.out.println("文件创建完毕");
}}


PrintStream类与PrintWriter类

他们都是打印输出流,可以将各种基本数据类型的数据输出至字符串流中,并且提供自动刷新(flush)功能。PrintStream会在调用println方法或输出已含换行符('/n')的字符串时自动刷新(flush),但是,PrintWriter仅在调用println()方法时自动刷新(flush)。System.out即为PrintStream的对象。PrintStream类与PrintWriter类在功能上和方法上无太大差别。


PrintWriter类的常用构造函数:

public PrintWriter(Writer out,boolean autoFlush)——使用指定的Writer对象out,创建一个打印输出流对象。若autoFlush为真,则自动刷新。

public PrintWriter(OutputStream out,boolean autoFlush)——使用指定的OutputStream对象out,创建一个打印输出流对象。若autoFlush为真,自动刷新。


PrintWriter类的常用方法:

public void flush()——强制性的将缓冲区中的数据写至输出流。

public void print(boolean b),public void print(int i)......——将各种类型的数据写至输出流

public void println()——将换行符写至输出流

public void println(boolean b),public void println(int i).....——讲各种数据和换行符写入至输出流

public boolean checkError()——检查是否发生 错误。若有错误发生,则返回true。

使用BufferedReader与PrintWriter类,并分别使用System.in与System.out进行输入输出。

import java.io.*;
public class Pwriter {
public static void main(String[] args) throws IOException {
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
PrintWriter pw=new PrintWriter(System.out,true);..............//自动刷新
String s;
pw.println("请输入字符");
while(!(s=br.readLine()).equals(""))....................//若输出字符串,条件将变为假.
pw.println(s);
br.close();
pw.close();
}}


5.RandomAccessFile类

RandomAccessFile类是随机访问类,支持对文件的随机读写操作。访问随机文件是指可以读写其存储的任意位置数据的文件。我们可以将其内存储的数据看做一字节数组。在随机访问文件中存在一个文件指针(file point),通过一定文件的指针可以实现数据的任意读写操作。

RandomAccessFile类实现了DataInput与DataOutput接口。所以可以读写基本数据类型的数据。下面是RandomAccessFile的头部分。

public class RandomAccessFile implements DataOutput,DataInput


RandomAccessFile类的常用构造函数:

public RandomAccessFile(String name,String mode)

public RandomAccessFile(File file,String mode)

使用给定的字符串或文件对象和存取模式创建一个RandomAccessFile类对象。

存取模式有"r","rw","rws","rwd"四种。其中"r"代表以只读方式打开文件。若试图向该文件进行读写操作。则会抛出IOException异常。"rw","rws","rwd"以只读模式打开文件。若文件不存在,则创建它。


RandomAccessFile类的常用方法:

public native long getFilePointer() throws IOException;——取得文件的位置指针

public native void seek(long pos) throws IOException;——将文件位置指针移至pos处,pos以字节为单位。

public native long length() throws IOException;——获取文件大小(以字节为单位)。从DataInput接口继承的方法。

readBoolean(),readByte(),readChar(),readShort(),readInt(),readLong(),readFloat(),readDouble(),readUTF()——读取不同类型的数据。从DataInput接口继承的方法。

write(int b),writeBoolean(Boolean v),writeByte(int v),writeChar(int v),writeShort(int v),writeInt(int v),writeLong(long v),writeFloat(float v),writeDouble(double v),writeUTF(String str)——讲不同德数据输出至文件。

创建文件,并在期内存储数据:

File f=new File("c://abc.txt");
RandomAccessFile raf=new RandomAccessFile(f,"rw");..........//读写
int a=10;
double b=12.34;
String c="abc";
raf.writeInt(a);
raf.writeDouble(b);
raf.writeUTF(c);
raf.close();

读取上面创建的文件:

File f=new File("c://abc.txt");
RandomAccessFile raf=new RandomAccessFile(f,"r");..........//只读模式
System.out.println(raf.readInt());
System.out.println(raf.readDouble);
System.out.println(raf.readUTF());
raf.close();

通过移动文件指针,实现文件的读写。

File f=new File("c://abc.txt");
RandomAccessFile raf=new RandomAccessFile(f,"rw");
String s=“洪吉童”;
Systems.out.println(“在文件尾追加数据”);
long len=raf.length();........//获取文件长度
raf.seek(len);...............//将文件指针置于文件末尾
raf.writeUTF(s);.............//存储数据
Systems.out.println(“读取刚存放的数据”);
raf.seek(len);...............//len为存入数据之前的文件指针位置
Systems.out.println(raf.readUTF());
raf.seek(0);...............//将文件指针置于文件开头
Systems.out.println(raf.readInt());
raf.close();


6.对象序列化(object serialization)

Stream可以很容易的将连续的比特构成的基本数据类型的数据传送至流中。但是倘若想将数据集合(对象)写入流中,则应将构成对象的数据排成一系列数据,再将其写入流中。这个过程成为对象序列化(serialization)。将序列化的数据恢复到原来的位置过程成为序列化解体(deserialization)。

可以序列化的对象有String,StringBuffer,Frame,Applet等,这些类都实现了Serializable接口。即可以序列化的类实现了Serializable接口。

事实上,Serializable接口无任何抽象方法,它仅表明类是可序列化的,我们将这样的接口称为标识接口


ObjectInput与ObjectOutput

ObjectInput与ObjectOutput接口分别继承了DataInput和DataOutput接口,提供了用于读写基本数据类型和对象数据类型的方法。ObjectInput提供了readObject()方法,此方法用于将对象从流中读出。ObjectOutput提供了writeObject()方法,此方法用于将对象写入流中。

从流中读取对象的ObjectInput的成员方法。

public Object readObject() throws classNotFoundException,IOException;

从对象写入流的ObjectOutput的成员方法。

public void writeObject(Object obj) throws IOException;

ObjectInput与ObjectOutput皆为接口,本身无法创建对象。但可以用实现了他们的ObjectInputStream类与ObjectOutputStream类创建对象,从而使用他们。

ObjectOutputStream:继承了OutputStream类,同时实现了ObjectOutput接口,提供了将对象序列化写入Stream的功能。构造函数如下:

public ObjectOutputStream(OutputStream out) throws IOException

ObjectOutputStream的应用位置如图:对象→ObjectOutputStream→OutputStream→文件网络

将对象输出至文件的过程

class Man implements Serializable{...............//Mand对象可序列化
String name; int age; double height; 
}
public class Serialize1{
public static void main(String[] args) throws Exception{
FileOutputStream fos=new FileOutputStream("c:\\obj.dat");
ObjectOutputStream oos=new ObjectOutputStream(fos);
Man m=new Man();
m.name="小刚";m.age=23;m.height=170.0;
oos.writeObject(m);...................//将对象写入流
oos.close();

ObjectInputStream:继承了InputStream类,同时实现了ObjectInput接口,构造函数如下:

public ObjectInputStream(InputStream in) throws IOException

读取上面创建的文件对象

public class Serialize2{
FileInputStream fis=new FileInputStream("c:\\obj.dat");
ObjectInputStream ois=new ObjectInputStream(fis);
Man m=(Man)ois.readObject();...........//readObject()方法从流中读取的对象类型为Object,需要强制转换为Man型。
ois.close();
System.out.pritln(m.name+m.age+m.height);


问题思考


转载请注明: ITTXX.CN--分享互联网 » Java语言学习—第十三章 Java输入与输出(I/O)[Java基础]

最后更新:2018-10-09 18:08:48

赞 (1) or 分享 ()
游客 发表我的评论   换个身份
取消评论

表情
(0)个小伙伴在吐槽