ThinkJava-标准IO

1 从标准输入中读取　　　　　　　　　　　　　　

按照标准1/0模型， Java提供了System.in、System.out和System.err。在整本书里，我们已经

看到了怎样用System.out将数据写出到标准输出，其中System.out 已经事先被包装成了

printStream对象。System.err 同样也是PrintStream ，但System.in却是一个没有被包装过的未经

加工的InputStream。这意味尽管我们可以立即使用System.out和System.err ，但是在读取

System.in之前必须对其进行包装。

 

通常我们会用readLine一次一行地读取输入，为此，我们将System.in包装成BufferedReader

来使用这要求我们必须用InputStreamReader把System.in转换成Reader。下面这个例子

将直接回显你所输入的每一行。

package com.java.io;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Echo {
    public static void main(String[] args) throws IOException {
        BufferedReader stdin = new BufferedReader(
                                    new InputStreamReader(System.in));
        String s;
        while((s = stdin.readLine()) != null && s.length()!= 0){
            System.out.println(s);
        }
         
      }
}

使用异常规范是因为readLineO会抛出IOException。注意System.in和大多数流一样，通

常应该对它进行缓冲。

 

2 将System.out转换成PrintWriter

System.out 是一个PrintStream ，而PrintStream是一个OutputStream . PrintWriter有一个

可以接受OutputStream作为参数的构造器。因此，只要需要，就可以使用那个构造器把

System.out 转换成PrintWriter:

package com.java.io;

import java.io.PrintWriter;

public class ChangeSystemOut {
    public static void main(String[] args) {
        PrintWriter out = new PrintWriter(System.out,true);
        out.println("Hello, world");
    }
}

重要的是要使用有两个参数的PrintWriter的构造器，并将第二个参数设为true ，以便开启自

动清空功能；否则，你可能看不到输出。

 

 

3 标准1/0重定向

Java的System类提供了一些简单的静态方泣调用，以，允许我们对标准输入、输出和错误IO

流进行重定向：

setIn(InputStream)

setOut(PrintStream)

setErr(PrintStream)

package com.java.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;

public class Redirecting {
      public static void main(String[] args) throws IOException {
        PrintStream console = System.out;
        BufferedInputStream in = new BufferedInputStream(
                                        new FileInputStream("src/com/java/io/Redirecting.java"));
        PrintStream out = new PrintStream(
                              new BufferedOutputStream(
                                new FileOutputStream("test.out")));
        System.setIn(in);
        System.setOut(out);
        System.setErr(out);
        BufferedReader br = new BufferedReader(
          new InputStreamReader(System.in));
        String s;
        while((s = br.readLine()) != null){
            System.out.println(s);
        }
        out.close(); 
        System.setOut(console);
      }
}

这个程序将标准输入附接到文件上，并将标准输出和标准错误重定向到另一个文件。注意，

它在程序开头处存储了对最初的System.out对象的引用，并且在结尾处将系统输出恢复到了该对

象上。

1/0重定向操纵的是字节流， 而不是字符流，因此我们使用的是InputStream和OutputStream,而不是Reader和Writer。

 

 

进程控制　　

你经常会需要在Java内部执行其他操作系统的程序，并且要控制这些程序的输入和输出。Java类库提供了执行这些操作的类。

一项常见的任务是运行程序，并将产生的输出发送到控制台。本节包含了一个可以简化这项任务的实用工具。在使用这个实用工具时，可能会产生两种类型的错误:普通的导致异常的错误一-对这些错误我们只需重新抛出一个运行时异常，以及从进程自身的执行过程中产生的错误，我们希望用单独的异常来报告这些错误;

package com.java.util;

public class OSExecuteException extends RuntimeException {
    public OSExecuteException(String why){
        super(why);
    }
}

要想运行一个程序，你需要向OSExecute.commandO传递一个command字符串，它与你在控制台上运行该程序所键入的命令相同。这个命令被传递给java.lang.ProcessBuilder构造器(它要求这个命令作为一个String对象序列而被传递),然后所产生的ProcessBuilder对象被启动:

// Run an operating system command
// and send the output to the console.
package com.java.util;

import java.io.BufferedReader;
import java.io.InputStreamReader;

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()));
          // Report errors and return nonzero value
          // to calling process if there are problems:
          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);
        }
      }
}

为了捕获程序执行时产生的标准输出流，你需要调用getInputStream() ，这是因为

InputStream是我们可以从中读取信息的流。从程序中产生的结果每次输出一行， 因此要使用

readLine()来读取。这里这些行只是直接被打印了出来，但是你还可能希望从command()中捕获

和返回它们。该程序的错误被发送到了标准错误流，并且通过调用getErrotStream()得以捕获。

如果存在任何错误，它们都会被打印并且会抛出OSExecuteException ，因此调用程序需要处理

这个问题。

 

下面是展示如何使用OSExecute的示例:

package com.java.io;

import com.java.util.OSExecute;

public class OSExecuteDemo {
    public static void main(String[] args) throws Exception{
        //这里使用了javap反编译器(随JDK发布)来反编译该程序.
        OSExecute.command("javap OSExecuteDemo");
    }
}

 

------------------