实训项目九:文件与数据流
- 格式:doc
- 大小:62.00 KB
- 文档页数:8
第8章文件与数据流一、文件和流的概念文件是指在各种驱动器上(硬盘、可移动磁盘等)永久或临时存储的数据的有序集合,是进行数据读/写操作的基本对象。
文件通常具有文件名、路径、访问权限等属性。
流从概念上来说类似于单独的磁盘文件,它也是进行读/写操作的对象。
流提供了连续的字节存储空间,通过流可以向后备的存储器写入数据,也可以从后备存储器读取数据。
与磁盘文件直接相关的流称为“文件流”。
除此之外,还有网络流、内存流等其他类型的流。
流用于传输数据时,有两个传输方向:读:将数据从外部数据源传输到程序中,这是读取流。
写:将数据从程序传输到外部数据源,这是写入流。
二、相关知识1.流的创建FileStream fs = new FileStream( "test1.dat",FileMode.Create, FileAccess.Write);一般格式:FileStream fs = new FileStream( string path,FileMode mode, FileAccess access);参数含义:path:指定当前FileStream对象将封装的文件的相对路径或绝对路径。
可以只是文件名(在程序所在目录下创建或打开文件)mode:指定如何打开或创建文件,它的值必须是FileMode枚举中的值。
access:指定如何访问文件,它的值必须是FileAccess枚举中的值。
2)将数据写入流fs.write(byte[] array,int offset,int count);参数含义:array:要写入文件流的字节数组offset:array数组中开始写入文件流的字节的下标。
count:将要写入流的最大字节数3)从流中读取数据fs.ReadByte()从流中读取一个字节(返回已转换为int的字节),并将流内的位置向前推进一个。
如果已经到达流的末尾,则返回-1。
在读之前,用canRead属性确定当前对象是否支持读取操作。
文件与数据流实习报告一文件的性质:(1用来长期保存大量的数据在程序结束后长期(永久)存在,件一般位于外存储设备上(硬盘、光盘、磁带)比较:内存中的变量或数组中的数据是临时性数据,程序结束时就会丢失。
(2)位流:计算机中的数据是以0与1的方式存储在两个装置间存取数据, 以1或0的方式进行,ava将数据在目的地与来源之间的流动抽象化为一个流,即位流。
(3)数据流:数据流是一系列的数据,循环处理每个数据单元,直到遇到结束符或出现异常(Exception)。
二输入输出流:Java中输入输出流主要分为字节流和字符流。
所有字节流都继承java.io.InputStream ,和java.ioOutputStream它们两个都是抽象类。
(1)输入字节流:a 所有字节流都继承java.io.InputStream .b 类InputStream的成员方法read( )读入单个无符号字节(unsigned byte)的数据,并返回一个整数类型(int)的值(与读入的无符号字节数据相对应)正常返回: 介于0和255之间的一个数如果遇到数据流结束,则返回-1c public int read(byte[ ] data) throws IOException 和public int read(byte[ ] data, intoffset, int length) throws IOException的用法。
read(byte[ ] data) t从输入流中读取一定数量的字节,并将其存储在缓冲区数组data 中。
以整数形式返回实际读取的字节数。
在输入数据可用、检测到文件末尾或者抛出异常前,此方法一直阻塞。
如果data 的长度为0,则不读取任何字节并返回0;否则,尝试读取至少一个字节。
如果因为流位于文件末尾而没有可用的字节,则返回值-1;否则,至少读取一个字节并将其存储在data 中。
read(byte[ ] data, int offset, int length)是将长度是从offset开始读length个字节。
第05章文件与数据流●java语言提供了很多类来处理目录、文件、文件数据,这些类主要位于包“java.io”中。
5.1 输入流与输出流●输入流:外部设备>> 内存InputStream及其子类●输出流:内存>> 外部设备OutputStream及其子类5.1.1 InputStream和FileInputStream●InputStream -处理输入流的类,抽象类例题:第132页例题要点:-control+Z :windows操作系统中流的结束标记public abstract int read() 方法:从输入流读入一个字节,若没有字节可读,则返回-1。
System.in:对应于标准输入,即键盘的输入。
是指向InputStream类型实例的应用。
InputStream类还有其他成员方法:public int available() 返回当前输入流中有效的字节数public int read(byte[] b) 一次读入多个字符,并存放在字节数组b中●FileInputStream -处理文件输入流的类,InputStream的子类对文件内容进行操作的基本步骤:1. 创建文件所对应的实例;public FileInputStream(String name) 构造方法2. 对文件进行读写操作;父类InputStream中继承3. 关闭文件:public void close()5.1.2 OutputStream和FileOutputStream●OutputStream -处理输出流的类,抽象类例题:第138页例题要点:public abstract int write(byte[] b) 方法:输出内容b。
System.out:对应于标准输出,即输出到屏幕。
是指向OutputStream类型实例的应用。
public void flush() 强制立即输出缓存中的数据●FileOutputStream -处理文件输出流的类,OutputStream的子类对文件内容进行操作的基本步骤:1. 创建文件所对应的实例;构造方法:public FileOutputStream(String name)public FileOutputStream(String name,boolean append)2. 对文件进行读写操作;父类InputStream中继承public void write(byte[] b)public void write(byte[] b, int off, int len)public void write(int b)3. 关闭文件:public void close()5.1.3 PrintStream●非常重要的输出流,System.out就是PrintStream的实例的一个引用。
文件与数据流一.实验目的:1.掌握输入输出流类的层次关系和类中的方法2.输入输出流类的编程方法二、实验内容:1.从输入或输出流类或子类创建输入或输出流对象.2.利用输入或输出流对象的方法读或写文件。
三.实验内容:1.从键盘上输入10个整数,然后将它们从小到大排序并写入文件c1.txt,然后将文件中的内容读出,输出到屏幕上。
程序如下:import java.io.*;import java.util.Scanner;public class FileIOStream {public static void main(String[] args) throws IOException { int temp = 0;int[] s=new int[10];String str="";Scanner sc = new Scanner(System.in);FileOutputStream out=new FileOutputStream("c1.txt");PrintStream p=new PrintStream(out);System.out.print("请连续输入10个整数:");for(int i =0;i<s.length;i++){s[i]=sc.nextInt();}for(int i=0;i<s.length;i++){str=s[i]+"";}byte b[]=str.getBytes();out.write(b);out.flush();out.close();for (int i = 0; i < s.length-1; i++) {for (int j = 0; j < s.length - i - 1; j++) {if (s[j] > s[j + 1]) {temp = s[j];s[j] = s[j + 1];s[j + 1] = temp;}}}System.out.println("10个数字从小到大排列:");for (int i = 0; i <s.length; i++) {System.out.print(s[i]+",");}}}运行结果:C1.txt文档内容:2.将文件f1.txt的内容加密(加密算法自己设计)后存放到f2.txt中。
《9.2 文件和文件流》1. 目标概述[5分钟] (2)2. 回顾[5分钟] (2)3. 课程知识点讲解 (2)3.1. 文件的基本概念[5分钟] (2)3.2. 文件流类与文件流对象[3分钟] (3)3.3. 文件的打开与关闭[20分钟] (3)3.4. 文本文件的读写[20分钟] (5)3.5. 二进制文件的读写[15分钟] (6)3.6. 文件指针[15分钟] (7)3.7. 随机访问二进制文件[15分钟] (7)3.8. 任务解决[30分钟] (8)4. 精练[45分钟] (8)5. 小结[2分钟] (8)6. 技能提升[90分钟] (10)7. 考核点 (11)8. 作业答案 (11)9. 扩展练习 (11)10. 学生问题汇总 (11)11. 教学后记 (12)本节目标⏹本节中将讲述如下主要内容:✧文件的基本知识✧文件流的基本知识✧文件的打开与关闭✧文本文件的读写✧二进制文件的读写✧随机访问二进制文件⏹通过教学使学生掌握文件和文件流的使用。
本节重点⏹文件和文件流的基本知识⏹文件的打开与关闭和读写⏹二进制文件的读写⏹随机访问二进制文件本节难点⏹文件的读写授课课时⏹6课时教法建议1.目标概述 [5分钟]本节主要讲述文件和文件流。
提出本节的任务。
2.回顾 [5分钟]回顾上一节的相关内容。
3.课程知识点讲解3.1.文件的基本概念[5分钟]引入:前面的程序设计中,都是以系统的标准设备进行输入/输出,但这种方式最大的缺点就是无法长久保存数据,实际应用中,通常需要利用磁盘等存储介质,以文件的形式来保存数据。
什么是“文件”(File)?主题:文件是指以一定格式存储在外部存储器(相对于CPU而言)上的数据集合。
这里的“外部存储器”可以是指硬盘、光盘、U盘等各类存储介质,因此可以根据存储介质的不同的将文件分为硬盘文件、光盘文件、U盘文件等。
这里的“一定格式”是指文件存储时的组织方式,通常可分为ASCII码文件与二进制文件两种方式。
文件与数据流一.实验目的:1.掌握输入输出流类的层次关系和类中的方法2.输入输出流类的编程方法二、实验内容:1.从输入或输出流类或子类创建输入或输出流对象.2.利用输入或输出流对象的方法读或写文件。
三.实验内容:1.从键盘上输入10个整数,然后将它们从小到大排序并写入文件c1.txt,然后将文件中的内容读出,输出到屏幕上。
程序如下:import java.io.*;import java.util.Scanner;public class FileIOStream {public static void main(String[] args) throws IOException { int temp = 0;int[] s=new int[10];String str="";Scanner sc = new Scanner(System.in);FileOutputStream out=new FileOutputStream("c1.txt");PrintStream p=new PrintStream(out);System.out.print("请连续输入10个整数:");for(int i =0;i<s.length;i++){s[i]=sc.nextInt();}for(int i=0;i<s.length;i++){str=s[i]+"";}byte b[]=str.getBytes();out.write(b);out.flush();out.close();for (int i = 0; i < s.length-1; i++) {for (int j = 0; j < s.length - i - 1; j++) {if (s[j] > s[j + 1]) {temp = s[j];s[j] = s[j + 1];s[j + 1] = temp;}}}System.out.println("10个数字从小到大排列:");for (int i = 0; i <s.length; i++) {System.out.print(s[i]+",");}}}运行结果:C1.txt文档内容:2.将文件f1.txt的内容加密(加密算法自己设计)后存放到f2.txt中。
实验三文件与数据流实验报告一、实验目的1. 掌握输入输出流类的层次关系和类中的方法及输入输出流的编程方法。
2. 理解对象序列化。
二、实验要求1. 利用InputStream(抽象类)的子类FileInputStream以及BufferedInputStream类对文件进行读入操作。
BufferedInputStream相对于FileInputStream类而言增加了缓存,减少了IO 操作,在一定程序上提升了程序的性能。
同理,利用OutputStream的子类FileOutputStream 和BufferedOutputStream类进行文件的输出操作。
2. 通过DataInputStream和DataOutputStream对象进行基本数据类型的写入文件和从文件读出的操作。
3. 通过ObjectInputStream和ObjectOutputStream可以直接把对象写入到文件或者从文件中读出。
同时,如果要使对象能够通过这个类写入到文件中,这个类需要实现Serializable 接口。
三、实验内容1. 将文件f1.txt的内容加密(字母’A’ 变为’C’,字母’B’ 变为字母‘D’,…,字母‘Z’ 变为’B’)后存放到f2.txt中。
读出f2.txt文件的内容,并显示解密后的内容。
import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;public class FileExperiment00 {public static void main(String[] args) {try {encrypt();decrypt();} catch (Exception e) {e.printStackTrace();}}public static void encrypt() throws Exception {File f1 = new File("f1.txt");File f2 = new File("f2.txt");if (!f1.exists()) {System.out.println("文件不存在");return;}if (!f2.exists()) {f2.createNewFile();}FileInputStream in = new FileInputStream(f1);BufferedInputStream bis = new BufferedInputStream(in);FileOutputStream out = new FileOutputStream(f2);BufferedOutputStream bos = new BufferedOutputStream(out);int b;while ((b = bis.read()) != -1) {bos.write(Encrypt.encrypt((byte) b));}bos.close();bis.close();}public static void decrypt() throws Exception {File file = new File("f2.txt");if (!file.exists()) {System.out.println("文件不存在!");return;}FileInputStream in = new FileInputStream(file);BufferedInputStream bis = new BufferedInputStream(in);byte[] buffer = new byte[2];while (bis.read(buffer) > 0) {buffer[0] = Encrypt.decrypt(buffer[0]);buffer[1] = Encrypt.decrypt(buffer[1]);System.out.print(new String(buffer));}bis.close();}}class Encrypt {public static byte encrypt(byte b) {if ((b >= 65 && b <= 88) || (b >= 97 && b <= 120)) {return (byte) (b + 2);} else if ((b >= 89 && b <= 90) || (b >= 121 && b <= 122)) { return (byte) (b - 24);} else {return b;}}public static byte decrypt(byte b) {if ((b >= 67 && b <= 90) || (b >= 99 && b <= 122)) {return (byte) (b - 2);} else if ((b >= 65 && b <= 66) || (b >= 97 && b <= 98)) { return (byte) (b + 24);} else {return b;}}}2. 从键盘中输入若干个实数(以-999999.999结束),按大小顺序存放到d1.txt,并从该文件中读取数据,在屏幕上显示(每行输出5个数)import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.EOFException;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.util.Arrays;import java.util.LinkedList;import java.util.Scanner;public class FileExperiment01 {public static void main(String[] args) {try {getData();readData();} catch (Exception e) {e.printStackTrace();}}public static void readData() throws Exception {File file = new File("d1.txt");DataInputStream in =new DataInputStream(new FileInputStream(file));double d = 0;while (true) {try {d = in.readDouble();System.out.println(d);} catch (EOFException e) {break;}}in.close();}public static void getData() throws Exception {LinkedList<Double> numbers = new LinkedList<Double>();Scanner s = new Scanner(System.in);while (true) {try {double value = s.nextDouble();if (value == -999999.999) {break;}numbers.add(value);} catch (Exception e) {throw new RuntimeException(e);}}double[] array = new double[numbers.size()];for (int i = 0; i < array.length; i++) {array[i] = numbers.get(i);}Arrays.sort(array); // 系统自带的 sort 方法进行排序DataOutputStream out =new DataOutputStream(new FileOutputStream(new File("d1.txt")));for (double d : array) {out.writeDouble(d);}if (out != null) {out.close();}}}3. 定义一个学生类(成员变量有学号、姓名和成绩),从键盘输入若干学生的信息(学号为’000’结束),并将学生信息存入到文件stu.txt中。
数据流、缓冲区、⽂件类型、⽂件存取⽅式1.1 数据流:指程序与数据的交互是以流的形式进⾏的。
进⾏C语⾔⽂件的存取时(例如从数据库读取内容到txt⽂本,从txt数据读取数据到数据库等),都会先进⾏“打开⽂件”操作,这个操作就是在打开数据流,⽽“关闭⽂件”操作就是关闭数据流。
1.2 缓冲区(Buffer):指在程序执⾏时,所提供的额外内存,可⽤来暂时存放做准备执⾏的数据。
它的设置是为了提⾼存取效率,因为内存的存取速度⽐磁盘驱动器快得多。
因为程序是具有局部性的,包括时间的局部和空间的局部,Cache从内存存取数据时会预取⼀个Cache Line缓存起来,操作系统从硬盘读取数据时会预读⼏个页⾯缓存起来,都是希望这些数据以后会被程序访问到。
⼤多数的程序⾏为都有局部性的特点:它们会花费⼤量的时间反复执⾏⼀⼩段的代码(例如循环),或者反复访问⼀个很⼩的地址范围中的数据(例如数组)。
其实CPU取数据就是这样之⾏的,先从寄存器⾥取值,没有了再从⼀级缓存⾥⾯取值,有⼆级缓存的在从⼆级缓存⾥⾯取值,再从物理内存⾥取数据,最后如果都没有了再从硬盘中去数据。
C语⾔中带缓冲区的⽂件处理:C语⾔的⽂件处理功能依据系统是否设置“缓冲区”分为两种:⼀种是设置缓冲区,另⼀种是不设置缓冲区。
由于不设置缓冲区的⽂件处理⽅式,必须使⽤较低级的I/O函数(包含在头⽂件io.h和fcntl.h中)来直接对磁盘存取,这种⽅式的存取速度慢,并且由于不是C的标准函数,跨平台操作时容易出问题。
下⾯只介绍第⼀种处理⽅式,即设置缓冲区的⽂件处理⽅式:当使⽤标准I/O函数(包含在头⽂件stdio.h中)时,系统会⾃动设置缓冲区,并通过数据流来读写⽂件。
当进⾏⽂件读取时,不会直接对磁盘进⾏读取,⽽是先打开数据流,将磁盘上的⽂件信息拷贝到缓冲区内,然后程序再从缓冲区中读取所需数据,如下图所⽰:事实上,当写⼊⽂件时,并不会马上写⼊磁盘中,⽽是先写⼊缓冲区,只有在缓冲区已满或“关闭⽂件”时,才会将数据写⼊磁盘,如下图所⽰。
C#篇基础知识6——⽂件和流计算机以⽂件的形式把数据存储在磁盘、光盘等存储设备上。
⽂件的管理和操作是操作系统的⼀个重要组成部分,.NET 框架提供了⼀组功能强⼤的类,可以⽅便地对⽂件进⾏操作和管理。
1.⽂件操作相关的类⽤于⽂件操作的类位于System.IO 命名空间中,⽤这些类可以⽅便地对⽂件进⾏创建、读写、复制、删除、移动、打开等操作。
2.File类和FileInfo类命名空间 System.IO 中的File 类⽤于对⽂件进⾏创建、打开、复制、移动、删除、重命名等典型操作,并能获取或设置⽂件的属性信息。
File 类中所有的⽅法都是静态的,使⽤起来⾮常简单,File 类的部分⽅法如下图所⽰:File类的⽅法使⽤起来⾮常⽅便:using System;using System.IO;static void Main(string[] args){ string path = @"D:\test.txt";if(File.Exists(path)) //如果⽂件已经存在,则读取⽂件内容{ //读取⽂件string contents = File.ReadAllText(path);Console.WriteLine("读取⽂件:\n" + contents); }else //如果⽂件不存在,则创建⽂件并写⼊内容{ string contents = "⽆可奈何花落去,\n 似曾相识燕归来,\n ⼩园⾹径独徘徊。
";File.WriteAllText(path, contents); //写⼊⽂件Console.WriteLine("⽂件已写⼊。
" ); }}注意 WriteAllText()、WriteAllLines()和WriteAllBytes()⽅法都会覆盖以前的⽂件,使⽤时要特别⼩⼼。
要想在⽂件尾部追加新⽂本,请使⽤AppendAllText()⽅法。
实训项目九:文件与数据流一、实训目的1.理解数据流的概念;2.理解Java流的层次结构;3.理解文件的概念;二、实训要求1.掌握字节流的基本使用方法;2.掌握字符流的基本使用方法;3.能够创建、读写、更新文件;三、实训内容(一)使用标准数据流的应用程序标准数据流指在字符方式下(如DOS 提示符)程序与系统进行输入输出的方式,键盘和显示器屏幕是标准输入输出设备,数据输入的起点为键盘,数据输出的终点是屏幕,输出的数据可以在屏幕上显示出来。
1.程序功能:将键盘上输入的字符在屏幕上显示出来2.编写Stdio_1.java 程序文件,源代码如下。
public class Stdio_1{public static void main(String[] args) throws java.io.IOException {byte buffer[]=new byte[10];System.out.println("从键盘输入不超过10 个字符,按回车键结束输入:");int count =System.in.read(buffer);//读取输入的字符并存放在缓冲区buffer 中System.out.println("保存在缓冲区buffer 中元素的个数为:"+count);System.out.println("buffer 中各元素的值为:");for (int i=0;i<count;i++){System.out.print(" "+ buffer[i]);//在屏幕上显示buffer 元素的值}System.out.println();System.out.println("输出buffer 字符元素:");System.out.write(buffer, 0, buffer.length);}}3.编译、运行Stdio_1.java 文件。
(二)使用文件输入输出流的应用程序1. 程序功能:将保存在本地机当前文件夹中的File1.html 文本文件的内容在屏幕上显示出来,然后将其另存为File2.txt 文件。
2. 编写FileIO_2.java 程序文件,源代码如下import java.io.*;public class FileIO_2 {public static void main(String[] args) throws IOException {FileReader in=new FileReader("File1.html");//建立文件输入流BufferedReader bin=new BufferedReader(in);//建立缓冲输入流FileWriter out=new FileWriter(" File2.txt",true);//建立文件输出流String str;while ((str=bin.readLine())!=null) {//将缓冲区内容通过循环方式逐行赋值给字符串strSystem.out.println(str);//在屏幕上显示字符串strout.write(str+"\n");//将字符串str 通过输出流写入File2.txt 中}in.close();out.close();}}3. 编译、运行程序(三)使用随机文件类的应用程序使用文件输入类FileReader 只能将文件内容全部读入。
如果要选择读入文件的内容,可使用随机文件类RandomAccessFile。
1.程序功能:建立数据流,通过指针有选择的读入文件内容。
2.编写RandomFile.java 程序文件,源代码如下。
import java.io.*;public class RandomFile {public static void main(String args[]) {String str[]={"First line\n","Second line\n","Last line\n"};try {RandomAccessFile rf=new RandomAccessFile("File2.txt", "rw");System.out.println("\n 文件指针位置为:"+rf.getFilePointer());System.out.println("文件的长度为:"+rf.length());rf.seek(rf.length());System.out.println("文件指针现在的位置为:"+rf.getFilePointer());for (int i=0; i<3; i++)rf.writeChars(str[i]); // 字符串转为字节串添加到文件末尾rf.seek(10);System.out.println("\n 选择显示的文件内容:");String s;while ((s=rf.readLine())!=null)System.out.println(s);rf.close();}catch (FileNotFoundException fnoe) {}catch (IOException ioe) {}}}3.编译并运行程序(四)使用数据输入输出流与文件输入输出流类的应用程序使用数据输入流DataOutputStream 和数据输出流DataInputStream 可以读取或写入任何Java 类型的数据,不用关心它们的实际长度是多少字节。
一般与文件输入流FileInputStream 和输出流类FileOutputStream 一起使用。
1.程序功能:将整型数据和字符串对象通过数据输出流写到文件中。
将文件中的整型数据和字符串对象通过数据输出流读出,并在屏幕上显示文件中的内容。
2.编写DataIO.java 程序文件,源代码如下。
import java.io.*;public class DataIO{public static void main(String arg[]){try{ //添加方式创建文件输出流FileOutputStream fout = new FileOutputStream("File4.txt",true);DataOutputStream dout = new DataOutputStream(fout);dout.writeInt(1);dout.writeChars("罗马"+"\n");dout.writeInt(2);dout.writeChars("北京"+"\n");dout.close();}catch (IOException ioe){}System.out.println(“写文件内容完成!”);try{Thread.sleep(3000);}catch(Exception e){}try{FileInputStream fin = new FileInputStream("File4.txt");DataInputStream din = new DataInputStream(fin);int i = din.readInt();while (i!=-1) //输入流未结束时,输入流结束时i 为-1{System.out.print(i+" ");char ch ;while ((ch=din.readChar())!='\n') //字符串未结束时System.out.print(ch);System.out.println();i = din.readInt();}din.close();}catch (IOException ioe){}}}3.编译并运行程序(五)使用对象输入输出流的应用程序使用对象流可以直接写入或读取一个对象。
由于一个类的对象包含多种信息,为了保证从对象流中能够读取到正确的对象,因此要求所有写入对象流的对象都必须是序列化的对象。
一个类如果实现了Serializable 接口,那么这个类的对象就是序列化的对象。
Serializable 接口没有方法,实现该接口的类不需要实现额外的方法。
1.程序功能:保存对象信息到文件,并将文件中的对象信息显示出来。
2.编写Student.java 程序文件,源代码如下。
import java.io.*;public class Student implements Serializable {private String name=null;private String sex=null;private int age=0;public Student(){}public Student(String name,String sex,int age){=name;this.sex=sex;this.age=age;}public String getName() {return name;}public void setName(String name) { = name;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}void save(String fname)//保存到文件中的方法{try{FileOutputStream fout = new FileOutputStream(fname);//输出文件流ObjectOutputStream out = new ObjectOutputStream(fout);//输出对象流out.writeObject(this); //写入对象out.close();}catch (FileNotFoundException fe){}catch (IOException ioe){}}void display(String fname)//显示文件中对象信息的方法{try{FileInputStream fin = new FileInputStream(fname);//输入文件流ObjectInputStream in = new ObjectInputStream(fin);//输入对象流Student OO = (Student)in.readObject(); //读取对象System.out.println(" 类名:"+OO.getClass().getName()+""+OO.getClass().getInterfaces()[0]);System.out.println(" "+OO.getName()+" "+OO.getSex()+""+OO.getAge());in.close();}catch (FileNotFoundException fe){}catch (IOException ioe){}catch (ClassNotFoundException ioe) {}}public static void main(String[] args){String fname="Student.obj";Student stu=new Student("张三","男",19);stu.save(fname);stu.display(fname);//下面请自己编写代码查看该文件的内容,即以文本方式显示出文件内容}}(六)使用File对象的应用程序File对象能完成操作系统下的文件和目录的操作,实现了文件和目录的属性查看和目录文件的创建、读写、更新。