[参考了许多来自互联网的资料]
最近刚学习了JAVA里的输入输出流,经过我小小的探究了一下后,获得了一些很浅的理解,当然还有一些疑惑的地方,结合了网络上一些资料,现在写下来记录总结一下!(估计有很多理解偏差的地方…)
流 Java程序中,对于数据的输入/输出操作都是以“流”的方式进行 .流具有方向性,至于是输入流还是输出流则是一个相对的概念,一般以程序 为参考,如果数据的流向是程序至设备,我们成为输出流,反之我们称为输入流,可以将流想象成一个“管道”,自然就出现了方向的概念。
流把I/O设备内部的具体操作给隐藏起来了。所有InputStream和Reader的派生类都有一个基本的,继承下来的,能读取单个或byte数组的read( )方法。
Java分为字节流(Stream结尾)和字符流(Reader、Write结尾),
再分为输入流(InputStream、Reader)和输出流(OutputStream、Write),输入输出相对于内存而言。在读字符的时候用字符流,如文本文件、XML(我想xml明明是字母字符组成的,属于ASCII文件,为何不用stream读取呢?)等。在读二进制文件时候用字节流,如RAR、EXE等不是文本以外的文件(图片)。Buffered开头的流只是加了缓冲区,为了读写提高效率。
字符流不能直接输出,需要转换成字节流才能输出!
说明:
字节流用于读写诸如图像数据之类的原始字节流。
字符流用于读写诸如文件数据之类的字符流。
低级流能和外设交流。
高级流能提高效率。
InputStreamReader 是字节流通向字符流的桥梁。
OutputStreamWriter是字符流通向字节流的桥梁。
FilterInputStream
FilterInputStream 的作用是用来“封装其它的输入流,并为它们提供额外的功能”。它的常用的子类有BufferedInputStream和DataInputStream。
BufferedInputStream的作用就是为“输入流提供缓冲功能,以及mark()和reset()功能”。
DataInputStream 是用来装饰其它输入流,它“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”。应用程序可以使用DataOutputStream(数据输出流)写入由DataInputStream(数据输入流)读取的数据。
FilterInputStream 源码(基于jdk1.7.40):
package java.io;
public class FilterInputStream extends InputStream {
protected volatile InputStream in;
protected FilterInputStream(InputStream in) {
this.in = in;
}
public int read() throws IOException {
return in.read();
}
public int read(byte b[]) throws IOException {
return read(b, 0, b.length);
}
public int read(byte b[], int off, int len) throws IOException {
return in.read(b, off, len);
}
public long skip(long n) throws IOException {
return in.skip(n);
}
public int available() throws IOException {
return in.available();
}
public void close() throws IOException {
in.close();
}
public synchronized void mark(int readlimit) {
in.mark(readlimit);
}
public synchronized void reset() throws IOException {
in.reset();
}
public boolean markSupported() {
return in.markSupported();
}
}
FilterOutputStream
FilterOutputStream 的作用是用来“封装其它的输出流,并为它们提供额外的功能”。它主要包括BufferedOutputStream, DataOutputStream和PrintStream。
(01) BufferedOutputStream的作用就是为“输出流提供缓冲功能”。
(02) DataOutputStream 是用来装饰其它输出流,将DataOutputStream和DataInputStream输入流配合使用,“允许应用程序以与机器无关方式从底层输入流中读写基本 Java 数据类型”。
(03) PrintStream 是用来装饰其它输出流。它能为其他输出流添加了功能,使它们能够方便地打印各种数据值表示形式。
FilterOutputStream 源码(基于jdk1.7.40):
package java.io;
public class FilterOutputStream extends OutputStream {
protected OutputStream out;
public FilterOutputStream(OutputStream out) {
this.out = out;
}
public void write(int b) throws IOException {
out.write(b);
}
public void write(byte b[]) throws IOException {
write(b, 0, b.length);
}
public void write(byte b[], int off, int len) throws IOException {
if ((off | len | (b.length - (len + off)) | (off + len)) < 0)
throw new IndexOutOfBoundsException();
for (int i = 0 ; i < len ; i++) {
write(b[off + i]);
}
}
public void flush() throws IOException {
out.flush();
}
public void close() throws IOException {
try {
flush();
} catch (IOException ignored) {
}
out.close();
}
}
用法分析
Java IO的一般使用原则(部分来自百度文库):
(1) 按数据来源(去向)分类:
是文件: FileInputStream, FileOutputStream, FileReader, FileWriter
是byte[]:ByteArrayInputStream, ByteArrayOutputStream
是Char[]: CharArrayReader, CharArrayWriter
是String: StringBufferInputStream, StringReader, StringWriter
网络数据流:InputStream, OutputStream, Reader, Writer
(2) 按是否格式化输出分:
要格式化输出:PrintStream, PrintWriter
(3) 按是否要缓冲分:
要缓冲:BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter。
(4) 按数据格式分:
二进制格式(只要不能确定是纯文本的): InputStream, OutputStream及其所有带Stream结束的子类
纯文本格式(含纯英文与汉字或其他编码方式);Reader, Writer及其所有带Reader, Writer的子类
(5) 按输入输出分:
输入:Reader, InputStream类型的子类;输出:Writer, OutputStream类型的子类
(6) 特殊需要:
从Stream到Reader,Writer的转换类:InputStreamReader, OutputStreamWriter
对象输入输出:ObjectInputStream, ObjectOutputStream
进程间通信:PipeInputStream, PipeOutputStream, PipeReader, PipeWriter
合并输入:SequenceInputStream
更特殊的需要:PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader
(7) 决定使用哪个类以及它的构造进程的一般准则如下(不考虑特殊需要):
考虑最原始的数据格式是什么:是否为文本?是输入还是输出?是否需要转换流:InputStreamReader, OutputStreamWriter?数据来源(去向)是什么:文件?内存?网络?是否要缓冲:bufferedReader (特别注明:一定要注意的是readLine()是否有定义,有什么比read, write更特殊的输入或输出方法)是否要格式化输出:print。
下面是收集的一些具体的例子:
//system.in
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/*
* System.in是InputStream static final的,包含了多态,叫同步式或者阻塞式
* 读取ASCII和二进制文件(图片),而字母就是ASCII字符(个人理解)。
*/
public class TestSystemIn {
public static void main(String[] args) {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);//有readline
String s = null;
try {
s = br.readLine();
while(s!=null) {
if(s.equalsIgnoreCase("exit")) {
break;
}
System.out.println(s.toUpperCase());
s = br.readLine();
}
br.close();
}catch (IOException e) {
e.printStackTrace();
}
}
}
//FileOutputStream 复制
import java.io.*;
/*
* 实现复制功能
*/
public class TestFileOutputStream {
public static void main(String[] args) {
int b = 0;
FileInputStream in = null;
FileOutputStream out = null;
try {
in = new FileInputStream("d:/java.txt");
//下面的若是不存在的话会自动建立
out = new FileOutputStream("d:/my_java.txt");
while((b=in.read())!=-1) {
out.write(b);
}
in.close();
out.close();
}catch(FileNotFoundException e) {
System.out.println("找不到指定文件");
System.exit(-1);
}catch(IOException e1) {
System.out.println("文件复制错误");
System.exit(-1);
}
System.out.println("文件已复制");
}
}
//ObjectOutputStream与Serializable
import java.io.*;
/*
* transient(透明的),可以用来修饰成员变量,
* 当进行序列化时不予考虑,修饰int 的话,不管原来的值是多少
* 输出的就是0
*/
public class TestObjectIO {
public static void main(String[] args) throws Exception {
T t = new T();
t.k = 8;
FileOutputStream fos = new FileOutputStream("d:/1.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(t);
oos.flush();
oos.close();
FileInputStream fis = new FileInputStream("d:/1.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
T tRead = (T)ois.readObject();
System.out.println(tRead.i + " " + tRead.j + " " + tRead.k);
}
}
class T implements Serializable {
int i = 10;
int j = 9;
double d = 2.3;
int k = 15;
}
//DataStream
import java.io.*;
public class TestDataStream {
public static void main(String[] args) {
//先在内存里分配一个字节数组,再有一个 OutputStream,再加上一个数据流
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos);
try {//写出读入
dos.writeDouble(Math.random());
dos.writeBoolean(true);
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
System.out.println(bais.available());//共几个字节可用
DataInputStream dis = new DataInputStream(bais);
////先写的先读(队列),下面这两个输出不可以调换,否则就先输出了double里的一个字节
System.out.println(dis.readDouble());
System.out.println(dis.readBoolean());
dos.close();
dis.close();
}catch (IOException e) {
e.printStackTrace();
}
}
}
//printwrite
import java.io.*;
class IODemo
{
public static void main(String[] args)
{
try
{
FileReader fr=new FileReader("a.txt");
BufferedReader br=new BufferedReader(fr);
FileWriter fw=new FileWriter("33.txt");
PrintWriter pw=new PrintWriter(fw);
String s=br.readLine();
while(null!=s)
{
//PrintWriter的println方法 相当于
//BufferedWriter 的write() + newLine()
pw.println(s);
s=br.readLine();
}
br.close();
pw.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
问题
为什么Writer/Reader不继承自Stream呢?字符最终也要转换成二进制。Writer/Readre继承OutputStream/InputStream,这样的继承层次不是更好?,为什么要单独做一个.
查资料得出字符流是操作缓存的,而字节流不操作缓存,但是为什么有BufferedInputStream这样的缓存字节流?这不是也操作缓冲区了吗?