第7章 输入输出处理.

Presentation on theme: "第7章 输入输出处理."— Presentation transcript:

1 第7章 输入输出处理

2 7.1 输入/输出概述 在Java中，应用程序所需要读入的数据和写出的数据是通过I/O操作实现的。这些读写数据的源或目的包括文件、内存、网络连接等，其中，最常用的是文件。 Java中的输入输出流可以分为两大类：输入流和输出流。输入流是能够读取字节序列的对象，而输出流是能够写字节序列的对象。最初设计的输入输出类是面向字节流的，即能够支持8位的字节流，分别由派生自抽象类InputStream和OutputStream的类层次来表示。但是随着对国际化支持的需求出现，面向字节的流不能很好地处理使用Unicode（每个字符使用两个字节）的数据，因此引入了派生自抽象类Reader和Writer的类层次，用于读写双字节的Unicode字符，而不是单字节字符。

3 1．字节流InputStream和OutputStream类 (1)InputStream
7.1.1输入输出类 1．字节流InputStream和OutputStream类 (1)InputStream InputStream中包含一套字节输入流需要的方法，可以完成最基本的从输入流读入数据的功能。当Java程序需要外设的数据时，可根据数据的不同形式，创建一个适当的InputStream子类类型的对象来完成与该外设的连接，然后再调用执行这个流类对象的特定输入方法来实现对相应外设的输入操作。 InputStream类的类层次参见课本143页. InputStream类子类对象自然也继承了InputStream类的方法。常用的方法有：读数据的方法read()，获取输入流字节数的方法available()，定位输入位置指针的方法skip()、reset()、mark()等。

4 (2)OutputStream OutputStream中包含一套字节输出流需要的方法，可以完成最基本的输出数据到输出流的功能。当Java程序需要将数据输出到外设时，可根据数据的不同形式，创建一个适当的OutputStream子类类型的对象来完成与该外设的连接，然后再调用执行这个流类对象的特定输出方法来实现对相应外设的输出操作。 OutputStream类的类层次参见课本143页 OutputStream类子类对象也继承了OutputStream类的方法。常用的方法有：写数据的方法write()，关闭流方法close()等。 在InputStream类和OutputStream类子类中，FilterInputStream和FilterOutputStream过滤流抽象类又派生出DataInputStream和DataOutputStream数据输入输出流类等子类。

5 过滤流的主要特点是在输入输出数据的同时能对所传输的数据做指定类型或格式的转换，即可实现对二进制字节数据的理解和编码转换。数据输入流DataInputStream中定义了多个针对不同类型数据的读方法，如readByte()、readBoolean()、readShort()、readChar()、readInt()、readLong()、readFloat()、readDouble()、readLine()等。数据输出流DataOutputStream中定义了多个针对不同类型数据的写方法，如writeByte()、writeBoolean()、writeShort()、writeChar()、writeInt()、writeLong()、writeFloat()、writeDouble()、writeChars()等。

6 2．字符流Reader和Writer类 (1)Reader (2)Writer
Reader中包含一套字符输入流需要的方法，可以完成最基本的从输入流读入数据的功能。当Java程序需要外设的数据时，可根据数据的不同形式，创建一个适当的Reader子类类型的对象来完成与该外设的连接，然后再调用执行这个流类对象的特定输入方法，如read()，来实现对相应外设的输入操作。 Read类的类层次参见课本144页 (2)Writer Writer中包含一套字符输出流需要的方法，可以完成最基本的输出数据到输出流的功能。当Java程序需要将数据输出到外设时，可根据数据的不同形式，也要创建一个适当的Writer子类类型的对象来完成与该外设的连接，然后再调用执行这个流类对象的特定输出方法，如write()，来实现对相应外设的输出操作。 Writer类的类层次参见课本144页

7 二、标准输入输出 为方便使用计算机常用的输入输出设备，各种高级语言与操作系统对应，都规定了可用的标准设备（文件）。所谓标准设备（文件），也称为预定义设备（文件），在程序中使用这些设备（文件）时，可以不用专门的打开操作就能简单的应用。一般地，标准输入设备是键盘，标准输出设备是终端显示器，标准错误输出设备也是显示器。 Java语言的系统类System提供访问标准输入输出设备的功能。System类是继承Object类的终极类，它有三个类变量in、out和err分别表示标准输入、标准输出和标准错误输出流。

8 (1)标准输入 (2)标准输出 System类的类变量in表示标准输入流，其定义为：
public static final InputStream in 标准输入流已打开，作好提供输入数据的准备。一般这个流对应键盘输入，可以使用InputStream 类的read()和skip(long n)等方法来从输入流获得数据。read()从输入流中读一个字节，skip(long n)在输入流中跳过n个字节。 (2)标准输出 System类的类变量out表示标准输出流，其定义为： public static final PrintStream out 标准输出流也已打开，作好接收数据的准备。一般这个流对应显示器输出。

9 可以使用PrintStream 类的print()和println()等方法来输出数据，这两个方法支持Java的任意基本类型作为参数。标准输入输出允许重定向。
(3)标准错误输出 System类的类变量err表示标准错误输出流，其定义为： public static final PrintStream err 标准错误输出流已打开，作好接收数据的准备。一般这个流也对应显示器输出，与System.out一样，可以访问PrintStream类的方法。标准错误输出不能重定向。

10 【例7.1】读写标准文件。将键盘输入的字符输出到屏幕并统计输入的字符数。
import java.util.Scanner; class MyType{ public static void main(String args[]){ int count = 0; String b = ""; Scanner sc = new Scanner(System.in); System.out.println("请输入："); while(sc.hasNext()){ b=sc.next(); System.out.print(b); count+=b.length(); } System.out.println(); // 输出换行 System.err.println("\n输入了"+count+"个字符。"); // 使用标准错误输出设备

11 程序运行时，显示“请输入：”，这时，可在光标提示处输入任意字符，按回车键则显示上一次按回车键后输入的字符串。要结束输入可按组合键<Ctrl>+<z>，此时程序将显示输入的字符数。

12 7.2 文件的顺序访问 输入输出流操作的一般步骤如下： 其中步骤(2)～(5)要考虑异常处理。
(1)使用引入语句引入java.io包：import java.io.*; (2)根据不同数据源和输入输出任务，建立字节流或字符流对象。 (3)若需要对字节或字符流信息组织加工为数据，在已建字节流或字符流对象上构建数据流对象。 (4)用输入输出流对象类的成员方法进行读写操作，需要时，设置读写位置指针。 (5)关闭流对象。 其中步骤(2)～(5)要考虑异常处理。

13 7.2.1 字节流（InputStream类和OutputStream类）
InputStream类和OutputStream类都是抽象类，不能直接生成对象，要通过继承类来生成程序中所需要的对象，在继承类中，一般将InputStream类和OutputStream类中的方法重写来满足需要。 1.FileInputStream 和FileOutputStream类 类FileInputStream 和FileOutputStream分别直接继承于InputStream和OutputStream，它们重写或实现了父类中的一些方法以顺序访问本地文件，是字节流操作的基础类。 (1)创建字节输入文件流FileInputStream类对象 若需要以字节为单位顺序读出一个已存在文件的数据，可使用字节输入流FileInputStream。可以用文件名、文件对象或文件描述符建立字节文件流对象。

14 FileInputStream类构造方法有：
FileInputStream(String name) 用文件名name建立流对象。 例如：FileInputStream fis = new FileInputStream ("c:/config.sys"); FileInputStream(File file)用文件对象file建立流对象。 例如：File myFile = new File("c:/config.sys"); FileInputSteam fis = new FileInputStream(myFile); 若创建FileInputStream输入流对象成功，就相应地打开了该对象对应的文件，接着就可以从文件读取信息了。若创建对象失败，将产生异常FileNotFoundException，这是一个非运行时异常，必须捕获和抛出，否则编译会出错。

15 (3)创建字节输出文件流FileOutputStream类对象
(2)读取文件信息 从FileInputStream流中读取字节信息，一般用read()成员方法，该方法有重载： int read()读流中一个字节，若流结束则返回-1。 int read(byte b[])从流中读字节填满字节数组b，返回所读字节数，若流结束则返回-1。 int read(byte b[],int off, int len)从流中读字节填入b[off]开始处，返回所读字节数，若流结束则返回-1。 (3)创建字节输出文件流FileOutputStream类对象 FileOutputStream可表示一种创建并顺序写的文件。在构造此类对象时，若指定路径的文件不存在，会自动创建一个新文件；若指定路径已有一个同名文件，该文件的内容将被保留或删除。

16 FileOutputStream类的构造方法有：
FileOutputStream对象用于向一个文件写数据。象输入文件一样，也要先打开这个文件后才能写这个文件。要打开一个FileOutputStream对象，象打开一个输入流一样，可以将字符串或文件对象作为参数。 FileOutputStream类的构造方法有： FileOutputStream(String name) 用文件名name创建流对象。 例如：FileOutputStream fos = new FileOutputStream("d:/out.dat"); FileOutputStream(File file) 用文件对象file建立流对象。 例如：File myFile = new File("d:/out.dat"); FileOutputStream fos = new FileOutputStream(myFile);

17 (4)向输出流写信息 (5)关闭FileInputStream
向FileOutputStream中写入信息，一般用write()方法，该方法有重载： void write(int b)将整型数据的低字节写入输出流。 void write(byte b[])将字节数组b中的数据写入输 出流。 void write(byte b[],int off,int len)将字节数组b中从off开始的len个字节数据写入输出流。 (5)关闭FileInputStream 当完成一个文件的操作，可用两种方法关闭它：显式关闭和隐式关闭，隐式关闭是让系统自动关闭它，Java有自动垃圾回收的功能。显式关闭是使用close()方法，例如： fos.close();

18 【例7.2】完成文件复制功能。用命令行方式提供源文件名和目标文件名。 //用法：java CopyFile 源文件名 目标文件名
import java.io.*; class CopyFile { public static void main(String args[])throws IOException{ int i; FileInputStream fin; FileOutputStream fout; try { fin = new FileInputStream(args[0]); } catch(FileNotFoundException e) { System.out.println("输入文件未找到！"); return; }

19 try { // 打开输出文件 fout = new FileOutputStream(args[1]); } catch(FileNotFoundException e) { System.out.println("打开输出文件错误！"); return; } } catch(ArrayIndexOutOfBoundsException e) { System.out.println(“用法: CopyFile 源文件 目标文件"); try { // 复制文件 while((i = fin.read())!= -1) fout.write(i); } catch(IOException e) { System.out.println("文件错误！"); fin.close(); fout.close();

20 【例7.3】在终端上显示指定文本文件的内容，文本文件名通过命令行方式提供。 //用法：java ShowFile TEST.TXT
import java.io.*; class ShowFile { public static void main(String args[])throws IOException{ int i; FileInputStream fin = null; try { fin = new FileInputStream(args[0]); } catch(FileNotFoundException e) { System.out.println("文件未找到！"); System.exit(-1); } catch(ArrayIndexOutOfBoundsException e) { System.out.println(“ 用法: java ShowFile 文件名"); System.exit(-2); }

21 // 读字符直到遇到EOF while(( i = fin.read()) != -1) System.out.print((char) i); fin.close(); }

22 2.DataInputStream 和DataOutputStream类
字节文件流FileInputStream 和FileOutputStream只能提供纯字节或字节数组的输入/输出，如果要进行基本数据类型如整数和浮点数的输入/输出。则要用到过滤流类的子类二进制数据文件流DataInputStream 和DataOutputStream类。这两个类的对象必须和一个输入类或输出类联系起来，而不能直接用文件名或文件对象建立。 使用数据文件流的一般步骤： (1)建立字节文件流对象; (2)基于字节文件流对象建立数据文件流对象; (3)用流对象的方法对基本类型的数据进行输入/输出。

23 DataInputStream类的构造方法如下：
DataInputStream(InputStream in)创建过滤流FilterInputStream对象并为以后的使用保存InputStream参数in。 DataOutputStream类的构造方法如下： DataOutputStream(OutputStream out)创建输出数据流对象写数据到指定的OutputStream 。 【例7.4】在C盘根目录下建立文件FIB.DAT，存储Fibonacci数列的前20个数。Fibonacci数列的前两个数是1，从第三个数开始，是其前两个数之和。即1,1,2,3,5,8,13,21,.…。

24 import java.io.*; class FibOut { public static void main(String args[]) { try { // 创建字节文件输出流 OutputStream fos = new FileOutputStream("c:/fib.dat"); DataOutputStream dos = new DataOutputStream(fos); int count = 0,i = 1,j = 1; for(;count < 20; count++){ dos.writeInt(i); int k = i + j; i = j; j = k; } fos.close(); // 关闭文件输出流 } catch(Exception e) { System.out.println("Exception: " + e); System.out.println("文件创建成功！");

25 程序运行正常结束后，可以在C盘的根目录见到创建的文件FIB
程序运行正常结束后，可以在C盘的根目录见到创建的文件FIB.DAT。这是二进制数据文件，用系统的TYPE命令查看其内容是无意义的。可用下面的例7.5程序来查看其内容。 【例7.5】从例7.4建立的文件中读取Fibonacci数据并显示到屏幕上。(参见课本)

26 3.BufferedInputStream和BufferedOutputStream类
若处理的数据量较多，为避免每个字节的读写都对流进行，可以使用过滤流类的子类缓冲流。缓冲流建立一个内部缓冲区，输入输出数据先读写到缓冲区中进行操作，这样可以提高文件流的操作效率。 缓冲输出流BufferedOutputStream类提供和FileOutputStream类同样的写操作方法，但所有输出全部写入缓冲区中。当写满缓冲区或关闭输出流时，它再一次性输出到流，或者用flush()方法主动将缓冲区输出到流。 当创建缓冲输入流BufferedInputStream时，一个输入缓冲区数组被创建，来自流的数据填入缓冲区，一次可填入许多字节。

27 (1)创建BufferedOutputStream流对象
若要创建一个BufferedOutputStream流对象，首先需要一个FileOutputStream流对象，然后基于这个流对象创建缓冲流对象。 BufferedOutputStream 类的构造方法如下： BufferedOutputStream(OutputStream out)创建缓冲输出流，写数据到参数指定的输出流，缓冲区设为缺省的512字节大小。 BufferedOutputStream(OutputStream out, int size)创建缓冲输出流，写数据到参数指定的输出流，缓冲区设为指定的size字节大小。

28 (2)用flush()方法更新流 例如，下面的代码可创建一个缓冲输出流bos： FileOutputStream fos =
new FileOutputStream("/user/dbf/stock.dbf"); BufferedOutputStream bos = new BufferedOutputStream(fos); (2)用flush()方法更新流 要想在程序结束之前将缓冲区里的数据写入磁盘，除了填满缓冲区或关闭输出流外，还可以显式调用flush()方法。flush()方法的声明为： public void flush() throws IOException 例如：bos.flush();

29 (3)创建BufferedInputStream流对象 BufferedInputStream类的构造方法如下：
BufferedInputStream(InputStream in) 创建BufferedInputStream流对象并为以后的使用保存InputStream参数in，并创建一个内部缓冲区数组来保存输入数据。 BufferedInputStream(InputStream in, int size) 用指定的缓冲区大小size创建BufferedInputStream流对象，并为以后的使用保存InputStream参数in。

30 (4)缓冲流类的应用 BufferedInputStream bis = new BufferedInputStream(fis);
缓冲流类一般与另外的输入输出流类一起配合使用。对例7.5，可以将流对象定义修改为： FileInputStream fis = new FileInputStream("c:/fib.dat"); BufferedInputStream bis = new BufferedInputStream(fis); DataInputStream dis = new DataInputStream(bis);

31 4.PrintStream类 过滤流类的子类PrintStream类提供了将Java的任何类型转换为字符串类型输出的能力。输出时，可应用经常使用的方法print()和println()。 创建PrintStream流也需要OutputStream流对象。PrintStream类的构造方法有： public PrintStream(OutputStream out)创建一个新的打印流对象。 public PrintStream(OutputStream out,boolean autoFlush)创建一个新的打印流对象。布尔值的参数autoFlush为true时，当写一个字节数组、引用println()方法或写newline字符或写字节('\n')时，缓冲区内容将被写到输出流。

32 【例7.6】使用PrintStream流。 import java.io.*; import java.awt.*;
public class PrintStreamDemo{ public static void main(String args[]) throws IOException{ FileOutputStream fos = new FileOutputStream("PrintStream"); PrintStream ps = new PrintStream(fos); Button b1 = new Button("Button"); ps.println(123); ps.println( ); ps.println("123"+456); ps.println(123==123.0); ps.println(b1); 方法 ps.close(); fos.close(); }

33 程序运行后，使用记事本等文本编辑软件打开 printstream文件，可看到其内容如下：
屏幕显示的结果如下： 123 123456 true java.awt.Button[button0,0,0,0x0,invalid,label=Button]

34 7.2.2 字符流（Reader类和Writer类）
由于Java采用16位的Unicode字符，因此需要基于字符的输入/输出操作。从Java1.1版开始，加入了专门处理字符流的抽象类Reader和Writer，前者用于处理输入，后者用于处理输出。这两个类类似于InputStream和OuputStream，也只是提供一些用于字符流的接口，本身不能用来生成对象。 Reader和Writer类也有较多的子类，与字节流类似，它们用来创建具体的字符流对象进行IO操作。字符流的读写等方法与字节流的相应方法都很类似，但读写对象使用的是字符。

35 1.InputSteamReader和OutputStreamWriter类
这是java.io包中用于处理字符流的基本类，用来在字节流和字符流之间搭一座“桥”。这里字节流的编码规范与具体的平台有关，可以在构造流对象时指定规范，也可以使用当前平台的缺省规范。 InputSteamReader和OutputStreamWriter类的构造方法如下： public InputSteamReader(InputSteam in) public InputSteamReader(InputSteam in,String enc) public OutputStreamWriter(OutputStream out) public OutputStreamWriter(OutputStream out,String enc)

36 2.FileReader和FileWriter类
其中in和out分别为输入和输出字节流对象，enc为指定的编码规范（若无此参数，表示使用当前平台的缺省规范，可用getEncoding()方法得到当前字符流所用的编码方式）。 读写字符的方法read()、write()，关闭流的方法close()等与Reader和Writer类的同名方法用法都是类似的。 2.FileReader和FileWriter类 FileReader和FileWriter类是InputSteamReader和OutputStreamWriter类的子类，利用它们可方便地进行字符输入/输出操作。 FileReader类的构造方法有： FileReader(File file)对指定要读的file创建FileReader对象。

37 FileReader(String fileName) 对指定要读的 fileName创建FileReader对象。
FileWriter类的构造方法有： FileWriter(File file) 对指定的file创建FileWriter对象。 FileWriter(String fileName) 对指定的fileName创建FileWriter对象。 这两个构造方法都可带第二个布尔值的参数append，当append为true时，为添加到输出流。 FileReader类中可用的方法有：read()返回输入字符，read(char[] buffer)输入字符到字符数组中等。 FileWriter类中常用的方法有：write(String str)和Write(char[] buffer)输出字符串，write(int char)输出字符，flush()输出缓冲字符，close()在执行flush后关闭输出流，getEncoding()获得文件流字符的编码等。

38 【例7.7】使用FileWriter类输出字符。
程序运行结果如下： Encoding:GBK 执行系统命令 >type filewriter.txt后显示如下： Java Programming. import java.io.*; class FileWriterDemo { public static void main(String args[]){ FileWriter out = null; try{ out = new FileWriter("FileWrite.txt"); System.out.println("Encoding:" + out.getEncoding()); out.write("Java Programming."); out.close(); }catch(IOException e){} }

39 3.BufferedReader和BufferedWriter类
public BufferedReader(Reader in) public BufferedReader(Reader in,int sz) public BufferedWriter(Writer out) public BufferedWriter(Writer out,int sz) 其中in和out分别为字符流对象，sz为缓冲区大小。从上述构造方法的声明可以看出，缓冲流的构造方法是基于字符流创建相应的缓冲流。

40 在BufferedReader和BufferedWriter类中，除了Reader和Writer中提供的基本读写方法外，增加了对整行字符的处理方法readLine()和newLine()。前者从输入流中读取一行字符，行结束标志为回车符和换行符；后者向字符输出流中写入一个行结束标记，该标记是由系统定义的属性line.separator。 【例7.8】创建顺序文本文件。使用FileWriter类和BufferedWriter类和用write()方法写文件。

41 import java.io.*; class BufferedWriterDemo{ public static void main(String[] args){ try{ FileWriter fw=new FileWriter(args[0]); BufferedWriter bw=new BufferedWriter(fw); for(int i = 0; i < 10; i++) { // 将字符串写至文件 bw.write("Line " + i + "\n\r"); } bw.close(); // 关闭缓冲字符输出流 }catch(Exception e) { System.out.println("Exception: " + e);

42 若程序编译成功，运行命令为： java BufferedWriterDemo p7-8.txt // 指明创建的输出文件为 p7-8.txt 程序运行后，可见到当前目录下，已经创建了p7-8.txt文件。可用系统命令type查看其内容，内容为Line 0至Line 9共10行信息。

43 【例7.9】读顺序文本文件。使用FileReader类和BufferedReader类和用readLine()方法读文件。
import java.io.*; class BufferedReaderDemo { public static void main(String args[]) { try { FileReader fr = new FileReader(args[0]); BufferedReader br = new BufferedReader(fr); String s; while((s = br.readLine()) != null) System.out.println(s); fr.close(); } catch(Exception e) { System.out.println("Exception: " + e);} }

44 PrintWriter类的构造方法如下：
PrintWriter类提供字符流的输出处理。由于该类的对象可基于字节流或字符流来创建，写字符的方法print()、println()可直接将Java基本类型的数据转换为字符串输出，用起来很方便。 PrintWriter类的构造方法如下： PrintWriter(OutputStream out) PrintWriter(OutputStream out, boolean autoFlush) PrintWriter(Writer out) PrintWriter(Writer out, boolean autoFlush) 例如，为文件test.txt创建PrintWriter对象pw的语句可为： PrintWriter pw = new PrintWriter(new FileOutputStream("test.txt")); 或:PrintWriter pw=new PrintWriter(new FileWriter("test.txt"));

45 【例7.10】将键盘输入的字符存储到命令行参数指定的文件中。
import java.io.*; public class ReadKey{ public static void main(String args[]){ File f = new File(args[0]); try{ BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); PrintWriter pw = new PrintWriter(new FileWriter(f)); String s; System.out.println( "请输入文本：(按Ctrl+z结束输入。)"); while((s = br.readLine())!=null)pw.println(s); br.close(); pw.close(); }catch(IOException e){ e.printStackTrace(); }

46 7.3 文件的随机访问 1.建立随机访问文件流对象 Java提供的RandomAccessFile类可进行随机形式的输入输出。
RandomAccessFile类直接继承于Object，但由于实现了DataInput和DataOutput接口而与同样实现该接口的DataInputStream和DataOutputStream类方法很类似。 1.建立随机访问文件流对象 建立RandomAccessFile类对象类似于建立其他流对象，RandomAccessFile类的构造方法如下： RandomAccessFile(File file, String mode) RandomAccessFile(String name, String mode)

47 其中，name为文件名字符串，file为File类的对象，mode为访问文件的方式，有“r”或“rw”两种形式。若mode为“r”，则文件只能读出，对这个对象的任何写操作将抛出IOException异常；若mode为“rw”并且文件不存在，则该文件将被创建。若name为目录名，也将抛出IOException异常。 例如，打开一个数据库后更新数据： RandomAccessFile rf = new RandomAccessFile ("/usr/db/stock.dbf", "rw"); 2.访问随机访问文件 RandomAccessFile对象的读写操作和DataInput/DataOutput对象的操作方式一样。可以使用在DataInputStream和DataOutputStream里出现的所有read()和write()方法。

48 3.移动文件指针 随机访问文件的任意位置的数据记录读写是通过移动文件指针指定文件读写位置来实现的。与文件指针有关的常用方法有：
public long getFilePointer()throws IOException返回文件指针的当前字节位置。 public void seek(long pos) throws IOException 将文件指针定位到一个绝对地址pos。pos参数指明相对于文件头的偏移量，地址0表示文件的开头。例如，将文件rf的文件指针移到文件尾，可用语句： rf.seek(rf.length()); 其中：public long length()throws IOException返回文件的长度。地址"length()"表示文件的结尾。 public int skipBytes(int n)throws IOException将文件指针向文件尾方向移动n个字节。

49 4.向随机访问文件增加信息 【例7.11】使用随机访问文件读写数据。
可以用访问方式"rw"打开随机访问文件后，向随机访问文件增加信息。例如： rf = new RandomAccessFile("c:/config.sys","rw"); rf.seek(rf.length()); 【例7.11】使用随机访问文件读写数据。 import java.io.*; public class RandomIODemo { public static void main(String args[]) throws IOException { RandomAccessFile rf = new RandomAccessFile("random.txt","rw"); rf.writeBoolean(true); rf.writeInt(123456); rf.writeChar('j'); rf.writeDouble( );

50 程序的输出结果如下： 123456 rf.seek(1); System.out.println(rf.readInt());
System.out.println(rf.readChar()); System.out.println(rf.readDouble()); rf.seek(0); System.out.println(rf.readBoolean()); rf.close(); } 程序的输出结果如下： 123456 j true

51 【例7.12】显示指定文本文件最后n个字符。文本文件名和数字n用命令行参数的方式提供。
import java.io.*; class RandomIODemo2{ public static void main(String args[]) { try { RandomAccessFile rf = new RandomAccessFile(args[0], "r"); long count = Long.valueOf(args[1]).longValue(); long position = rf.length(); position -= count; if(position < 0) position = 0; rf.seek(position); while(true) {

52 这个命令表示显示程序RandomIODemo2.java的最后50个字符。
byte b = rf.readByte(); System.out.print((char)b); }catch(EOFException eofe) { break; } }catch(Exception e) { e.printStackTrace(); 若程序正确编译后，执行命令为: java RandomIODemo2 RandomIODemo2.java 50 这个命令表示显示程序RandomIODemo2.java的最后50个字符。

53 7.4 目录和文件管理 java.io包中的File类提供了与具体平台无关的方式来描述目录和文件对象的属性功能。其中包含大量的方法可用来获取路径、目录和文件的相关信息，并对它们进行创建、删除、改名等管理工作。因为不同的系统平台，对文件路径的描述不尽相同。为做到平台无关，在Java语言中，使用抽象路径等概念。Java自动进行不同系统平台的文件路径描述与抽象文件路径之间的转换。 File类的直接父类是Object类。

54 7.4.1 目录管理 7.4.2 文件管理 1．创建一个新的文件对象 目录操作的主要方法为：
public boolean mkdir() 根据抽象路径名创建目录。 public String[] list() 返回抽象路径名表示路径中的文件名和目录名。 7.4.2 文件管理 在进行文件操作时，常需要知道一个关于文件的信息。Jave的File类提供了一个成员方法来操纵文件和获得一个文件的信息。另外，File类还可以对目录和文件进行删除、属性修改等管理工作。 1．创建一个新的文件对象 可用File类的构造方法来生成File对象。File类的构造方法有：

55 2．文件测试和使用 File(String pathname)通过给定的路径名变换的抽象路径创建文件对象。
File(File parent, String child)从父抽象路径（目录）和子路径字符串创建文件对象。 File(String parent, String child) 从父路径和子路径字符串创建文件对象。 这些构造方法取决于访问文件的方式。例如，若在应用程序里只用一个文件，第一种创建文件的结构是最容易的。但若在同一目录里打开数个文件，则后两种方法更好一些。 2．文件测试和使用 一旦创建了一个文件对象，便可以使用下述方法来获得文件相关信息。

56 (1)获得文件名 (2)文件重命名 (3)文件删除 public String getName() 得到一个文件名。
public String getParent() 得到一个抽象路径的父路径名。 public String getPath() 得到一个文件的路径名。 public String getAbsolutePath() 得到一个抽象路径的绝对路径名。 (2)文件重命名 public boolean renameTo(File dest) 将抽象路径文件名重命名为给定的新文件名。 (3)文件删除 public boolean delete() 删除抽象路径表示的文件或目录。

57 (4)文件测试 (5)获得一般文件信息 public boolean exists() 检查文件是否存在。
public boolean canWrite() 检查文件是否可写。 public boolean canRead() 检查文件是否可读。 public boolean isFile() 检查文件是否为正常文件（非目录）。 public boolean isDirectory() 检查抽象路径表示的是否为目录。 public boolean isAbsolute()检查抽象路径表示的是否为绝对路径。 (5)获得一般文件信息 public long lastModified() 得到抽象路径表示的文件最近一次修改的时间。 public long length() 得到抽象路径表示的文件的长度。

58 【例7.13】获取文件信息。显示所给文件的基本信息，文件名通过命令行参数方式提供。
import java.io.*; public class FileInfo{ public static void main(String args[]) throws IOException{ File fileToCheck; if(args.length > 0){ for(int i = 0;i<args.length;i++){ fileToCheck = new File(args[i]); info(fileToCheck); } } else { System.out.println("命令行未给出文件！");

59 public static void info (File f) throws IOException {
System.out.println("绝对路径: "+ f.getAbsolutePath()); System.out.println("路 径: "+f.getPath()); System.out.println("父路径（目录）: " +f.getParent()); System.out.println("文件名: "+f.getName()); if(f.exists()){ System.out.println("文件存在。"); System.out.println(“是目录？：” + f.isDirectory()); System.out.println("可读？：" + f.canRead()); System.out.println("可写？：" + f.canWrite()); System.out.println("文件长度：" + f.length() +" 字节。");

60 设运行字节码文件的命令行是（本程序可以输入多个命令行参数）：
System.out.println("文件最后修改时间：" + f.lastModified()); } else { System.out.println("文件不存在！"); } 设运行字节码文件的命令行是（本程序可以输入多个命令行参数）： Java FileInfo d:\lu\!jiaocai\java程序\FileInfo.java

61 则程序的运行结果如下： 绝对路径: d:\lu\!jiaocai\java程序\FileInfo.java 路 径: d:\lu\!jiaocai\java程序\FileInfo.java 父路径（目录）: d:\lu\!jiaocai\java程序 文件名: FileInfo.java 文件存在。 是目录？：false 可读？：true 可写？：true 文件长度：925 字节。 文件最后修改时间： 注意：程序输出中路径（getPath()的输出）和父路径（getParent()的输出）两行内容与命令行参数写法有关。若只给出文件名，则路径为文件名，父路径为null。

62 【例7.14】显示工作目录下的文件名和目录名信息。
import java.io.*; class DirTree { public static void main(String args[]) { File dir = new File(System.getProperty("user.dir")); if(dir.isDirectory()){ System.out.println("Directory of "+ dir); String listing[]= dir.list(); for(int i = 0;i<listing.length()&&i<10;i++) System.out.println("\t"+listing[i]); }

63 程序的输出结果如下（程序中控制只显示前10个目录和文件名）：
Directory of D:\lu\!jiaocai\Java程序 LinkExample.jar ButtonDemoSelf.java FontDemo.java FontDemo.class FontDemo.html Drawings.html Drawings.java ColorString.java Demo.java Beeper.java

64 本章小结 字节流类InputStream和OutputStream类 FileInputStream和 fileOutputStream类
DataInputStream和 DataOutputStream类 BufferedInputStream和 BufferedOutputStream类 PrintStream类 字符流类Reader和Writer InputStreamReader和 OutputStreamReader类 FileReader和FileWriter类 BufferedReader和BufferedWriter类 PrintWriter类 文件的随机访问RandomAccessFile 目录文件管理