习题解答chapter09
题目
- Java中流的分类有哪些?
- 字节流InputStream和OutputStream的子类分别有哪些?请举例说明其使用场景。与其对应的字符流分别有哪些?
- 字节流与字符流的转化是怎样的?Java对此提供了哪些支持?
- Java中的过滤流(流的装配)有什么作用?请举例说明常用的过滤流。
- 什么是对象的序列化和反序列化?Java对此提供了哪些支持?
- Java的File类表示什么?有什么作用?
- Java对文件的读写分别提供了哪些支持?
1. Java中流的分类有哪些?
- 从流动的方向上看：一般为输入流（InputStream）和输出流（OutputStream）两类。从读取类型上看，一般分为字节流和字符流。字节流是由InputStream和OutputStream派生出来的一系列类，以字节为处理单位；字符流是由Reader和Writer派生出来的一系列类，以16位Unicode码表示的字符为处理单位。
2. 字节流InputStream和OutputStream的子类分别有哪些?请举例说明其使用场景。与其对应的字符流分别有哪些?
- 字节流InputStream：
java.io.InputStream
java.io.FileInputStream //文件输入流，对应 java.io.InputstreamReader
java.io.PipedInputStream //管道输入流，对应 java.io.Pipedreader
java.io.ObjectInputStream // 对象输入流，用于序列化问题
java.io.ByteArrayInputStream // 字节输入流，对应java.io.CharArrayReader
java.io.SequenceInputStream // 序列输入流java.io.FilterInputStream // 过滤输入流包含一些其他输入流，它用作其基本数据源，可能沿途转换数据或提供其他功能。
java.io.DataInputStream
java.io.BufferedInputStream
java.io.PushbackInputStream
- 字节流OutputStream：
java.io.OutputStream
java.io.FileOutputStream // 文件输出流，对应 java.io.FileReader
java.io.PipedOutputStream // 管道输出流，对应 java.io.PipedReader
java.io.ObjectOutputStream //对象输出流
java.io.ByteArrayOutputStream //字节输出流，对应 java.io.CharReader
java.io.FilterOutputStream // 过滤输出流java.io.DataOutputStream
java.io.BufferedOutputStream
java.io.PrintStream
3. 字节流与字符流的转化是怎样的?Java对此提供了哪些支持?
输入的字节流有时需要转化为字符流，输出的字符流有时需要转化为字节流，转化过程也叫流的装配过程。转化的方法是：
(1) 输入字节流转为字符流需要用到InputStreamReader的构造方法：
InputStreamReader(InputStream in)
其使用方法为：
InputStreamReader ins = new InputStreamReader(new FileInputStream("c:\\text.txt") ) ;
之后通过ins的方法就可以从字符角度来读取文件text.txt。
(2) 输出字符流转为字节流要用到OutputStreamWriter或PrintWriter的构造方法：
OutputStreamWriter(OutputStream out)PrintWriter(OutputStream out);
其使用方法为：
OutputStreamWriter outs = new OutputStreamWriter(new FileOutputStream("c:\\text.txt") );
之后通过outs就可以直接输出字符到text.txt文件中。
这种转化过程并没有改变流的内容，只是改变了“看”流的角度。例如上面输人流还以再进行装配。查阅JDK帮助文档，可发现缓冲输人字符流的构造方法如下：BufferedReader(Reader in)
其参数说明只要是Reader的子类都可以作为BufferedReader的参数， 因此可写成：
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("c:\\text.txt") ) );
虽然流中的内容是一样的， 但是br和ins的角度不同， ins是一个一个字符地读， 而br就以一行一行地读。
4. Java中的过滤流(流的装配)有什么作用?请举例说明常用的过滤流。
抽象的InputStream和OutputStream类允许我们对字串及数字进行读写。为达到这个目的，还需要功能更多的子类。例如：DateInputStream和DataOutputStream允许我们对所有基本的java类型进行读写。文件流类与抽象的InputStream和OutputStream类相似，这些类也只支持字节级的读写操作。换言之，只能从fin对象中读取字符和字节数组。byte b=fin.read()，他们没有提供专门的数值类型，所以DataInputStream没有办法从一个文件中获取数字。
解决方案：java给流职责分工，某些流（FileInputStream）负责从文件或另一些更特殊的地方读入字节数据。而另一些流（DataInputStream、PrintWriter）负责将字节“组装”成更有用的数据类型。必须综合运用这两种流，将其合并成所谓的"过滤流（FilteredStreams）"，方法是将一个现成的流传递给另一个流的构建器。
解决方案举例：从一个文件中读取数字
-
步骤：
1）创建一个FileInputStream；
2）将其传递给一个DataInputStream的构造函数； -
代码：
1）FileInputStream fin=new FileInputStream("a.txt");
2）DataInputStream din=new DataInputStream(fin); double s=din.readDouble(); -
演示程序：
---------------------------------* 从一个文件中读取数字 *-------------------------------------
import java.io.*;
import java.lang.*;
public class B
{
public static void main(String args[])
{
try
{
FileOutputStream fin1=new FileOutputStream("a.txt");
DataOutputStream din1=new DataOutputStream(fin1);
din1.writeDouble(102);
FileInputStream fin2=new FileInputStream("a.txt");
DataInputStream din2=new DataInputStream(fin2);
Double d= new Double(din2.readDouble());
System.out.println("read message is : "+d.toString());
din2.close();
fin2.close();
din1.close();
fin1.close();
}
catch(Exception e)
{}
}
}
- 补充知识：
默认情况下，流不会进行缓冲。即每读一次，都会要求操作系统提供一个字节。通过BufferedInputStream和
BufferedOutputStream对流构建器进行过滤分层，实现缓冲。
- 构造函数：
BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in, int size) //size：缓冲区的大小
- 代码演示：
BufferedInputStream bis=new BufferedInputStream(System.in);
BufferedInputStream bis=new BufferedInputStream(System.in ,100);
- 程序举例：
//-----------*对a.txt文件进行缓冲以及数据输入操作*---------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class BB
{
public static void main(String args[])
{
try
{
DataInputStream dis=new DataInputStream(new BufferedInputStream(new FileInputStream("a.txt")));
byte[] c=new byte[10];
while(dis.read(c)!=-1)
{
for(int i=0;i<10;i++)
System.out.println("the message is "+String.valueOf(c[i]));}
}catch(Exception e){}
}
}
5. 什么是对象的序列化和反序列化?Java对此提供了哪些支持?
- 定义：
把对象转换为字节序列的过程称为对象的序列化。
把字节序列恢复为对象的过程称为对象的反序列化。
序列化的过程是在服务端做的；反序列化是在客户端做的。 - 对象的序列化主要有两种用途：
- 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
- 在网络上传送对象的字节序列。
- 在Java中，我们可以通过多种方式来创建对象，并且只要对象没有被回收我们都可以复用此对象。但是，我们创建出来的这些对象都存在于JVM中的堆（heap）内存中，只有JVM处于运行状态的时候，这些对象才可能存在。一旦JVM停止，这些对象也就随之消失。但是在真实的应用场景中，我们需要将这些对象持久化下来，并且在需要的时候将对象重新读取出来，Java的序列化可以帮助我们实现该功能。对象序列化机制（object serialization）是java语言内建的一种对象持久化方式，通过对象序列化，可以将对象的状态信息保存未字节数组，并且可以在有需要的时候将这个字节数组通过反序列化的方式转换成对象，对象的序列化可以很容易的在JVM中的活动对象和字节数组（流）之间进行转换。
6. Java的File类表示什么?有什么作用?
Java文件类以抽象的方式代表文件名和目录路径名。该类主要用于文件和目录的创建、文件的查找和文件的删除等。File对象代表磁盘中实际存在的文件和目录。
public class DirList {
public static void main(String args[]) {
String dirname = "/java";
File f1 = new File(dirname);
if (f1.isDirectory()) {
System.out.println("Directory of " + dirname);
String s[] = f1.list();
for (int i = 0; i < s.length; i++) {
File f = new File(dirname + "/" + s[i]);
if (f.isDirectory()) {
System.out.println(s[i] + " is a directory");
} else {
System.out.println(s[i] + " is a file");
}
}
} else {
System.out.println(dirname + " is not a directory");
}
}
}
7. Java对文件的读写分别提供了哪些支持?
以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。以字符为单位读取文件，常用于读文本，数字等类型的文件。
//------------------参考资料---------------------------------
//
//1、按字节读取文件内容
//2、按字符读取文件内容
//3、按行读取文件内容
//4、随机读取文件内容
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader;
public class ReadFromFile {
/**
* 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
*
* fileName
* 文件的名
*/
public static void readFileByBytes(String fileName) {
File file = new File(fileName);
InputStream in = null;
try {
System.out.println("以字节为单位读取文件内容，一次读一个字节：");
// 一次读一个字节
in = new FileInputStream(file);
int tempbyte;
while ((tempbyte = in.read()) != -1) {
System.out.write(tempbyte);
}
in.close();
} catch (IOException e) {
e.printStackTrace();
return;
}
try {
System.out.println("以字节为单位读取文件内容，一次读多个字节：");
// 一次读多个字节
byte[] tempbytes = new byte[100];
int byteread = 0;
in = new FileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
// 读入多个字节到字节数组中，byteread为一次读入的字节数
while ((byteread = in.read(tempbytes)) != -1) {
System.out.write(tempbytes, 0, byteread);
}
} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e1) {
}
}
}
}
/**
* 以字符为单位读取文件，常用于读文本，数字等类型的文件
*
* fileName
* 文件名
*/
public static void readFileByChars(String fileName) {
File file = new File(fileName);
Reader reader = null;
try {
System.out.println("以字符为单位读取文件内容，一次读一个字节：");
// 一次读一个字符
reader = new InputStreamReader(new FileInputStream(file));
int tempchar;
while ((tempchar = reader.read()) != -1) {
// 对于windows下，rn这两个字符在一起时，表示一个换行。
// 但如果这两个字符分开显示时，会换两次行。
// 因此，屏蔽掉r，或者屏蔽n。否则，将会多出很多空行。
if (((char) tempchar) != 'r') {
System.out.print((char) tempchar);
}
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
try {
System.out.println("以字符为单位读取文件内容，一次读多个字节：");
// 一次读多个字符
char[] tempchars = new char[30];
int charread = 0;
reader = new InputStreamReader(new FileInputStream(fileName));
// 读入多个字符到字符数组中，charread为一次读取字符数
while ((charread = reader.read(tempchars)) != -1) {
// 同样屏蔽掉r不显示
if ((charread == tempchars.length)
&& (tempchars[tempchars.length - 1] != 'r')) {
System.out.print(tempchars);
} else {
for (int i = 0; i < charread; i++) {
if (tempchars[i] == 'r') {
continue;
} else {
System.out.print(tempchars[i]);
}
}
}
}
} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 以行为单位读取文件，常用于读面向行的格式化文件
*
* fileName
* 文件名
*/
public static void readFileByLines(String fileName) {
File file = new File(fileName);
BufferedReader reader = null;
try {
System.out.println("以行为单位读取文件内容，一次读一整行：");
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int line = 1;
// 一次读入一行，直到读入null为文件结束
while ((tempString = reader.readLine()) != null) {
// 显示行号
System.out.println("line " + line + ": " + tempString);
line++;
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 随机读取文件内容
*
* fileName
* 文件名
*/
public static void readFileByRandomAccess(String fileName) {
RandomAccessFile randomFile = null;
try {
System.out.println("随机读取一段文件内容：");
// 打开一个随机访问文件流，按只读方式
randomFile = new RandomAccessFile(fileName, "r");
// 文件长度，字节数
long fileLength = randomFile.length();
// 读文件的起始位置
int beginIndex = (fileLength > 4) ? 4 : 0;
// 将读文件的开始位置移到beginIndex位置。
randomFile.seek(beginIndex);
byte[] bytes = new byte[10];
int byteread = 0;
// 一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
// 将一次读取的字节数赋给byteread
while ((byteread = randomFile.read(bytes)) != -1) {
System.out.write(bytes, 0, byteread);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (randomFile != null) {
try {
randomFile.close();
} catch (IOException e1) {
}
}
}
}
/**
* 显示输入流中还剩的字节数
*/
private static void showAvailableBytes(InputStream in) {
try {
System.out.println("当前字节输入流中的字节数为:" + in.available());
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String fileName = "C:/temp/newTemp.txt";
ReadFromFile.readFileByBytes(fileName);
ReadFromFile.readFileByChars(fileName);
ReadFromFile.readFileByLines(fileName);
ReadFromFile.readFileByRandomAccess(fileName);
}
}
使用字符流缓冲区拷贝文本文件可以提高效率，Reader有一个子类BufferedReader， 子类继承父类显然子类可以重写父类的方法可以增加自己的新方法。例如一次读一行就是常用的操作.那么BufferedReader类就提供了这个方法,可以查看readLine()方法具备 一次读取一个文本行的功能。很显然,该子类可以对功能进行增强。
private static void copyFile(File srcFile, File destFile)throws IOException {
// 创建字符输入流
FileReader fr = new FileReader(srcFile);
// 创建字符输出流
FileWriter fw = new FileWriter(destFile);
// 字符输入流的缓冲流
BufferedReader br = new BufferedReader(fr);
// 字符输出流的缓冲流
BufferedWriter bw = new BufferedWriter(fw);
String line = null;
// 一次读取一行
while ((line = br.readLine()) != null) {
// 一次写出一行.
bw.write(line);
// 刷新缓冲
bw.flush();
// 进行换行,由于readLine方法默认没有换行.需要手动换行
bw.newLine();
}
// 关闭流
br.close();
bw.close();
}
