Java I/O系统

编程语言的[b]I/O类库[/b]，常使用流这个抽象概念，它代表任何有能力产出数据的数据源对象，或者有能力接收数据的接收端对象。

[b]InputStream[/b]的作用是用来表示那些从不同数据源产生输入的类，这些数据源包括
1 字节数组 ByteArrayInputStream 将内存的缓冲去当作InputStream使用
2 String对象 StringBufferInputStream (已弃用)
3 文件 FileInputStream
4 管道 PipedInputStream
5 一个有其他种类的流组成的序列，以便我们可以将它们收集合并到一个流内 SequenceInputStream
6 其他数据源，网络连接
7 FilterInputStream 所有“装饰器”类的基类

[b]OutputStream[/b]决定了输出所要去往的目标：
1 字节数组（但不是String，不过可以根据字节数组创建String） ByteArrayOutputStream
2 文件 FileOutputStream
3 管道 PipedOutputStream
4 FilterOutputStream


[b]FilterInputStream[/b]类型
1 DataInputStream 可以从流读取基本数据类型(int char long等)
2 BufferedInputStream 使用缓冲区
3 LineNumberInputStream 跟踪输入流的行号 (已弃用)
4 PushbackInputStream

[b]FilterOutputStream[/b]类型
1 DataOutputStream
2 PringStream 用于产生格式化输出，不要用于网络编程，因为格式化与本地系统类型有关
3 BufferedOutputStream

Stream是面向字节形式的I/O (8位字节流)，Reader和Writer是面向字符、提供兼容Unicode的I/O (16位的Unicode字符)，我们应该优先尝试使用Reader和Writer，在不得不使用时，才想到面向字节的类库。(比如java.util.zip)。为了实现字节和字符的转换，要用到“适配器”类InputStreamReader 和 OutputStreamWriter


[img]http://dl.iteye.com/upload/attachment/271094/ca6a88c4-bf63-351d-8106-ee2c792f9b0a.png[/img]

[img]http://dl.iteye.com/upload/attachment/271096/040766e6-3014-3370-8298-c5df01c1b033.png[/img]


从文件数据源缓冲输入

public class BufferedInputFile {
  public static String read(String filename) throws IOException {
    BufferedReader in = new BufferedReader(new FileReader(filename));
    String s;
    StringBuilder sb = new StringBuilder();
    while ((s = in.readLine()) != null)
      sb.append(s + "\n");
    in.close();
    return sb.toString();
  }
}

从内存输入

public class MemoryInput {
  public static void main(String[] args) throws IOException {
    StringReader in = new StringReader("this is a StringReader");
    int temp;
    while ((temp = in.read()) != -1)
      System.out.print((char) temp);
    in.close();
  }
}

格式化内存输入

public class FormattedMemoryInput {
  public static void main(String[] args) throws IOException {
    DataInputStream in = new DataInputStream(
        new ByteArrayInputStream("this is a ByteArrayInputStream".getBytes()));
    // 读到任何字节的值都是合法的，不能通过返回值来检测输入是否结束
    // avaliable()方法查看还有多少可供存取的字符
    while (in.available() != 0)
      System.out.print((char) in.readByte());
  }
}

基本文件输出

public class BasicFileOutput {
  public static void main(String[] args) throws IOException {
    BufferedReader in = new BufferedReader(new FileReader("temp"));
    PrintWriter out = new PrintWriter("temp2");
    String s;
    int lineNum = 0;
    while ((s = in.readLine()) != null)
      out.println("line " + lineNum++ + " is " + s);
    out.flush();
  }
}

[b]存储和和恢复数据[/b]
为了输出可供另一个“流”恢复的数据，我们需要用DataOutputStream，并用DataInputStream恢复数据。
随机访问文件RandomAccessFile和DataOutputStream、DataInputStream同样实现了DataOutput、DataInput接口，使用同样的方式操作

public class StroingAndRecoveringDate {
  public static void main(String[] args) throws IOException {
    DataOutputStream out = new DataOutputStream(
        new BufferedOutputStream(new FileOutputStream("data")));
    out.writeUTF("pi is: ");
    out.writeDouble(3.1415926);
    out.flush();
    DataInputStream in = new DataInputStream(
        new BufferedInputStream(new FileInputStream("data")));
    System.out.println(in.readUTF());
    System.out.println(in.readDouble());
  }
}

[b]标准I/O[/b]
程序的所有输入可以来自于标准输入，所有输出都可以发送到标准输出，所有错误信息都可以发送到标准错误。标准I/O的意义在于：我们可以把程序串联起来。
System.in是未包装的InputStream，System.out、System.err是PrintoStream。
[b]标准I/O重定向[/b]
如果突然在显示器上有大量输出，输出滚动太快而无法阅读，重定向输出就显得极为有用。为了向重复测试某个用户的输入命令行程序，重定向输入就很有价值。
I/O重定向操纵的是字节流，不是字符流！

public class Redirecting {
  public static void main(String[] args) throws IOException {
    PrintStream consoleOut = System.out;
    InputStream consoleIn = System.in;
    BufferedInputStream in = 
      new BufferedInputStream(new FileInputStream("temp"));
    PrintStream out = 
      new PrintStream(new BufferedOutputStream(new FileOutputStream("temp2")));
    // 标准输入改为文件temp，不是console
    System.setIn(in);
    // 标准输出已经改到文件temp2上
    System.setOut(out);
    BufferedReader br = new BufferedReader(new InputStreamReader(in));
    String s;
    while ((s = br.readLine()) != null) {
      System.out.println(s);
      // 标准错误仍然输出到控制台
      System.err.println(s);
    }
    out.close();
    // 恢复
    System.setOut(consoleOut);
    System.setIn(consoleIn);
  }
}

可能你会需要Java内部执行其他操作系统的程序，并且要控制这些程序的输入和输出。

public class OSExecute {
  public static void command(String command) {
    boolean err = false;
    try {
      Process process =
        new ProcessBuilder(command.split(" ")).start();
      BufferedReader results = new BufferedReader(
        new InputStreamReader(process.getInputStream()));
      String s;
      while((s = results.readLine())!= null)
        System.out.println(s);
      BufferedReader errors = new BufferedReader(
        new InputStreamReader(process.getErrorStream()));

      while((s = errors.readLine())!= null) {
        System.err.println(s);
        err = true;
      }
    } catch(Exception e) {
      // Compensate for Windows 2000, which throws an
      // exception for the default command line:
      if(!command.startsWith("CMD /C"))
        command("CMD /C " + command);
      else
        throw new RuntimeException(e);
    }
    if(err)
      throw new OSExecuteException("Errors executing " + command);
  }
  public static void main(String[] args) {
    new OSExecute().command("explorer d:\\新建文本文档.txt")
  }
}