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");

    }

}

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

巴特西

ThinkJava-标准IO

最新文章

热门文章