【Java使用手册】-06 I/O from the Command Line（已完成）

I/O from the Command Line

A program is often run from the command line and interacts with the user in the command line environment. The Java platform supports this kind of interaction in two ways: through the Standard Streams and through the Console.

译:从命令行中进行IO操作

程序经常从命令行运行，并且在命令行环境中与用户交互。 Java 平台以两种方式支持这种交互:通过标准流控制和通过控制台.

Standard Streams

Standard Streams are a feature of many operating systems. By default, they read input from the keyboard and write output to the display. They also support I/O on files and between programs, but that feature is controlled by the command line interpreter, not the program.

The Java platform supports three Standard Streams: Standard Input, accessed through System.in; Standard Output, accessed through System.out; and Standard Error, accessed through System.err. These objects are defined automatically and do not need to be opened. Standard Output and Standard Error are both for output; having error output separately allows the user to divert regular output to a file and still be able to read error messages. For more information, refer to the documentation for your command line interpreter.

You might expect the Standard Streams to be character streams, but, for historical reasons, they are byte streams. System.out and System.err are defined as PrintStream objects. Although it is technically a byte stream, PrintStream utilizes an internal character stream object to emulate many of the features of character streams.

By contrast, System.in is a byte stream with no character stream features. To use Standard Input as a character stream, wrap System.in in InputStreamReader.

译:标准流

标准流是很多操作系统的特性。默认情况下，他们从键盘读取输入并将输出写入显示器。他们还支持程序和文件之间的IO，但那特性是通过命令行解释器进行控制，而不是程序。

Java 平台支持三种标准流：标准输入，通过 System.in 访问；标准输出，通过 System.out 访问；和标准错误，通过 System.err 访问。这些对象是自动定义的，不需要打开。标准输出和标准错误都是为了输出；有错误的输出分别允许用户将常规输出转向到文件，并且仍然可以读取错误消息。有关更多信息，请参考命令行解释器的文档。

你可能期望标准流是字符流，但是，因为历史原因，他们是字节流。 System.out 和 System.err 被定义为 PrintStream 对象。尽管从技术上讲它是一个字节流， PrintStream 利用一个内部字符流对象来模拟字符流的许多特性。

相比之下，System.in 是没有字符流特性的字节流。要使用标准输入作为字符流，把 System.in 包装在在InputStreamReader中进行包装。

InputStreamReader cin = new InputStreamReader(System.in);

The Console

A more advanced alternative to the Standard Streams is the Console. This is a single, predefined object of type Console that has most of the features provided by the Standard Streams, and others besides. The Console is particularly useful for secure password entry. The Console object also provides input and output streams that are true character streams, through its reader and writer methods.

Before a program can use the Console, it must attempt to retrieve the Console object by invoking System.console(). If the Console object is available, this method returns it. If System.console returns NULL, then Console operations are not permitted, either because the OS doesn't support them or because the program was launched in a noninteractive environment.

The Console object supports secure password entry through its readPassword method. This method helps secure password entry in two ways. First, it suppresses echoing, so the password is not visible on the user's screen. Second, readPassword returns a character array, not a String, so the password can be overwritten, removing it from memory as soon as it is no longer needed.

The Password example is a prototype program for changing a user's password. It demonstrates several Console methods.

译：控制台

标准流的一个更高级的替代方案是控制台。这是一个单一的、预定义的 Console 类型对象，它拥有标准流的大多数特性以及其他特性。控制台对于安全的密码输入非常有用。Console 对象还通过 reader 和 writer 方法提供了真正的字符流的输入输出流。

在程序可以使用控制台之前，必须尝试通过调用 System.console() 来检索 Console 对象。如果 Console 对象事可用的，则方法会返回它。如果 System.console 返回 NULL ，则 Console 操作是不允许的。要么因为操作系统不支持它们，要么因为程序是在非交互环境中启动的。

控制台对象通过它的 readPassword 方法支持安全的密码输入。这种方法通过两种方式帮助密码输入的安全性。首先，它抑制了回显，所以密码在用户屏幕上不可见。其次，readPassword 返回一个字符数组，而不是字符串，所以密码可以被覆写，一旦不再需要，就将其从内存中删除。

下面的 Password 实例是一个修改用户密码的原型程序。它演示了几个“控制台”方法

import java.io.Console;
import java.util.Arrays;
import java.io.IOException;

public class Password {

public static void main (String args[]) throws IOException {

Console c = System.console();
if (c == null) {
   System.err.println("No console.");
   System.exit(1);
}

String login = c.readLine("Enter your login: ");
char [] oldPassword = c.readPassword("Enter your old password: ");

if (verify(login, oldPassword)) {
   boolean noMatch;
   do {
       char [] newPassword1 = c.readPassword("Enter your new password: ");
       char [] newPassword2 = c.readPassword("Enter new password again: ");
       noMatch = ! Arrays.equals(newPassword1, newPassword2);
       if (noMatch) {
           c.format("Passwords don't match. Try again.%n");
       } else {
           change(login, newPassword1);
           c.format("Password for %s changed.%n", login);
       }
       Arrays.fill(newPassword1, ' ');
       Arrays.fill(newPassword2, ' ');
   } while (noMatch);
}

Arrays.fill(oldPassword, ' ');
}

// Dummy change method.
static boolean verify(String login, char[] password) {
// This method always returns
// true in this example.
// Modify this method to verify
// password according to your rules.
return true;
}

// Dummy change method.
static void change(String login, char[] password) {
// Modify this method to change
// password according to your rules.
}
}

The Password class follows these steps:

1. Attempt to retrieve the Console object. If the object is not available, abort.
2. Invoke Console.readLine to prompt for and read the user's login name.
3. Invoke Console.readPassword to prompt for and read the user's existing password.
4. Invoke verify to confirm that the user is authorized to change the password. (In this example, verify is a dummy method that always returns true.)
5. Repeat the following steps until the user enters the same password twice:
   1. Invoke Console.readPassword twice to prompt for and read a new password.
   2. If the user entered the same password both times, invoke change to change it. (Again, change is a dummy method.)
   3. Overwrite both passwords with blanks.
6. Overwrite the old password with blanks.

译：

Password类遵循以下步骤：

1. 尝试检索Console对象，如果对象不可用，则终止。
2. 调用 Console.readLine ，提示并读取用户的登录名。
3. 调用 Console.readPassword ，提示并读取用户已存在的密码。
4. 调用 verify 来确认用户被授权修改密码。（在本例中， verify 是一个总是返回true 的虚拟方法）。
5. 重复下面的步骤，直到用户两次输入相同的密码：
   1. 调用 Console.readPassword 两次，提示并读取一个新密码。
   2. 如果用户两次都输入相同的密码，则调用 change 方法去修改它。（同样的， change 是一个虚拟方法）。
   3. 用空格覆盖两个新密码。
6. 用空格覆写旧密码