一. 输入和输出
可将Java库的IO类分割为输入与输出两个部分。通过继承,从InputStream(输入流)衍生的所有类都拥有名为read()的基本方法,用于读取单个字节或者字节数组。类似地,从OutputStream衍生的所有类都拥有基本方法write(),用于写入单个字节或者字节数组。Java类库的设计者将所有与输入有关的类都从InputStream继承,而与输出有关的所有类都从OutputStream继承。
*1.InputStream的类型
InputStream的作用是标志那些从不同起源地产生输入的类。这些起源地包括(每个都有一个相关的InputStream子类):
(1) 字节数组
(2) String对象
(3) 文件
(4) “管道”。
(5) 一系列其他流,以便我们将其统一收集到单独一个流内。
(6) 其他起源地,如Internet连接等。
除此之外,FilterInputStream 也属于InputStream 的一种类型,用它可为“破坏器”类提供一个基础类,以便将属性或者有用的接口同输入流连接到一起。
类 | 功能 | 构造器参数 / 如何使用 |
---|---|---|
ByteArrayInputStream | 允许内存中的一个缓存区作为InputStream使用 | 缓冲区,字节将从中取出 / 作为一种数据源:将其同一个FilterInputStream对象相连以提供一个有用的接口。 |
StringBufferInputStream | 将String 转换成InputStream | 字符串。底层实现实际使用StringBuffer / 作为一种数据源:通过将其同一个FilterInputStream 对象相连以提供一个有用的接口 |
FileInputStream | 用于从文件读取信息 | 字符串,表示文件名、文件或FileDescriptor对象 / 作为一种数据源:将其同一个FilterInputStream对象相连以提供一个有用的接口。 |
PipedInputStrem | 产生用于写入相关PipleOutputStream的数据。实现“管道化”概念 | PipleOutputStream / 作为多线程中的数据源:将其与FilterInputStream 对象相连以提供一个有用的接口 |
SequenceInputStream | 将两个或更多的InputStream 对象转换成单个InputStream | 两个InputStream 对象或一个容纳InputStream对象的容器Enumeration / 作为一种数据源:将其与FilterInputStream 对象相连以提供一个有用的接口 |
FilterInputSTream | 抽象类,作为“装饰器”的接口。其中“装饰器”为其他的InputStream类提供有用功能,见下表FilterInputStream | 见下表FilterInputStream |
*2.OutputStream的类型
这一类别包括的类决定了我们的输入往何处去:一个字节数组(但没有String;假定我们可用字节数组创建一个);一个文件;或者一个“管道”。
类 | 功能 | 构造器参数 / 如何使用 |
---|---|---|
ByteArrayInputStream | 在内存中创建缓冲区。所有送往“流”的数据都要放置在此缓存区 | 缓冲区初始化尺寸(可选的) / 用于指定数据的目的地:将其与FilterInputStream对象相连以提供有用接口 |
FileOutputStream | 用于将信息写至文件 | 字符串,表示文件名、文件或FileDescription对象 / 用于指定数据的目的地:将其与FilterInputStream对象相连以提供有用接口 |
PipleOutputStream | 任何写入其中的信息都会自动作为相关PipedInputStrem 的输出。实现管道化的概念 | PipedInputStrem / 用于指定数据的目的地:将其与FilterInputStream对象相连以提供有用接口 |
FilterOutStream | 抽象类,作为“装饰器”的接口。其中,“装饰器”为其他OutputStream提供有用功能 | 见下表FilterOutStream |
二.增添属性和有用的接口
FilterInputStream 和FilterOutputStream 提供了相应的装饰器接口,用于控制一个特定的输入流(InputStream)或者输出流(OutputStream)。它们分别是从InputStream 和OutputStream 衍生出来的。此外,它们都属于抽象类,在理论上为我们与一个流的不同通信手段都提供了一个通用的接口。事实上,FilterInputStream 和FilterOutputStream 只是简单地模仿了自己的基础类,它们是一个装饰器的基本要求。
1.通过FilterInputStream从InputStream里读入数据
FilterInputStream 类要完成两件全然不同的事情。其中,DataInputStream 允许我们读取不同的基本类型数据以及String 对象(所有方法都以“read”开头,比如readByte(),readFloat()等等)。伴随对应的DataOutputStream,我们可通过数据“流”将基本类型的数据从一个地方搬到另一个地方。这些“地方”是由下表那些类决定的。
其他FilterInputStream类则在内部修改InputStream的行为方式:是否缓冲,是否保留它所读过的行(允许我们查询行数或设置行数),以及是否把单一字符推回输入流等等。最后两个类看起来更像是为了创建一个编译器(它们被添加进来可能是为了对“用Java构建编译器”实验提供支持),因此我们一般编程中不会用到它们。
FilterInputStream类型
类 | 功能 | 构造器参数 / 如何使用 |
---|---|---|
DataInputStream | 与DatatOutputStream搭配使用,因此我们可以按照可移植方式从流读取基本数据类型(int 、char、long等) | InputStream / 包含用于读取基本类型数据的全部接口 |
BufferedInputStream | 使用它可以防止每次读取时都得进行实际写操作。代表“使用缓冲区” | InputStream,可以指定缓冲区的大小(可选的)/ 本质上不提供接口,只不过向进程中添加缓冲区所必须的。与接口对象搭配。 |
LineNumberInputStream | 跟踪输入流中的行号,可用getLineNumber()和SetLineNumber(int) | InputStream / 仅增加了行号,因此可能要与接口对象搭配使用 |
PushbackInputStream | 具有“能弹出一个字节的缓冲区”。因此可以将读到的最后一个字符回退。 | InputStream / 通常作为编译器的扫描器,之所以包含在内是因为Java编译器的需要,我们可能永远用不到 |
2. 通过FilterOutputStream向OutputStream写入
与DataInputStream对应的是DataOutputStream,它可以将各种基本数据类型以及String对象格式化输出“流”中,这样以来,任何机器上的任何DataInputStream都能够读取它们。所有方法都以“write”开头,例如writeByte()、writeFloat()等。
PrintStream最初的目的表示为了可视化格式打印所有的基本数据类型以及String对象。这和DataOutpuStream不同,后者的目的是将数据元素置入“流”中,使DataOutputStream能够可移植地重构它们。
PrintStream可能会有些问题,因为它捕捉了所有IOException(因此,我们必须使用checkError()自行测试错误状态,如果出现错误它返回true)。另外,PrintStream也未完全国际化,不能以平台无关的方式处理换行动作(这些问题在printWrite中得到了解决)。
BufferOutputStream是一个修改过的OutputStream,它对数据流使用缓冲技术;因此当我们每次向流写入时,不必每次都进行实际的物理写动作。所以在进行输出时,我们可能更经常的是使用它。
FilterOutputStream:
类 | 功能 | 构造器参数 / 如何使用 |
---|---|---|
DataOutputStream | 与DatatOutputStream搭配使用,因此我们可以按照可移植方式向流中写入基本数据类型(int 、char、long等) | OutputStream / 包含用于写入基本数据类型的全部接口 |
PrintStream | 用于产生格式化输出。其中DataOutputStream处理数据的存储,PringStream处理显示 | OutputStream / 可以用boolean指示是否在每次换行时清空缓冲区(可选的)应该是对OutputStream对象的“final”封装。可能会经常使用它。 |
BufferedOutputStream | 使用它以避免每次发送数据时都要进行实际的写操作。代表“使用缓冲区”。 | OutputStream,可以指定缓冲区的大小(可选的) / 本质上并不提供接口,只不过是向进程中添加缓冲区所必须的。与接口对象搭配 |
三.Reader和Writer
InputStream 和 OutputStream在以面向字节形式的I/O中仍可以提供极有价值的功能,Reader和Writer则提供兼容Unicode与面向字符的I/O功能。另外:
1) Java1.1向InputStream和OutputStream的继承层次结构中添加了一些新类,所以显然这两个类是不会被取代的。
2)有时我们必须把来自于“字节”层次结构中的类和“字符”层次结构中的类结合起来使用。我了实现这个目的,要用到“适配器”(adapter)类:InputStreamReader可以把InputStream转换为Reader,而OutputStreamWriter可以把OutputStream转换为Writer。
设计Reader和Writer继承层次结构主要是为了国际化。老的I/O流继承层次结构仅支持8位字节流,并且不能很好的处理16位的Unicode字符。由于Unicode用于字符国际化(Java本身的char也是16位的Unicode),所以添加Reader和Writer继承层次结构就是为了在所有的I/O操作中都支持Unicode。
补充:字符编码
编码表的由来
计算机只能识别二进制数据,早期由来是电信号。为了方便应用计算机,让它可以识别各个国家的文字。就将各个国家的文字用数字来表示,并一一对应,形成一张表。这就是编码表。
常见的编码表
ASCII 码
ASCII 码总共有128个,用1个字节的低七位表示,0~31 是控制字符如换行、回车、删除等,32~126 是打印字符,可以通过键盘输入并且能够显示出来。
ISO-8859-1
128个字符显然是不够用的,于是ISO组织在ASCII 码基础上又制定了一系列标准来拓展 ASCII 编码,它们是ISO-8859-1 至 ISO-8859-15,其中 ISO-8859-1 涵盖了大多数西欧语言字符,所以应用的最广泛。ISO-8859-1 仍然是单字节编码,它总共能表示 256 个字符。
GB2312
GB2312 的全称是 《信息技术 中文编码字符集》,它是双字节编码,总的编码范围是 A1~F7,其中A1 ~ A9 是符号区,总共包含682个字符; B0~F7 是汉字区,包含6763个汉字。
GBK
全称是《汉字内码扩展规范》,它的出现是为了拓展 GB2312 ,并加入更多的汉字。它的编码是和GB2312 兼容的,也就是说用GB2312 编码的汉字可以用GBK 来解码,并且不会有乱码。
UTF-16
说到UTF 必须提到 Unicode ,ISO 试图创建一个全新的超语言字典,世界上所有的语言都可以通过这个字典来相互翻译。UTF-16 具体定义了Unicode 在计算中的存取方法。UTF-16 用两个字节来表示 Unicode 的转化格式,采用定长的表示方法,即不论什么字符都可以用两个字节表示。
UTF-8
UTF-16 存在存储空间浪费。UTF-8 采用了一种变长技术,每个编码区域有不同的字码长度。不同类型的字符可以由1~6 个字节组成。如果是一个字节,最高位为0,则表示这是 1 个 ASCII 字符,可见,所有ASCII 编码已经是UTF-8了。
编码:字符串à字节数组
解码:字节数组à字符串
转换流的编码应用
可以将字符按指定编码格式存储。
可以对文本数据按指定编码格式来解读。
指定编码表的动作由构造器完成。
1.数据的来源和去处
下面的表展示了在两个继承层次结构中,信息的来源和去处之间的对应关系。
字节 | 字符 |
---|---|
InputStream | Reader,适配器InputStreamReader |
OutputStream | Writer, 适配器OutStreamReader |
FileInputStream | FileReader |
FileOutputStream | FileWriter |
StringBufferInputStream(已弃用) | StringReader |
无相应的类 | StringWriter |
ByteArrayInputStream | CharArrayReader |
ByteArrayOutputStream | CharArrayWriter |
PipedInputStream | PipleReader |
PipedOutputStream | PipedWriter |
2.更改流的行为
对于InputStream和OutputStream来说,我们会使用FilterInputStream
和FilterOutputStream的装饰器子类来修改“流”以满足特殊要求。Reader和Writer的类继承层次结构继续沿用相同的思想———但是并不完全相同。
在下表中,相对于前一个表格来说,左右之间的对应关系的近似程度更加粗略一些。造成这种差别的原因是因为类的组织形式不同;尽管BufferedOutputStream是FilterOutputStream的子类,但是BufferedWriter并不是FilterWriter的子类(尽管FilterWriter是抽象类,没有任何子类,把它放在那里也只是把它作为一个占位符,或仅仅让我们不会对他所在的地方产生疑惑)。然而,这些类的接口却十分相似。
字节过滤器 | 字符过滤器 |
---|---|
FilterOutputStream | FilterReader |
FilterIntputStream | FilterWriter(抽象类,没有子类) |
BufferedIntputStream | BufferedWriter |
BufferedOutputStream | BufferedWriter |
DataInputStream | 使用DataInputStream(除了当需要使用readLine()时以外,这时应该使用BufferedReader) |
PrintStream | PrintWriter |
LineNumberInputStream(已弃用) | LineNumberReader |
StreamTokenzier | StreamTokenzier(使用接受Reader的构造器) |
PushbackInputStream | PushbackReader |
有一点很清楚,无论我们何时使用readLine(),都不应该使用DataInputStream(这会遭到编译器的强烈反对),而应该使用BufferedReader。除了这一点外,DataInputStream仍是I/O类库的首选成员。
为了更容易的过度到使用PrintWriter,它提供了一个既能接受Writer对象又能接受任何OutputStream对象的构造器。PrintWriter的格式化接口实际上是与PrintStream相同。
四.自我独立的类:RandomAccessFile
RandomAccessFile适用于由大小已知的记录组成的文件,以便我们能用seek()从一条记录移至另一条;然后读取或修改那些记录。各记录的长度并不一定相同;只要知道它们有多大以及置于文件何处即可。
有用。
首先,我们有点难以相信RandomAccessFile 不属于InputStream 或者OutputStream 分层结构的一部分。除了恰巧实现了DataInput 以及DataOutput(这两者亦由DataInputStream 和DataOutputStream 实现)接口之外,它们与那些分层结构并无什么关系。它甚至没有用到现有InputStream 或OutputStream 类的功能——采用的是一个完全不相干的类。该类属于全新的设计,含有自己的全部(大多数为固有)方法。之所以要这样做,是因为RandomAccessFile 拥有与其他IO 类型完全不同的行为,因为我们可在一个文件里向前或向后移动。不管在哪种情况下,它都是独立运作的,作为Object 的一个“直接继承人”使用。从根本上说,RandomAccessFile 类似DataInputStream 和DataOutputStream 的联合使用。其中,getFilePointer()用于了解当前在文件的什么地方,seek()用于移至文件内的一个新地点,而length()用于判断文件的最大长度。此外,构建器要求使用另一个自变量(与C 的fopen()完全一样),指只是随只是随机读(”r”),还是读写兼施(”rw”)。这里没有提供对“只写文件”的支持。也就是说,假如是从DataInputStream 继承的,那么RandomAccessFile 也有可能能很好工作。还有更难对付的。很容易想象我们有时要在其他类型的数据流中搜索,比如一个ByteArrayInputStream,但搜索方法只有RandomAccessFile 才会提供。而后者只能针对文件才能操作,不能针对数据流操作。此时,BufferedInputStream 确实允许我们标记一个位置(使用mark(),它的值容纳于单个内部变量中),并用reset()重设那个位置。但这些做法都存在限制,并不是特别有用。
五.Java IO中常用的类
以上图片来源:https://www.cnblogs.com/ylspace/p/8128112.html
六 .File类
- java.io.File类:文件和目录路径名的抽象表示形式,与平台无关
- File 能新建、删除、重命名文件和目录,但 File 不能访问文件内容本身。如果需要访问文件内容本身,则需要使用输入/输出流。
- File对象可以作为参数传递给流的构造函数
- File类的常见构造方法:public File(String pathname)
以pathname为路径创建File对象,可以是绝对路径或者相对路径,如果pathname是相对路径,则默认的当前路径在系统属性user.dir中存储。
public File(String parent,String child)
以parent为父路径,child为子路径创建File对象。
File的静态属性String separator存储了当前系统的路径分隔符。
在UNIX中,此字段为’/’,在Windows中,为’\’
此节内容转载自:https://www.cnblogs.com/baixl/p/4170599.html
七.IO流的典型应用
1.缓冲输入文件.
如果想要打开一个文件用于字符输入,可以使用String或File对象作为文件名的FileReader。为了提高速度,我么希望对那个文件进行缓冲,那么我们将所产生的引用传给一个BufferedReader构造器,由于BufferedReader也提供readLine()方法,所以这是我们的最终对象和进行读取的接口。当readLine()返回null时,你就打到了文件的末尾。
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BufferedReaderFile {
public static String read(String fileName) throws IOException {
BufferedReader reader = new BufferedReader(new FileReader(fileName));
String s;
StringBuffer buffer = new StringBuffer();
while ((s = reader.readLine()) != null) {
buffer.append(s + "\n");
}
reader.close();
return buffer.toString();
}
public static void main(String[] args) throws IOException {
System.out.println(read("BufferedReaderFile.java"));
}
}
2.从内存输入
在下面的示例中,从上面的BuffereredInputFile.read()读入的String结果被用来创建一个StringReader。然后调用read()每次读取一个字符,并把它发送到控制台。
public static String read(String fileName) throws IOException {
BufferedReader reader = new BufferedReader(new FileReader(fileName));
String s;
StringBuffer buffer = new StringBuffer();
while ((s = reader.readLine()) != null) {
buffer.append(s + "\n");
}
reader.close();
return buffer.toString();
}
public static void main(String[] args) throws IOException {
StringReader buffer = new StringReader(read("MemoryInput.java"));
int c;
while ((c = buffer.read()) != -1) {
System.out.println((char) c);
}
}
}
注意read()是以int形式返回下一字节,因此必须类型转换为char才能正确打印。
3.格式化内存输入
要读取格式化数据,可以使用DataInputStream,它是一个面向自己的I/O类(不是面向字符的)。因此我们必须使用InputStream类而不是Reader类。当然,我们可以用InputStream以字节的形式读取任何数据(例如一个文件),不过,在这里使用的是字符串。
public class FormattedMemoryInput {
public static String read(String fileName) throws IOException {
BufferedReader reader = new BufferedReader(new FileReader(fileName));
String s;
StringBuffer buffer = new StringBuffer();
while ((s = reader.readLine()) != null) {
buffer.append(s + "\n");
}
reader.close();
return buffer.toString();
}
public static void main(String[] args) throws IOException{
try {
DataInputStream input = new DataInputStream(
new ByteArrayInputStream(read("FormattedMemoryInput.java").getBytes()));
while (true)
System.out.println((char) input.readByte());
} catch (EOFException e) {
System.out.println("End of stream"); // 读到文件结尾时会抛出异常
}
}
}
必须为ByteArrayInputStream提供字节数组,为了产生该数组String包含了一个可以实现此项工作的getBytes()方法。所产生的ByteArrayInpuStream是一个适合传递给DataInputStream的InputStream。
如果我们从DataInputStream用readByte()一次一个字节的读取,那么任何字节的值都是合法的结果,因此返回值不能用来检测输入是否结束。相反,我们可以使用available()方法查看还有多少可供存取的字符。下面这个例子演示了怎样一次一个字节地读取文件:
public class TestEOF {
public static void main(String[] args) throws IOException {
DataInputStream in = new DataInputStream(
new BufferedInputStream(new FileInputStream("TestEOF.java")));
while (in.available() != 0)
System.out.println((char) in.readByte());
}
}
注意,available()的工作方式会随着所读取的媒介类型的不同而有所不同,字面意思就是“在没有阻塞的情况下所能读取的字节数”。对于文件,这意味着整个文件;但是对于不同类型的流,可能就不是这样的,因此要谨慎使用。
我们来看看哪些地方可以用available()方法来获取文件大小,进而用来定义缓冲数组的长度:
1.在本地文件文件中,这里我一般是直接使用的。
2.网络中的文件
a.比如web 中http 里面的文件流里面,第一种情况有content-length,那么小文件的情况,我们是直接可以通过request 获取该属性,也就知道文件的大小了。
b.在某些情况下,比如文件比较大,采用采用分段方式,长连接的方式发送,不能一次知道文件大小,http 的header 里面就没有上面的content-length 属性,而是变成了Transfer-Encoding: chunked属性,这表示分段发送信息,但是对整个文件的接受,可以通过一些标志位,或者一些超时限制等方法处理,这里不具体研究了。
c.socket 传输文件,是没重写available方法的,也就是说我们不能通过这个知道流的字节数,一般情况下,我们可以先发送一段自定义的header 过去,描述文件大小,然后再循环持续获取流信息。
我们也可以通过捕获异常(EOFException)来检测输入的末尾。但是,使用异常进行流控制,被认为是对异常特性的错误使用。
4.基本的文件输出
FileWriter对象可以向文件写入数据。首先,创建一个与指定文件连接的FileWriter。实际上,我们通常会用BufferedWriter将其包装起来用以缓冲输出(尝试移除此包装来感受对性能的影响——缓冲往往能显著地增加IO操作的性能)
public class BasicFileOutput {
static final String file = "BasicFileOutput.java";
public static String read(String fileName) throws IOException {
BufferedReader reader = new BufferedReader(new FileReader(fileName));
String s;
StringBuffer buffer = new StringBuffer();
while ((s = reader.readLine()) != null) {
buffer.append(s + "\n");
}
reader.close();
return buffer.toString();
}
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new StringReader(read(file)));
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(file)));
int lineCount = 1;
String s;
while ((s = reader.readLine()) != null) {
out.println(lineCount++ + ":" + s);
}
out.close();
System.out.println(read(file));
}
}
一旦读完输入数据流,readLine()会返回null。我们可以看到要为out显示调用close()。如果我们不为所有的输出文件调用close(),就会发现缓冲区内容不会被刷新清空,那么它们也就不完整。
文本文件输出的快捷方式
JavaSE5 在PrintWriter中添加了一个辅助构造器,使得你不必在每次希望创建文本文件并向其中写入时,都去执行所有的装饰工作。下面是这种快捷方式重写的BasicFileOutput.java
public class BasicFileOutput {
static final String file = "BasicFileOutput.java";
public static String read(String fileName) throws IOException {
BufferedReader reader = new BufferedReader(new FileReader(fileName));
String s;
StringBuffer buffer = new StringBuffer();
while ((s = reader.readLine()) != null) {
buffer.append(s + "\n");
}
reader.close();
return buffer.toString();
}
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new StringReader(read(file)));
PrintWriter out = new PrintWriter(file); // 这地方未执行所有的装饰工作
int lineCount = 1;
String s;
while ((s = reader.readLine()) != null) {
out.println(lineCount++ + ":" + s);
}
out.close();
System.out.println(read(file));
}
}
查看PrintWriter的带有String类型的参数的构造函数,源码如下:
public PrintWriter(String fileName) throws FileNotFoundException {
this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName))),
false);
}
通过源码可知装饰工作已在源码中完成了。
5.存储和恢复数据
PrintWriter可以对数据进行格式化(既根据数据的实际类型输出和或写入),以便人们的阅读。但是为了输出可供一个“流”恢复的数据,我们需要用DatatOutputStream写入数据,并用DataInputStream恢复数据。当然,这些流可以是任何形式,但在下面的示例中使用的是一个文件,并且对于读和写都进行了缓存处理。注意DataOutputStream和DataInputStream是面向字节的,因此要使用InputStream和OutputStream
public class StoringAndRecoveringData {
public static void main(String[] args) throws IOException {
DataOutputStream out = new DataOutputStream(
new BufferedOutputStream(new FileOutputStream("D:\\xx.txt")));
out.writeDouble(2423.343);
out.writeInt(1314);
out.writeChars("d");
out.writeUTF("utf-8");
out.writeDouble(4545.5656);
out.close();
DataInputStream in = new DataInputStream(
new BufferedInputStream(new FileInputStream("D:\\xx.txt")));
System.out.println(in.readDouble());
System.out.println(in.readInt());
System.out.println(in.readChar());
System.out.println(in.readUTF());
System.out.println(in.readDouble());
// 下面读取的顺序必须和上面写入的顺序一样
}
}
如果我们使用DataOutputStream写入数据,Java保证我们可以使用DataInputStream准确地读取数据——无论读和写数据的平台多么不同。
6.读写随机访问文件
使用RandomAccessFile,类似于组合使用了DatInpuStream和DataOutputStream(因为它实现了相同的接口:DataInput和DataOutput)。另外我们可以看到,利用seek()可以在文件中到处移动,并修改文件中的某个值。
在使用RandomAccessFile时,你必须知道文件排版,这样才能准确地操作它。RandomAccessFile拥有读取基本类型和UTF-8字符串的各种具体方法。
public class UsingRandomAccessFile {
static String file = "rtest.dat";
static void display() throws IOException {
RandomAccessFile rf = new RandomAccessFile(file, "r");
for (int i = 0; i < 7; i++) {
System.out.println("Value " + i + " : " + rf.readDouble());
}
System.out.println(rf.readUTF());
rf.close();
}
public static void main(String[] args) throws IOException {
RandomAccessFile rf = new RandomAccessFile(file, "rw");
for (int i = 0; i < 7; i++) {
rf.writeDouble(i * 1.44);
}
rf.writeUTF("the end of the file");
rf.close();
display();
rf = new RandomAccessFile(file, "rw");
rf.seek(5 * 8);
rf.writeDouble(47.0001);
rf.close();
display();
}
}
display()方法打开了一个文件,并以double值的形式显示了其中的七个元素。在main()中,首先创建了文件,然后打开并修改了它。因为double总是8字节长,所以为了用seek()查找第5个双精度值,你只需5*8来产生查找位置。
正如先前所指,RandomAccessFile除了实现DataInput和DataOutput接口之外,有效地与I/O继承层次结构的其他部分实现了分离。因为它不支持装饰,所以不能将其与InputStream及OutputStream子类的任何部分组合起来。
可以自行选择的是第二个构造器参数:我们可指定以“只读”(r)方式或“读写”(rw)方式打开一个RandomAccessFile文件重点内容