流习题及思考题- 首都师范大学精品课程网

更新时间:2024-05-27 17:30:01 阅读量: 综合文库 文档下载

说明:文章内容仅供预览,部分内容可能不全。下载后的文档,内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的,是否完整无缺。

流习题及思考题

1、编一个应用程序,按行顺序地读取一个可读文件的内容。 解:import java.io.*; public class ReadFile

{ public static void main(String args[]) { String s;

FileInputStream is; InputStreamReader ir; BufferedReader in; try

{ is=new FileInputStream(\ ir=new InputStreamReader(is); in=new BufferedReader(ir); while((s=in.readLine())!=null) System.out.println(\ }

catch(FileNotFoundException e)

{ System.out.println(\ System.exit(-2); }

catch(IOException e)

{ System.out.println(\ System.exit(-3); } } }

2、把Hashtable存放的信息输出到磁盘文件中,并再从中读进Hashtable. import java.io.*;

import java.util.Hashtable;

public class ObjectIOClass extends implements Serializable{ public static void main(String args[]) throws Exception {

Hashtable ht=new Hashtable(); //建立Hashtable 的对象实例

DataInputStream dis=new DataInputStream(System.in); //建立DataInputStream对象,并且与//标准输入对象连接。

String st_no=dis.readLine(); //从标准输入读一行存入st_no String st_rec=dis.readLine(); //从标准输入读一行存入st_rec

ht.put(st_no,st_rec); //st_no作关键字,st_rec为Hashtable保存的对象,存入ht System.out.println(ht);

String st_no1=dis.readLine(); //从标准输入读一行存入st_no1

if (ht.containsKey(st_no1)) //如Hashtable对象中有st_no1,打印对应的对象 System.out.println(ht.get(s3));

else System.out.println(\

ObjectReadWrite my_object=new ObjectReadWrite (); //建立文件对象 my_object.write(ht); //如ht对象输出到输出源 my_object.read(); //从输入源读入对象 }}

public class ObjectReadWrite {

static File object_file=new File(\public static void write(Hashtable ht ) { try{

//建立FileOutputStream对象,并且与文件对象object_file 连接 FileOutputStream fos=new FileOutputStream(object_file); // 建立ObjectOutputStream对象,并且与文件对象fos连接 ObjectOutputStream oos=new ObjectOutputStream ( fos);

oos.writeObject(ht); //Hashtable对象内容写入输出文件中 //o1.flush(); oos.close();

} catch(Exception e){}; }

public static void read(){ //从对象输入文件中读对象 try{

//建立ObjectOutputStream对象,并且与文件对象object_file 连接。

ObjectInputStream ois=new ObjectInputStream( new FileInputStream(object_file )); Hashtable ht1=(Hashtable)ois.readObject(); //从输入源读入对象 System.out.println(ht1); //标准输出ht1 }

catch(Exception e){ e.printStackTrace(); } } }

3、利用StringBuffer类编写从键盘读入字符串、整数、实型数,并在屏幕上输出。 源程序:

import java.io.*;

public class StringBufferToString {

public static void main(String[] args) throws IOException {

char ch;

StringBuffer strb = new StringBuffer(); //创建一个空的StringBuffer类

System.out.println(\ while((ch = (char)System.in.read() )! = '\\n') {

strb.append(ch); //把字符连接到当前串尾

}

String str = strb.toString( ); //把StringBuffer类转换为String类 System.out.println(\ System.out.println(str); } }

4、什么叫流?简述流的分类?

“流”可以被理解为一条“管道”。这条“管道”有两个端口:一端与数据源(当输入数据时)或数据宿(当输出数据时)相连,另一端与程序相连。在与数据源或是数据宿相连的端口,“管道”在读/写数据时能够应付数据源和数据宿的多样性,消化掉因数据源和数据宿的多样性带来的数据读/写的复杂性;而在与程序相连的端口,“管道”提供了输入/输出的统一界面。

根据流中的数据传输的方向,流可分为输入流和输出流;根据“管道”里流动的数据的类型,流可分为字符流和字节流;根据流的建立方式和工作原理,流可分为节点流与过滤流。

5、编写一个测试文件一般属性(如显示文件的路径、绝对路径、显示文件是否可写、显示文件是否可读、显示文件的大小等属性)的程序。 import java.io.*;

public class FileInfo {

public static void main(String[] args) {

System.out.println(\ char c;

StringBuffer buf = new StringBuffer( ) ; try {

while( (c = (char)System.in.read() ) != '\\n') buf.append(c);

//将输入的字符加到buf中,直到遇见回车符 } catch(java.io.IOException e) {

System.out.println(\ }

File file = new File(buf.toString( ).trim( ) ); //创建File类的file对象

if ( file.exists( ) )

//如果文件在当前目录存在 {

System.out.println(\ //显示文件的文件名

System.out.println(\

//显示文件的路径

System.out.println(\ //显示文件的绝对路径

System.out.println(\ //显示文件是否可写

System.out.println(\ // 显示文件是否可读

System.out.println(\ //显示文件的大小 }

else //如果文件不在当前目录 System.out.println(\ //显示文件没有找到的提示消息 } }

6、利用RandomAccessFile类编写应用程序,要求输入10组数据到文件中,每组数据为1个整形数和一个双精度数,然后随机修改文件的某组数,并显示修改的结果。 import java.io.*;

public class testRandom2{

public static void main(String args[]){ try{

RandomAccessFile rf=new RandomAccessFile(\for(int i = 0; i < 10; i++){ rf.writeInt(i);

rf.writeDouble(i*1.414); }

rf.close();

rf = new RandomAccessFile(\rf.seek(5*(4+8)); rf.writeInt(47);

rf.writeDouble(47.0001); rf.close();

rf = new RandomAccessFile(\for(int i = 0; i < 10; i++){ ;

System.out.println(\}

rf.close();

}catch(IOException e){

System.out.println(e.toString()); } } }

7、将如下三组不同类型的数据利用DataInputStream和DataOutputStream写入文件,然后从文件中读出。 三组数据如下

{ 19.99, 9.99, 15.99,3.99, 4.99 }; { 12, 8, 13, 29, 50 };

{ \

解:import Java.io.*; public class DataIOTest {

public static void main(String[] args) throws IOException {

//创建数据输出流

DataOutputStream out = new DataOutputStream(new FileOutputStream(\ //初始化输出数据

double[] prices = { 19.99, 9.99, 15.99, 3.99, 4.99 }; int[] units = { 12, 8, 13, 29, 50 }; String[] descs = { \ \ \ \ \ };

//数据输出

for (int i = 0; i < prices.length; i ++) {

out.writeDouble(prices[i]); out.writeChar('\\t'); out.writeInt(units[i]); out.writeChar('\\t');

out.writeChars(descs[i]); out.writeChar('\\n'); } //关闭数据输出流 out.close();

//创建数据输入流

DataInputStream in = new DataInputStream( new FileInputStream(\

double price; int unit;

String desc;

double total = 0.0; try { //利用数据输入流读文件内容 while (true) {

price = in.readDouble();

in.readChar(); // throws out the tab unit = in.readInt();

in.readChar(); // throws out the tab desc = in.readLine();

System.out.println(\ unit + \ desc + \ total = total + unit * price; } } //捕获异常 catch (EOFException e) { e.printStackTrace(); }

System.out.println(\ //关闭数据输入流 in.close(); } }

8、利用BufferedReader和BufferedWriter在文件中实现输入输出字符串。 import java.io.*;

public class ko24_6 {

public static void main(String args[]) throws IOException {

String line; String str=\ BufferedWriter kow=new BufferedWriter(new FileWriter(\ kow.write(str,0,str.length()); kow.flush(); BufferedReader kor=new BufferedReader(new FileReader(\ line=kor.readLine(); System.out.println(line); } }

9、什么是过滤流,并举例

解:过滤流在读/写数据的同时可以对数据进行处理,它提供了同步机制,使得某一时刻只有一个线程可以访问一个I/O流,以防止多个线程同时对一个I/O流进行操作所带来的意想不到的结果。类FilterInputStream和FilterOutputStream分别作为所有过滤输入流和输出流的父类。

为了使用一个过滤流,必须首先把过滤流连接到某个输入/出流上,通常通过在构造方法的参数中指定所要连接的输入/出流来实现。例如:

FilterInputStream( InputStream in ); FilterOutputStream( OutputStream out ); 下面的类均是过滤流的例子

BufferedInputStream和BufferedOutputStream

缓冲流,用于提高输入/输出处理的效率。 DataInputStream 和 DataOutputStream

不仅能读/写数据流,而且能读/写各种的java语言的基本类型,如:boolean,int,float等。

LineNumberInputStream

除了提供对输入处理的支持外,LineNumberInputStream可以记录当前的行号。 PushbackInputStream

提供了一个方法可以把刚读过的字节退回到输入流中,以便重新再读一遍。 PrintStream

打印流的作用是把Java语言的内构类型以其字符表示形式送到相应的输出流。

10、什么是串行化,并举例

解:对象的寿命通常随着生成该对象的程序的终止而终止。有时候,可能需要将对象的状态保存下来,在需要时再将对象恢复。我们把对象的这种能记录自己的状态以便将来再生的能力,叫做对象的持续性(persistence)。对象通过写出描述自己状态的数值来记录自己,这个过程叫对象的串行化(Serialization)。

串行化的目的是为java的运行环境提供一组特性,其主要任务是写出对象实例变量的数值。

首先定义一个可串行化对象

public class Student implements Serializable{ int id; //学号

String name; //姓名 int age; //年龄

String department //系别

public Student(int id,String name,int age,String department){ this.id = id;

this.name = name; this.age = age;

this.department = department; } }

其次是构造对象的输入/输出流 java.io包中,提供了ObjectInputStream和ObjectOutputStream将数据流功能扩展至可读写对象。在ObjectInputStream中用readObject()方法可以直接读取一个对象,ObjectOutputStream中用writeObject()方法可以直接将对象保存到输出流中。 Student stu=new Student(981036,\ FileOutputStream fo=new FileOutputStream(\ //保存对象的状态

ObjectOutputStream so=new ObjectOutputStream(fo); try{

so.writeObject(stu); so.close();

}catch(IOException e )

{System.out.println(e);}

FileInputStream fi=new FileInputStream(\ ObjectInputStream si=new ObjectInputStream(fi); //恢复对象的状态 try{

stu=(Student)si.readObject(); si.close();

}catch(IOException e ) {System.out.println(e); }

本文来源:https://www.bwwdw.com/article/jn77.html

Top