第十四讲 Java中的字节流和过滤流
|
主要内容
InputStream和FileInputStream OutputStream和FileOutputStream 文件字节ＩＯ流应用举例 过滤流类和常用的过滤流（缓冲流、转换流、数据流、PrintStream） |
InputStream和FileInputStream
InputStream
抽象类，声明了输入流的最基本操作——读操作。
read方法
|
public int read() throws IOException |
|
从流中读一个字节，当流中没有数据可读时，返回值为－1 |
|
public int read(byte[] b) throws IOException |
|
从流中读适合数组b尺寸的字节，置于数组中 |
|
public void read(byte[] b,int off,int len) throws IOException |
|
读入len个字节，从下标off开始置入数组b |
available方法
public int available() throws IOException
返回流中的有效字节数。
skip方法
public long skip(long n) throws IOException
close方法
public abstract void close() throws IOException
System中的流
public static InputStream in
public static PrintStream out
public static PrintStream err
例程阅读：
import java.io.*;
public class Echo{
public static void startEcho(InputStream in) throws Exception{
int b;
while((b=in.read())!=-1){
System.out.print((char)b);
}
System.out.println();
}
public static void main(String[] aa) throws Exception{
startEcho(System.in);
}
}
说明：在Windows中，流的结束标志为Ctrl+Z。
练习1：在Echo中设计一个静态的readLine()方法，可通过System.in输入并返回一行字符。
练习2：
1) 在Echo中设计一个静态的readInt()方法，可通过System.in输入并返回一个整数。（如输入非数字，其后的字符一律忽略）
2) 进而设计一程序，利用readInt方法，读入五个整数，并累加。
FileInputStream概述
按字节对文件进行数据读操作。（适合于二进制文件）
可通过创建FileInputStream对象获得InputStream类型的实例。
构造方法
public FileInputStream(String filename)
public FileInputStream(File file)
|
throws FileNotFoundException
|
例：显示文本文件内容
import java.io.*;
public class FileEcho{
public static void main(String[] aa)throws Exception{
FileInputStream in=new FileInputStream("try.txt");
Echo.startEcho(in);
f.close();
}
}
|
思考 1. InputStream子类对象，表示的是怎样的一种数据流？ 2. 对于InputStream数据流，如何从中读取数据？ 3. 一次性可读取一组数据吗？ 4. 在数据流操作时，将会抛出什么异常？ 5. FileInputStream是一种怎样的数据流？ 6. 上例中用FileInputStream 建立输入流，逐字节的读写将引起汉字无法显示的问题，为什么？ 7. 如何解决汉显的问题？ |
OutputStream和FileOutputStream
OutputStream
抽象类，声明了输出流的最基本操作——写操作。
write方法
|
public void write(int i) throws IOException |
|
向流中写一个字节 |
|
public void write(byte[] b) throws IOException |
|
向流写数组b |
|
public void write(byte[] b,int off,int len) throws IOException |
|
向流写数组b中的len个元素：下标从off到off+len-1 |
flush方法
public abstract void flush() throws IOException
将缓冲区中数据立即写入到输出流。
close方法
public abstract void close() throws IOException
例：阅读分析程序
import java.io.*;
public class Copy{
public static void startCopy(InputStream in,
OutputStream out) throws IOException{
int b;
while((b=in.read())!=-1){
out.write((byte)b);
}
}
public static void main(String[] aa)throws IOException{
startCopy(System.in,System.out);
}
}
FileOutputStream
构造方法
public FileOutputStream(String filename)
public FileOutputStream(File file)
public FileOutputStream(String filename,boolean append)
public FileOutputStream(File file,boolean append)
|
throws FileNotFoundException |
练习：设计程序CreateFile.java，运行时可从键盘输入内容，尔后保存到文件中。（try.txt）
import java.io.*;
public class CreateFile{
public static void main(String[] aa)throws Exception{
}
}
文件字节ＩＯ流应用举例
1、设计程序CopyFile.java，可将try.txt复制生成trynew.txt。（试一下图像文件的复制。）
2、设计程序Combine.java，将CreateFile.java 和CopyFile.java两个文件合并成一个文件，命名为cc.txt。
3、设计程序CutFile.java将cc.txt按尺寸等分拆分成两个文件c1.txt和c2.txt。
问题：
1) 能否直接向FileOutputStream写入各种基本类型的数据、字符串？
2) 能否直接从FileInputStream中读出一行？
过滤流类和常用的过滤流
用流来处理的一般模式
流中的信息直接从一个端点传到另一个端点
流中的信息通过过滤器进行数据传输
过滤器也是流，是对流的封装，从流的上游将封装后的数据发送到流的下游。
多重过滤后，数据从一个端点流向另一个端点
过滤流：过滤流是建立在节点上的流，提供了很多增强功能。
过滤流提供了更多样化的数据读写处理。有两种类型的过滤流：
² 过滤输入流——FilterInputStream
² 过滤输出流——FilterOutputStream
|
思考 1. 过滤流能否直接由文件建立？ 2. 可直接由文件建立的流是什么流？ 3. 用过滤流来封装一个节点流的好处是？ 4. 什么叫多重过滤？ 5. 列出几种学过的直接由文件建立的流。 |
BufferedReader 和BufferedWriter
缓冲字符输入输出流，对已定义的字符流进行带缓冲的封装。
public BufferedReader(Reader in)
public BufferedReader(Reader in,int size)
public BufferedWriter(Writer out)
public BufferedWriter(Writer out,int size)：
说明：默认缓冲大小为默认值32bytes，size指定缓冲区尺寸。
BufferedReader新增读方法：
String readLine()
BufferedWriter新增写方法：
void newLine()
void write(String s, int off,int len)
InputStreamReader 和OutputStreamWriter
用于字节流和字符流之间的转换。
InputStreamReader：字节输入流è字符输入流
OutputStreamWriter：字节输出流è字符输出流
例：
import java.io.*;
class InputTest{
public static int getInt() throws IOException{
BufferedReader in = new BufferedReader(
new InputStreamReader(System.in));
String s=in.readLine();
return Integer.parseInt(s);
}
public static void main(String[] aa) throws IOException{
System.out.print("\nNumber 1: ");
int a=getInt();
System.out.print("\nNumber 2: ");
int b=getInt();
System.out.println("\nResult: "+a+" + "+ b+" = "+(a+b));
}
}
标准输出流PrintStream*
PrintStream是向标准输出设备的输出流，可直接输出各种类型的数据。
构造方法
public PrintStream(OutputStream out)：创建一无flush的标准输出流。
public PrintStream(OutputStream out,boolean autoFlush)：创建标准输出流。
如：FileOutputStream f=new FileOutputStream("try.txt");
PrintStream out=new PrintStream(f);
常用的输出方法
|
方法原型 |
说明 |
|
public void print(数据) |
数据可以是： ² 字符串 ² 各种基本类型 ² 字符数组名 |
|
public void println(数据) |
|
|
void write(int b) |
写入一指定字节b到流中 |
|
void write(byte b[],int off,int len) |
|
|
将数组b中的b[off],b[off+1],……,b[off+len-1]写入到流中 |
|
|
void write(byte b[]) |
写入一字节数组到流中，从FilterOutputStream继承 |
例：随机产生五个数，放到 random.txt文件中。
import java.io.*;
import java.util.*;
class RandomTest{
public static void main(String[] aa) throws Exception{
PrintStream out=
new PrintStream(new FileOutputStream("random.txt"));
Random r=new Random();
int a;
for(int i=0;i<10;i++){
a=r.nextInt(100);
out.print(a+"\t");
}
out.close();
}
}
练习：将菲波那契级数的前二十项存放在fei.txt文件中。
BufferedInputStream 和BufferedOutputStream*
缓冲字节输入输出流，对已定义的字节流进行带缓冲的封装。缓冲输入流的读写操作通过缓冲区进行。
public BufferedInputStream(InputStream in)：
public BufferedInputStream(InputStream in,int size)：
public BufferedOutputStream(OutputStream out)
public BufferedOutputStream(OutputStream out,int size)
DataInputStream和DataOutputStream*
数据过滤流，提供了读写Java中的基本数据类型的功能。
public DataInputStream(InputStream in)
public DataOutputStream(OutputStream in)
DataInputStream新增读方法
|
方法 |
说明 |
|
boolean readBoolean() |
读取布尔型数据 |
|
byte readByte() |
读取单字节数据 |
|
char readChar() |
读取字符数据 |
|
short readShort() |
读取short整型数据 |
|
int readInt() |
读取int整型数据 |
|
long readLong() |
读取long整型数据 |
|
float readFloat() |
读取浮点型数据 |
|
double readDouble() |
读取双精度型数据 |
|
string readString() |
读取字符串数据 |
当文件读到结尾时，EOFException例外将发生，据此判断数据是否读完。
如：
try{
while(true)
System.out.print(out.readChar());
}catch(EOFException e){}
DataOutputStream新增写方法
|
方法 |
说明 |
|
void writeBoolean(boolead b) |
写一个布尔型数据 |
|
void writeByte(byte b) |
写一个单字节数据 |
|
Void writeBytes(String s) |
写一个字节序列 |
|
void writeChar(int b) |
写一个字符数据 |
|
void writeChars(String b) |
写一个字符串数据 |
|
void writeShort(short b) |
写一个short整型数据 |
|
void writeInt(int b) |
写一个int整型数据 |
|
void writeLong(long b) |
写一个long整型数据 |
|
void writeFloat(float b) |
写一个浮点型数据 |
|
void writeDouble(double b) |
写一个双精度型数据 |
数据流练习
1、用数据输出流将菲波那契级数的前二十项存放在fei.dat文件中。
2、从fei.dat文件中读出数列，显示输出，并计算累加和。
import java.io.*;
class TestFei{
public static void main(String[] aa) throws IOException{
int sum=0;
System.out.println("\nsum:"+sum);
in.close();
}
}
附：阅读程序，理解byte数组在读写中的作用
import java.io.*;
class TestFileIO{
public static void main(String[] aa) throws Exception{
FileOutputStream out=new FileOutputStream("1.txt");
out.write("试一试\n".getBytes());
out.write("www.szit.edu.cn".getBytes());
out.close();
FileInputStream in=new FileInputStream("1.txt");
int l=in.available();
byte[] b=new byte[l];
in.read(b);
System.out.println(new String(b));
in.close();
}
}
