Java IO流大致总结

[参考了许多来自互联网的资料]
最近刚学习了JAVA里的输入输出流,经过我小小的探究了一下后,获得了一些很浅的理解,当然还有一些疑惑的地方,结合了网络上一些资料,现在写下来记录总结一下!(估计有很多理解偏差的地方…)

Java程序中,对于数据的输入/输出操作都是以“流”的方式进行 .流具有方向性,至于是输入流还是输出流则是一个相对的概念,一般以程序 为参考,如果数据的流向是程序至设备,我们成为输出流,反之我们称为输入流,可以将流想象成一个“管道”,自然就出现了方向的概念。
流把I/O设备内部的具体操作给隐藏起来了。所有InputStream和Reader的派生类都有一个基本的,继承下来的,能读取单个或byte数组的read( )方法。
Java分为字节流(Stream结尾)和字符流(Reader、Write结尾),
再分为输入流(InputStream、Reader)和输出流(OutputStream、Write),输入输出相对于内存而言。在读字符的时候用字符流,如文本文件、XML(我想xml明明是字母字符组成的,属于ASCII文件,为何不用stream读取呢?)等。在读二进制文件时候用字节流,如RAR、EXE等不是文本以外的文件(图片)。Buffered开头的流只是加了缓冲区,为了读写提高效率。

字符流不能直接输出,需要转换成字节流才能输出!

总结
说明:

  1. 字节流用于读写诸如图像数据之类的原始字节流。

  2. 字符流用于读写诸如文件数据之类的字符流。

  3. 低级流能和外设交流。

  4. 高级流能提高效率。

  5. InputStreamReader 是字节流通向字符流的桥梁。

  6. OutputStreamWriter是字符流通向字节流的桥梁。
    input
    output
    reader
    write
    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这样的缓存字节流?这不是也操作缓冲区了吗?

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值