X-Spirit: Core Java学习笔记

3.7 Input and Output 输入与输出

Tue, 18 Sep 2007 11:35:10 GMT

To make our example programs more interesting, we want to accept input and properly format the program output. Of course, modern programs use a GUI for collecting user input. However, programming such an interface requires more tools and techniques than we have at our disposal at this time. Because the first order of business is to become more familiar with the Java programming language, we make do with the humble console for input and output for now. GUI programming is covered in Chapters 7 through 9.

要是我们的程序更有意思，我们需要在程序中接收输入，并适当的格式化输出。当然，先进的程序采用GUI（图形用户界面）来收集用户输入。但是编写这样一个界面需要更多的工具和技术，这已经超出了我们现在的目标。因为我们当前的目标是更熟悉Java编程语言，我们还是采用粗陋的控制台作为输入输出。GUI编程将在7~9章介绍。

Reading Input 读取输入

You saw that it is easy to print output to the "standard output stream" (that is, the console window) just by calling System.out.println. Oddly enough, before JDK 5.0, there was no convenient way to read input from the console window. Fortunately, that situation has finally been rectified.

你可以看到，向标准输出流（也就是控制台窗口）输出内容非常简单，只需要调用System.out.println即可。非常奇怪的是，JDK5.0以前，还没有什么便捷的办法可以从控制台窗口读取输入。幸运的是，这种情况最终得以矫正。

To read console input, you first construct a Scanner that is attached to the "standard input stream" System.in.

要读取控制台输入，你首先构造一个附属于标准输入流System.in的Scanner。

Scanner in = new Scanner(System.in);

Now you use the various methods of the Scanner class to read input. For example, the nextLine method reads a line of input.

现在你可以使用Scanner类的各种方法来读取输入。例如，nextLine方法可以读取一行输入。

System.out.print("What is your name? ");

String name = in.nextLine();

Here, we use the nextLine method because the input might contain spaces. To read a single word (delimited by whitespace), call

这里，我们使用nextLine方法因为输入可能包含空格。要读取单个单词（以空格分隔），调用：

String firstName = in.next();

To read an integer, use the nextInt method.

要读取一个整数，使用nextInt方法。

System.out.print("How old are you? ");

int age = in.nextInt();

Similarly, the nextdouble method reads the next floating-point number.

类似的，nextdouble方法读取下一个浮点数字。

The program in Example 3-2 asks for the user's name and age and then prints a message like

Hello, Cay. Next year, you'll be 46

Finally, add the line

import java.util.*;

at the beginning of the program. The Scanner class is defined in the java.util package. Whenever you use a class that is not defined in the basic java.lang package, you need to use an import directive. We look at packages and import directives in more detail in Chapter 4.

例3-2要求用户输入姓名和年龄，并输出消息”Hello, cay. Next year, you’ll be 46”

最后在程序的开头加上import java.util.*;

Scanner类是定义在java.util包里的。只要你使用了一个没有定义在基本的java.lang包中的类，你都需要一个import 命令。我们将在第四章中更详细的讨论包和import。

Example 3-2. InputTest.java

1. import java.util.*;

3. public class InputTest

4. {

5. public static void main(String[] args)

6. {

7. Scanner in = new Scanner(System.in);

9. // get first input

10. System.out.print("What is your name? ");

11. String name = in.nextLine();

12.

13. // get second input

14. System.out.print("How old are you? ");

15. int age = in.nextInt();

16.

17. // display output on console

18. System.out.println("Hello, " + name + ". Next year, you'll be " + (age + 1));

19. }

20. }

NOTE

If you do not have JDK 5.0 or above, you have to work harder to read user input. The simplest method is to use an input dialog (see Figure 3-6).

如果你没有JDK 5.0或以上版本，你必须在读取用户输入上多费些力气。最简单的方法就是使用一个输入框（见图3-6）

String input = JOptionPane.showInputDialog(promptString)

Figure 3-6. An input dialog

The return value is the string that the user typed.

返回值就是用户输入的字符串。

For example, here is how you can query the name of the user of your program:

例如，下面的代码展示了我们如何在程序中要求输入用户的名字。

String name = JOptionPane.showInputDialog("What is your name?");

Reading numbers requires an additional step. The JOptionPane.showInputDialog method returns a string, not a number. You use the Integer.parseInt or Double.parseDouble method to convert the string to its numeric value. For example,

读取数字型输入需要再多一步。JOptionPane.showInputDialog方法返回一个字符串，而不是一个数字。你需要使用Integer.parseInt或者Double.parseDouble方法来将其数字值转换为字符串。例如

String input = JOptionPane.showInputDialog("How old are you?"); int age = Integer.parseInt(input);

If the user types 45, then the string variable input is set to the string "45". The Integer.parseInt method converts the string to its numeric value, the number 45.

如果用户输入45，则字符串变量被赋值为”45”。Integer.parseInt方法将字符串转换为相应的数字值，也就是数字45。

The JOptionPane class is defined in the javax.swing package, so you need to add the statement

JOptionPane类是定义在javax.swing包中，所以你需要添加语句

import javax.swing.*;

Finally, whenever your program calls JOptionPane.showInputDialog, you need to end it with a call to System.exit(0). The reason is a bit technical. Showing a dialog box starts a new thread of control. When the main method exits, the new thread does not automatically terminate. To end all threads, you call the System.exit method. (For more information on threads, see Chapter 1 of Volume 2.) The following program is the equivalent to Example 3-2 prior to JDK 5.0.

最后，无论何时程序调用JOptionPane.showInputDialog，你需要采用System.exit(0)来结束之。这是一个有点技术性的原因。显示一个对话框需要启动一个新的控制线程。当main方法退出时，新启动的线程并没有终结。要结束所有线程，你需要调用System.exit方法（想进一步了解线程，参见卷2第一章）下面的程序等同于JDK5.0以前的例3-2

import javax.swing.*;

public class InputTest

{

public static void main(String[] args)

{

String name = JOptionPane.showInputDialog("What is your name?");

String input = JOptionPane.showInputDialog("How old are you?");

int age = Integer.parseInt(input);

System.out.println("Hello, " + name + ". Next year, you'll be " + (age + 1));

System.exit(0);

}

java.util.Scanner 5.0

Scanner(InputStream in)

constructs a Scanner object from the given input stream.

String nextLine()

reads the next line of input.

String next()

reads the next word of input (delimited by whitespace).

int nextInt()
double nextDouble()

read and convert the next character sequence that represents an integer or floating-point number.

boolean hasNext()

tests whether there is another word in the input.检测后面是否还有一个单词

boolean hasNextInt()
boolean hasNextDouble()

test whether the next character sequence represents an integer or floating-point number.检测下一个字符序列是否代表一个整数或一个浮点数。

javax.swing.JOptionPane 1.2

static String showInputDialog(Object message)

displays a dialog box with a message prompt, an input field, and "OK" and "Cancel" buttons. The method returns the string that the user typed.
显示一个带有消息提示的对话框，一个输入框，还有”OK”和”Cancel”按钮。该方法返回用户键入的字符串。

java.lang.System 1.0

static void exit(int status)

terminates the virtual machine and passes the status code to the operating system. By convention, a non-zero status code indicates an error.
终止虚拟机并向操作系统传递状态码。约定非零状态码表示一种错误。

Formatting Output 格式化输出

You can print a number x to the console with the statement System.out.print(x). That command will print x with the maximum number of non-zero digits for that type. For example,

你可以用System.out.print(x)语句将一个数字x输出到控制台。这个命令将以该类型最大非零位数打印x。例如：

double x = 10000.0 / 3.0;

System.out.print(x);

prints打印出

3333.3333333333335

That is a problem if you want to display, for example, dollars and cents.但是当你想显示美元和美分的时候这就成了问题。

Before JDK 5.0, formatting numbers was a bit of a hassle. Fortunately, JDK 5.0 brought back the venerable printf method from the C library. For example, the call

JDK5.0前，对数字的格式化产生了争论。幸运的是，JDK5.0将古老的printf方法从C库中带回来了。例如：

System.out.printf("%8.2f", x);

prints x with a field width of 8 characters and a precision of 2 characters. That is, the printout contains a leading space and the seven characters

以8个字符的字段宽度和2个字符的精度打印出x。也就是说，输出包含前导空白和七个字符

3333.33

You can supply multiple parameters to printf, for example:你可以在printf中使用多个参数。

System.out.printf("Hello, %s. Next year, you'll be %d", name, age);

Each of the format specifiers that start with a % character is replaced with the corresponding argument. The conversion character that ends a format specifier indicates the type of the value to be formatted: f is a floating-point number, s a string, and d a decimal integer. Table 3-5 shows all conversion characters.

每个格式区分符以%开始，并被相应的变量取代。结束格式区分符的转换字符指明了要格式化的值的类型：f是指一个浮点数字，s是指一个字符串，d是指一个十进制整数。表3-5列出了所有的转换字符。

Table 3-5. Conversions for printf

Conversion Character

Type

Example

Decimal integer十进制整数

159

Hexadecimal integer 十六进制整数

Octal integer八进制整数

237

Fixed-point floating-point定点浮点数

15.9

Exponential floating-point指数型浮点数

1.59e+01

General floating-point (the shorter of e and f)

Hexadecimal floating point十六进制浮点

0x1.fccdp3

String

Hello

Character

Boolean

TRue

Hash code哈希码

42628b2

Date and time

See Table 3-7

The percent symbol百分号

The platform-dependent line separator换行符

Table 3-7. Date and Time Conversion Characters

Conversion Character

Type

Example

Complete date and time

Mon Feb 09 18:05:19 PST 2004

ISO 8601 date

2004-02-09

U.S. formatted date (month/day/year)

02/09/2004

24-hour time

18:05:19

12-hour time

06:05:19 pm

24-hour time, no seconds

18:05

Four-digit year (with leading zeroes)

2004

Last two digits of the year (with leading zeroes)

First two digits of the year (with leading zeroes)

Full month name

February

b or h

Abbreviated month name月份名称缩写

Feb

Two-digit month (with leading zeroes)

Two-digit day (with leading zeroes)

Two-digit day (without leading zeroes)

Full weekday name

Monday

Abbreviated weekday name

Mon

Three-digit day of year (with leading zeroes), between 001 and 366

069

Two-digit hour (with leading zeroes), between 00 and 23

Two-digit hour (without leading zeroes), between 0 and 23

Two-digit hour (with leading zeroes), between 01 and 12

Two-digit hour (without leading zeroes), between 1 and 12

Two-digit minutes (with leading zeroes)

Two-digit seconds (with leading zeroes)

Three-digit milliseconds (with leading zeroes)三位毫秒数

047

Nine-digit nanoseconds (with leading zeroes)九位纳秒数

047000000

Uppercase morning or afternoon marker大写上下午标记

Lowercase morning or afternoon marker小写上下午标记

RFC 822 numeric offset from GMT格林尼治时间偏移量

-0800

Time zone时区

PST

Seconds since 1970-01-01 00:00:00 GMT

1078884319

Milliseconds since 1970-01-01 00:00:00 GMT

1078884319047

In addition, you can specify flags that control the appearance of the formatted output. Table 3-6 shows all flags. For example, the comma flag adds group separators. That is,

另外，你可以指定标记来控制格式化输出的行为。例如逗号标记可以添加组分隔符。也就是

System.out.printf("%,.2f", 10000.0 / 3.0);

Table 3-6. Flags for printf

Flag

Purpose

Example

Prints sign for positive and negative numbers输出数字的正负号

+3333.33

space

Adds a space before positive numbers在整数前加一个空格

| 3333.33|

Adds leading zeroes加入前导的0

003333.33

Left-justifies field左对齐字段

|3333.33 |

(

Encloses negative number in parentheses用圆括号括起负数

(3333.33)

Adds group separators添加组分隔符

3,333.33

# (for f format)

Always includes a decimal point总是包含小数点

3,333.

# (for x or o format)

Adds 0x or 0 prefix添加0x或者0前缀

0xcafe

Converts to upper case转换为大写

0XCAFE

Specifies the index of the argument to be formatted; for example, %1$d %1$x prints the first argument in decimal and hexadecimal指定要格式化的参数的索引，例如%1$d %1$x以十进制和十六进制形式输出第一个参数

159 9F

Formats the same value as the previous specification; for example, %d %<x prints the same number in decimal and hexadecimal格式化前面指定的相同的值，例如%d %<x 以十进制和十六进制的形式输出同一个数字。

159 9F

prints打印出

3,333.33

You can use multiple flags, for example, "%,(.2f", to use group separators and enclose negative numbers in parentheses.

你可以使用多个标记，例如"%,(.2f",使用组分隔符并用圆括号括住负数。

NOTE

You can use the s conversion to format arbitrary objects. If an arbitrary object implements the Formattable interface, the object's formatTo method is invoked. Otherwise, the toString method is invoked to turn the object into a string. We discuss the toString method in Chapter 5 and interfaces in Chapter 6.

你可以使用s转换来格式化任意对象。如果任意对象实现了Formattable接口，则对象的formatTo方法被调用。否则调用toString方法来将一个对象转变为一个字符串。我们将在第五章和第六章中分别讨论toString方法和接口

You can use the static String.format method to create a formatted string without printing it:

你可使用静态方法String.format来创建格式化的字符串，而并不将其输出。

String message = String.format("Hello, %s. Next year, you'll be %d", name, age);

Although we do not describe the Date type in detail until Chapter 4, we do, in the interest of completeness, briefly discuss the date and time formatting options of the printf method. You use two a two-letter format, starting with t and ending in one of the letters of Table 3-7. For example,

尽管我们到第4章才讲述Date类型，但是完全是出于兴趣，简要介绍一下printf方法的时间和日期格式选项。你可以使用一个两字母的格式，以t开始，以表3-7中的字母结束。例如

System.out.printf("%tc", new Date());

prints the current date and time in the format

以如下格式输出日期和时间。

Mon Feb 09 18:05:19 PST 2004

As you can see in Table 3-7, some of the formats yield only a part of a given date, for example, just the day or just the month. It would be a bit silly if you had to supply the date multiple times to format each part. For that reason, a format string can indicate the index of the argument to be formatted. The index must immediately follow the %, and it must be terminated by a $. For example,

如你在表3-7中所见，一些格式仅输出指定时间的一部分，例如，仅仅是日或者月。如果你要多次提供时间，并要格式化每个部分，这看起来很傻。一个格式化字串可以指定要格式化的参数的索引。索引值紧跟百分号%，并以$结束。例如

System.out.printf("%1$s %2$tB %2$te, %2$tY", "Due date:", new Date());

prints输出

Due date: February 9, 2004

Alternatively, you can use the < flag. It indicates that the same argument as in the preceding format specification should be used again. That is, the statement

或者你可以选择使用<标记。它表明将再次使用前一个格式所规范的参数。也就是如下语句

System.out.printf("%s %tB %<te, %<tY", "Due date:", new Date());

yields the same output as the preceding statement.

将和上一条语句产生相同的输出。

CAUTION

Argument index values start with 1, not with 0: %1$... formats the first argument. This avoids confusion with the 0 flag.

参数索引值以1开始，而不是0.

You have now seen all features of the printf method. Figure 3-7 shows a syntax diagram for format specifiers.

下图是格式化说明符的语法：

Figure 3-7. Format specifier syntax

[View full size image]

NOTE

A number of the formatting rules are locale specific. For example, in Germany, the decimal separator is a period, not a comma, and Monday is formatted as Montag. You will see in Volume 2 how to control the international behavior of your applications.

一些格式化规范是地区性的。例如，在德国，十进制分隔符是一个句点，而不是一个逗号，而Monday被格式化为Montag。你将在卷2中看到如何在你的程序中处理国际化问题。

TIP

If you use a version of Java prior to JDK 5.0, use the NumberFormat and DateFormat classes instead of printf.

如果你使用的是JDK5.0以前版本，请使用NumberFormat和DateFormat来代替printf

3.6 Strings字符串

Wed, 12 Sep 2007 10:51:53 GMT

Conceptually, Java strings are sequences of Unicode characters. For example, the string "Java\u2122" consists of the five Unicode characters J, a, v, a, and ™. Java does not have a built-in string type. Instead, the standard Java library contains a predefined class called, naturally enough, String. Each quoted string is an instance of the String class:

概念上讲，Java字符串就是Unicode字符序列。例如，字符串"Java\u2122"由5个Unicode字符J，a，v，a和™组成。Java没有内建的string类型。但是，标准Java库提供了一个类，很自然的，叫做String。每个被引起来的字符串就是一个String实例：

String e = ""; // an empty string

String greeting = "Hello";

Code Points and Code Units 代码点和代码单元

Java strings are implemented as sequences of char values. As we discussed on page 41, the char data type is a code unit for representing Unicode code points in the UTF-16 encoding. The most commonly used Unicode characters can be represented with a single code unit. The supplementary characters require a pair of code units.

Java字符串是以char值序列的方式实现的。如我们在41页中提到的，char数据类型是一个表示UTF-16编码中各个Unicode代码点的代码单元。最常用的Unicode字符可以用一个单独的代码单元表示。增补字符需要一对代码单元。

The length method yields the number of code units required for a given string in the UTF-16 encoding. For example:

length方法返回指定的UTF-16编码字符串所需代码单元的数量，例如：

String greeting = "Hello";

int n = greeting.length(); // is 5.

To get the true length, that is, the number of code points, call

要得到真实的长度，即代码点的数量，调用：

int cpCount = greeting.codePointCount(0, greeting.length());

The call s.charAt(n) returns the code unit at position n, where n is between 0 and s.length() – 1. For example,

s.charAt(n) 返回位置n对应的代码单元，这里n介于0和s.length()-1之间。例如：

char first = greeting.charAt(0); // first is 'H'

char last = greeting.charAt(4); // last is 'o'

To get at the ith code point, use the statements

要获得第i个代码点，使用语句：

int index = greeting.offsetByCodePoints(0, i);

int cp = greeting.codePointAt(index);

NOTE

Java counts the code units in strings in a peculiar fashion: the first code unit in a string has position 0. This convention originated in C, where there was a technical reason for counting positions starting at 0. That reason has long gone away and only the nuisance remains. However, so many programmers are used to this convention that the Java designers decided to keep it.

Java以一种特殊的方式计算字符串中的代码单元：字符串中的第一个代码单元的位置是0。这个约定源于C，在C中位置从0开始计数是有技术原因的。这个技术原因现在早已不存在了，但是却留下了这个令人讨厌的方式。但是由于很多程序员习惯了这个约定，所以Java的设计者们决定保留它。

Why are we making a fuss about code units? Consider the sentence

我们为什么要在代码单元上小题大做？看一下这个句子

is the set of integers

The character requires two code units in the UTF-16 encoding. Calling

在UTF-16编码中，字符需要两个代码单元，调用

char ch = sentence.charAt(1)

doesn't return a space but the second code unit of . To avoid this problem, you should not use the char type. It is too low-level.

并不返回一个空格，而是其第二个代码单元。要避免这个问题，你不应当使用char类型。这个类型太低级。

If your code traverses a string, and you want to look at each code point in turn, use these statements:

如果你的代码遍历一个字符串，并且你想逐个查看每个代码单元，请使用下面的语句：

int cp = sentence.codePointAt(i);

if (Character.isSupplementaryCodePoint(cp)) i += 2;

else i++;

Fortunately, the codePointAt method can tell whether a code unit is the first or second half of a supplementary character, and it returns the right result either way. That is, you can move backwards with the following statements:

幸运的是，codePointAt方法可以告诉我们何处是一个辅助字符的前一半或者后一半，并且对于任一一种都可以返回正确的结果。也就是说，你也可以用下面的语句进行逆向遍历

i--;

int cp = sentence.codePointAt(i);

if (Character.isSupplementaryCodePoint(cp)) i--;

Substrings 子串

You extract a substring from a larger string with the substring method of the String class. For example,

用substring方法可以从一个大的字符串中提取字串。例如

String greeting = "Hello";

String s = greeting.substring(0, 3);

creates a string consisting of the characters "Hel".

得到一个由字符”Hel”组成的字串。

The second parameter of substring is the first code unit that you do not want to copy. In our case, we want to copy the code units in positions 0, 1, and 2 (from position 0 to position 2 inclusive). As substring counts it, this means from position 0 inclusive to position 3 exclusive.

substring的第二个参数是你第一个不想复制的代码单元。在我们的例子中，我们想复制的是位置0、1、2（从位置0到位置2，包含端点）。也就是从位置0（包含）到位置3（不包含）。

There is one advantage to the way substring works: Computing the number of code units in the substring is easy. The string s.substring(a, b) always has b - a code units. For example, the substring "Hel" has 3 – 0 = 3 code units.

substring的这种工作方式有一个优点：计算字串中的代码单元数量是简单的。字符串s.substring(a,b)的代码单元数总是等于b-a。从例子即可看出。

String Editing 字符串编辑

The String class gives no methods that let you change a character in an existing string. If you want to turn greeting into "Help!", you cannot directly change the last positions of greeting into 'p' and '!'. If you are a C programmer, this will make you feel pretty helpless. How are you going to modify the string? In Java, it is quite easy: concatenate the substring that you want to keep with the characters that you want to replace.

Java中的String类型虽然不提供字符串编辑的方法，但是，你可以采用将某个字符串的字串和其他字串相连接的方式。例如你希望将”Hello”修改为”Help!”，你可以这样做

greeting = greeting.substring(0, 3) + "p!";

This declaration changes the current value of the greeting variable to "Help!".

Because you cannot change the individual characters in a Java string, the documentation refers to the objects of the String class as being immutable. Just as the number 3 is always 3, the string "Hello" will always contain the code unit sequence describing the characters H, e, l, l, o. You cannot change these values. You can, as you just saw however, change the contents of the string variable greeting and make it refer to a different string, just as you can make a numeric variable currently holding the value 3 hold the value 4.

在Java中，你不能改变Java字串中的某个值，但是，你可以改变变量的内容，即使得字符串变量指向其他字符串。

Isn't that a lot less efficient? It would seem simpler to change the code units than to build up a whole new string from scratch. Well, yes and no. Indeed, it isn't efficient to generate a new string that holds the concatenation of "Hel" and "p!". But immutable strings have one great advantage: the compiler can arrange that strings are shared.

虽然生成新的字符组合效率会降低，但是不可变的字符串有一大优点：编译器可以将字符串共享。

To understand how this works, think of the various strings as sitting in a common pool. String variables then point to locations in the pool. If you copy a string variable, both the original and the copy share the same characters. Overall, the designers of Java decided that the efficiency of sharing outweighs the inefficiency of string editing by extracting substrings and concatenating.

要理解这个工作过程，假设各种字符串处在一个共享池中。字符串变量指向池中的某一个位置。如果你复制一个字符串，原字串和拷贝共享同一个字符序列。总之，Java设计者认为共享的有效性远大于提取字串在连接的字符串编辑的有效性。

Look at your own programs; we suspect that most of the time, you don't change strings—you just compare them. Of course, in some cases, direct manipulation of strings is more efficient. (One example is assembling strings from individual characters that come from a file or the keyboard.) For these situations, Java provides a separate StringBuilder class that we describe in Chapter 12. If you are not concerned with the efficiency of string handling, you can ignore StringBuilder and just use String.

看看我们的程序，大多数时候，我们并不改变字串，而是进行比较。当然，有时候直接对字符串进行操作更为有效。（一个例子就是编译来自于一个文件或者键盘的独立字符序列。）对此种情况而言，Java提供独立的StringBuilder类。我们在12章中讨论。如果你对字符串处理的效率不感兴趣，你可以跳过StringBuilder，仅仅使用String就可以了。

C++ NOTE

C programmers generally are bewildered when they see Java strings for the first time because they think of strings as arrays of characters:

C程序员第一次看到Java字符串的时候会感到疑惑，因为他们会认为字符串其实就是字符数组：

char greeting[] = "Hello";

That is the wrong analogy: a Java string is roughly analogous to a char* pointer,

这是一个错误的类比：Java字符串组略的类同于一个char*指针。

char* greeting = "Hello";

When you replace greeting with another string, the Java code does roughly the following:

当你用另一个字符串代替greeting的时候，Java代码粗略的进行如下工作：

char* temp = malloc(6);

strncpy(temp, greeting, 3);

strncpy(temp + 3, "p!", 3);

greeting = temp;

Sure, now greeting points to the string "Help!". And even the most hardened C programmer must admit that the Java syntax is more pleasant than a sequence of strncpy calls. But what if we make another assignment to greeting?

当然，现在greeting指向字符串”Help!”。即使是最铁杆的C程序员也必须承认Java语句比使用一组strncpy函数要令人愉快。但如果我们要给greeting另作指派又会如何呢？

greeting = "Howdy";

Don't we have a memory leak? After all, the original string was allocated on the heap. Fortunately, Java does automatic garbage collection. If a block of memory is no longer needed, it will eventually be recycled.

这难道不会产生内存泄漏？毕竟，原字串是分配在堆上的。幸运的是，Java具有垃圾自动回收机制。如果某部分内存不再需要，它将最终被回收。

If you are a C++ programmer and use the string class defined by ANSI C++, you will be much more comfortable with the Java String type. C++ string objects also perform automatic allocation and deallocation of memory. The memory management is performed explicitly by constructors, assignment operators, and destructors. However, C++ strings are mutable—you can modify individual characters in a string.

如果你是C++程序员，并且使用由ANSI C++定义的string类，你将感到和Java中的String类型一样的舒服。C++中的string对象也能自动分配和释放内存。内存管理由构造函数、赋值运算符和析构函数清晰的执行。但是C++字符串是可变的，你可以修改字串中的独立字符。

Concatenation 连接

Java, like most programming languages, allows you to use the + sign to join (concatenate) two strings.

和大多数编程语言一样，Java也可以使用+号将两个字符串相连接。

String expletive = "Expletive";

String PG13 = "deleted";

String message = expletive + PG13;

The above code sets the variable message to the string "Expletivedeleted". (Note the lack of a space between the words: the + sign joins two strings in the order received, exactly as they are given.)

以上的代码将变量message设置为字符串”Expletivedeleted”。（之所以两个单词之间会缺少空格，是因为+号精确的按照两个单词给出的顺序将其连接起来）

When you concatenate a string with a value that is not a string, the latter is converted to a string. (As you see in Chapter 5, every Java object can be converted to a string.) For example:

当你将一个字符串和一个非字符串连接时，后者将转换为字符串（第五章中，你将看到，Java对象都可以转换成字符串），例如：

int age = 13;

String rating = "PG" + age;

sets rating to the string "PG13".

将rating设置为”PG13”。

This feature is commonly used in output statements. For example,

这一功能通常用于输出语句，例如

System.out.println("The answer is " + answer);

is perfectly acceptable and will print what one would want (and with the correct spacing because of the space after the word is).

可以很好的接受，并打印出你想要的（由于is 后面有空格，所以也能正确的打印出空格）

Testing Strings for Equality 测试字符串相等

To test whether two strings are equal, use the equals method. The expression

要测试两个字符串是否相等，使用equals方法。表达式

s.equals(t)

returns TRue if the strings s and t are equal, false otherwise. Note that s and t can be string variables or string constants. For example, the expression

返回true当字符串t和s相等时，否则，返回false。注意，s和t可以是字符串变量，也可以是字符串常量。例如，表达式

"Hello".equals(greeting)

is perfectly legal. To test whether two strings are identical except for the upper/lowercase letter distinction, use the equalsIgnoreCase method.

也是很合法的。要测试两个字符串除了大小写的差别是否相同，使用equalsIgnoreCase方法。

"Hello".equalsIgnoreCase("hello")

Do not use the == operator to test whether two strings are equal! It only determines whether or not the strings are stored in the same location. Sure, if strings are in the same location, they must be equal. But it is entirely possible to store multiple copies of identical strings in different places.

不要使用==运算符来测试两个字符串是否相等！这种方法仅能判断两个字符串是否存储在同一个位置上。当然，如果字符串存储在同一个位置上，他们肯定相等。但是在不同的位置存储相同的字符串的多个拷贝也是完全有可能的。

String greeting = "Hello"; //initialize greeting to a string

if (greeting == "Hello") . . .

// probably true

if (greeting.substring(0, 3) == "Hel") . . .

// probably false

If the virtual machine would always arrange for equal strings to be shared, then you could use the == operator for testing equality. But only string constants are shared, not strings that are the result of operations like + or substring. Therefore, never use == to compare strings lest you end up with a program with the worst kind of bug—an intermittent one that seems to occur randomly.

如果虚拟机总是将字符串分配为共享的，那么，你可以使用==运算符来测试相等。但是只有字符串常量是共享的，而那些+或者substring运算产生的字符串则不是共享的。所以，千万不可以使用==来比较字符串，以免你编写出的程序存在最糟糕的一种bug——一种不连续发生的貌似随机的Bug。

C++ NOTE

If you are used to the C++ string class, you have to be particularly careful about equality testing. The C++ string class does overload the == operator to test for equality of the string contents. It is perhaps unfortunate that Java goes out of its way to give strings the same "look and feel" as numeric values but then makes strings behave like pointers for equality testing. The language designers could have redefined == for strings, just as they made a special arrangement for +. Oh well, every language has its share of inconsistencies.

如果你习惯了C++的string类，那么你需要特别注意相等性测试。C++中的string类在进行字符串内容的相等比较的时候，运算符==进行了重载。Java打破自己的形式，给字符串赋予数字值一般的外表，而实际上又让这些字符串在比较的时候像指针一样，这也许是个不幸的事情。这门语言的设计者可以重新定义string中的==符号，就像他们特别分配了+号一样。嗯，好吧，每个语言都有其矛盾的一面。

C programmers never use == to compare strings but use strcmp instead. The Java method compareTo is the exact analog to strcmp. You can use

C程序员从不使用==来比较字符串，而是使用strcmp。Java中的compareTo方法精确的类似于strcmp，你可以使用

if (greeting.compareTo("Hello") == 0) . . .

but it seems clearer to use equals instead.

但是使用equals似乎更清晰明了。

The String class in Java contains more than 50 methods. A surprisingly large number of them are sufficiently useful so that we can imagine using them frequently. The following API note summarizes the ones we found most useful.

Java中的String类有多达50个方法。这么多的方法都十分的有用，所以我们可以经常使用它们。下面的API注释中，我们总结了最有用的一些方法

（译者：以下内容不再翻译，仅供参考。）

NOTE

You will find these API notes throughout the book to help you understand the Java Application Programming Interface (API). Each API note starts with the name of a class such as java.lang.String—the significance of the so-called package name java.lang is explained in Chapter 4. The class name is followed by the names, explanations, and parameter descriptions of one or more methods.

We typically do not list all methods of a particular class but instead select those that are most commonly used, and describe them in a concise form. For a full listing, consult the on-line documentation.

We also list the version number in which a particular class was introduced. If a method has been added later, it has a separate version number.

java.lang.String 1.0

char charAt(int index)

returns the code unit at the specified location. You probably don't want to call this method unless you are interested in low-level code units.

int codePointAt(int index) 5.0

returns the code point that starts or ends at the specified location.

int offsetByCodePoints(int startIndex, int cpCount) 5.0

returns the index of the code point that is cpCount code points away from the code point at startIndex.

int compareTo(String other)

returns a negative value if the string comes before other in dictionary order, a positive value if the string comes after other in dictionary order, or 0 if the strings are equal.

boolean endsWith(String suffix)

returns TRue if the string ends with suffix.

boolean equals(Object other)

returns true if the string equals other.

boolean equalsIgnoreCase(String other)

returns true if the string equals other, except for upper/lowercase distinction.

int indexOf(String str)
int indexOf(String str, int fromIndex)
int indexOf(int cp)
int indexOf(int cp, int fromIndex)

return the start of the first substring equal to the string str or the code point cp, starting at index 0 or at fromIndex, or -1 if str does not occur in this string.

int lastIndexOf(String str)
int lastIndexOf(String str, int fromIndex)
int lastindexOf(int cp)
int lastindexOf(int cp, int fromIndex)

return the start of the last substring equal to the string str or the code point cp, starting at the end of the string or at fromIndex.

int length()

returns the length of the string.

int codePointCount(int startIndex, int endIndex) 5.0

returns the number of code points between startIndex and endIndex - 1. Unpaired surrogates are counted as code points.

String replace(CharSequence oldString, CharSequence newString)

returns a new string that is obtained by replacing all substrings matching oldString in the string with the string newString. You can supply String or StringBuilder objects for the CharSequence parameters.

boolean startsWith(String prefix)

returns true if the string begins with prefix.

String substring(int beginIndex)
String substring(int beginIndex, int endIndex)

return a new string consisting of all code units from beginIndex until the end of the string or until endIndex - 1.

String toLowerCase()

returns a new string containing all characters in the original string, with uppercase characters converted to lower case.

String toUpperCase()

returns a new string containing all characters in the original string, with lowercase characters converted to upper case.

String trim()

returns a new string by eliminating all leading and trailing spaces in the original string.

Reading the On-Line API Documentation

As you just saw, the String class has lots of methods. Furthermore, there are thousands of classes in the standard libraries, with many more methods. It is plainly impossible to remember all useful classes and methods. Therefore, it is essential that you become familiar with the on-line API documentation that lets you look up all classes and methods in the standard library. The API documentation is part of the JDK. It is in HTML format. Point your web browser to the docs/api/index.html subdirectory of your JDK installation. You will see a screen like that in Figure 3-2.

Figure 3-2. The three panes of the API documentation

[View full size image]

The screen is organized into three frames. A small frame on the top left shows all available packages. Below it, a larger frame lists all classes. Click on any class name, and the API documentation for the class is displayed in the large frame to the right (see Figure 3-3). For example, to get more information on the methods of the String class, scroll the second frame until you see the String link, then click on it.

Figure 3-3. Class description for the String class

[View full size image]

Then scroll the frame on the right until you reach a summary of all methods, sorted in alphabetical order (see Figure 3-4). Click on any method name for a detailed description of that method (see Figure 3-5). For example, if you click on the compareToIgnoreCase link, you get the description of the compareToIgnoreCase method.

Figure 3-4. Method summary of the String class

[View full size image]

Figure 3-5. Detailed description of a String method

[View full size image]

TIP

Bookmark the docs/api/index.html page in your browser right now.

3.5.4 其他运算符

Tue, 11 Sep 2007 00:50:42 GMT

Bitwise Operators 位运算符

When working with any of the integer types, you have operators that can work directly with the bits that make up the integers. This means that you can use masking techniques to get at individual bits in a number. The bitwise operators are

& ("and") | ("or") ^ ("xor") ~ ("not")

These operators work on bit patterns. For example, if n is an integer variable, then

int fourthBitFromRight = (n & 8) / 8;

gives you a 1 if the fourth bit from the right in the binary representation of n is 1, and 0 if not. Using & with the appropriate power of 2 lets you mask out all but a single bit.

在对整数类型进行处理的时，还有能够直接处理构成整数的各个位的运算符。这意味着你可以使用掩码技术来处理一个数字中的各个独立位。这些位运算符是：

& ("与") | ("或") ^ ("异或") ~ ("非")

这些运算符工作在比特形式下。例如，如果n是一个整型变量，那么

int fourthBitFromRight = (n & 8) / 8;

这条语句将在n的二进制表示从右起第四位是1时得出结果1，否则为0。使用&符号搭配适当的2的指数幂可以使你屏蔽某一个位以外的所有位。

NOTE 注释

When applied to boolean values, the & and | operators yield a boolean value. These operators are similar to the && and || operators, except that the & and | operators are not evaluated in "short circuit" fashion. That is, both arguments are first evaluated before the result is computed.

当应用于布尔值时，&和|运算将产生一个布尔值。这些运算符和&&以及||运算符是类似的，但是&和|并不以短路形式运算。也就是说，两个参数在结果算出之前就参与运算。（译者注，参见http://www.itsway.net/java/java020505.aspx）

There are also >> and << operators, which shift a bit pattern to the right or left. These operators are often convenient when you need to build up bit patterns to do bit masking:

int fourthBitFromRight = (n & (1 << 3)) >> 3;

Finally, a >>> operator fills the top bits with zero, whereas >> extends the sign bit into the top bits. There is no <<< operator.

还有>>和<<运算符，可以向左或者向右移动一位。这些运算符在你需要通过位模式来执行按位掩码时是非常方便的，例如：

int fourthBitFromRight = (n & (1 << 3)) >> 3;

最后，>>>运算符用0填写头两位，而>>把符号为增加到头一位。没有<<<运算符。

CAUTION 注意

The right-hand side argument of the shift operators is reduced modulo 32 (unless the left-hand side is a long, in which case the right-hand side is reduced modulo 64). For example, the value of 1 << 35 is the same as 1 << 3 or 8.

移位运算符右边的参数被减少到32（除非左边的参数较长，这种情况下，右边的较少到64）。例如，1<<35的值和1<<3或者1<<8是一样的。

C++ NOTE C++注释

In C/C++, there is no guarantee as to whether >> performs an arithmetic shift (extending the sign bit) or a logical shift (filling in with zeroes). Implementors are free to choose whatever is more efficient. That means the C/C++ >> operator is really only defined for non-negative numbers. Java removes that ambiguity.

在C/C++中，并不保证>>进行的是算术移位(扩展符号位)还是逻辑移位（以0填充）。设备可以在二者中选择更有效的操作。这就意味着C/C++中的>>运算符的确仅仅是为非负数定义的。Java去除了这种歧义性。

Mathematical Functions and Constants 数学函数与常量

The Math class contains an assortment of mathematical functions that you may occasionally need, depending on the kind of programming that you do.

To take the square root of a number, you use the sqrt method:

Math类包含一组你有时会用到的数学函数，这取决于你所编程序的类型。要计算一个数字的平方根，需要使用sqrt方法：

double x = 4;

double y = Math.sqrt(x);

System.out.println(y); // 打印 2.0

NOTE 注释

There is a subtle difference between the println method and the sqrt method. The println method operates on an object, System.out, defined in the System class. But the sqrt method in the Math class does not operate on any object. Such a method is called a static method. You can learn more about static methods in Chapter 4.

println方法和sqrt方法有一个微妙的差别。println方法对一个对象进行操作，即System类中定义的System.out。但是Math类中的sqrt方法并不对任何对象进行操作。这样的方法称作静态方法。你可在第四章中学习更多有关静态方法的知识。

The Java programming language has no operator for raising a quantity to a power: you must use the pow method in the Math class. The statement

double y = Math.pow(x, a);

sets y to be x raised to the power a (x^a). The pow method has parameters that are both of type double, and it returns a double as well.

Java语言没有指数幂运算符，你需要使用Math类中的pow方法。语句

double y = Math.pow(x, a);

将y的值设置为x的a次幂。pow方法的两个参数都应该是double类型，且返回值也是double类型。

The Math class supplies the usual trigonometric functions

Math类提供了常用的三角函数：

Math.sin

Math.cos

Math.tan

Math.atan

Math.atan2

and the exponential function and its inverse, the natural log:

以及指数函数及其逆运算——自然对数：

Math.exp

Math.log

Finally, two constants denote the closest possible approximations to the mathematical constants p and e:

最后，介绍两个与数学常量p 和 e的值非常近似的常量：

Math.PI

Math.E

TIP提示

Starting with JDK 5.0, you can avoid the Math prefix for the mathematical methods and constants by adding the following line to the top of your source file:

从JDK5.0开始，你可以在源文件起始处使用如下代码来避免每次使用数学方法和常量的Math前缀。

import static java.lang.Math.*;

For example,

例如:

System.out.println("The square root of \u03C0 is " + sqrt(PI));

We discuss static imports in Chapter 4.

我们将在第四章讨论静态导入。

NOTE注意

The functions in the Math class use the routines in the computer's floating-point unit for fastest performance. If completely predictable results are more important than fast performance, use the StrictMath class instead. It implements the algorithms from the "Freely Distributable Math Library" fdlibm, guaranteeing identical results on all platforms. See http://www.netlib.org/fdlibm/index.html for the source of these algorithms. (Whenever fdlibm provides more than one definition for a function, the StrictMath class follows the IEEE 754 version whose name starts with an "e".)

为了获得最快的性能，Math类中的函数使用计算机浮点运算单元中的例程。如果可预测的结果完全重于快速表现，则使用StrictMath类。这个类从“自由分布数学库”中实现运算，保证各个平台上的统一的结果。算法源码参见http://www.netlib.org/fdlibm/index.html。不论何时fdlibm提供对一个函数的多种定义，StrictMath类始终遵循以“e”开始命名的IEEE 754版本。

Conversions Between Numeric Types 数字类型之间的转换

It is often necessary to convert from one numeric type to another. Figure 3-1 shows the legal conversions.

在多种数字类型之间进行转换是常有的事，图3-1说明了合法的转换：

图3-1 数字类型之间的合法转换

The six solid arrows in Figure 3-1 denote conversions without information loss. The three dotted arrows denote conversions that may lose precision. For example, a large integer such as 123456789 has more digits than the float type can represent. When the integer is converted to a float, the resulting value has the correct magnitude but it loses some precision.

图3-1中的六个实箭头表示无信息丢失的转换。三个虚箭头表示可能丢失精度的转换。例如，一个大的整型数字，如123456789，其位数多于浮点型能够表示的位数。当这个整型数转换成浮点型时，结果值仍然很大，但是丢失了精度。

int n = 123456789;

float f = n; // f is 1.23456792E8

When two values with a binary operator (such as n + f where n is an integer and f is a floating-point value) are combined, both operands are converted to a common type before the operation is carried out.

当两个数字和一个二进制运算符结合在一起（例如n+f中，n是一个整数，而f是一个浮点数），两个操作数都会在运算之前被转换为通用类型。

If either of the operands is of type double, the other one will be converted to a double.
Otherwise, if either of the operands is of type float, the other one will be converted to a float.
Otherwise, if either of the operands is of type long, the other one will be converted to a long.
Otherwise, both operands will be converted to an int.

如果两个操作数有一个是double型，另一个转换为double型。
否则，如果两个操作数有一个为float型，则另一个转换为float型。
否则，如果两个操作数有一个为long型，则另一个转换为long型。
否则，两个操作数都被转换为整型。

Casts

In the preceding section, you saw that int values are automatically converted to double values when necessary. On the other hand, there are obviously times when you want to consider a double as an integer. Numeric conversions are possible in Java, but of course information may be lost. Conversions in which loss of information is possible are done by means of casts. The syntax for casting is to give the target type in parentheses, followed by the variable name. For example:

在前面的章节中，你可以看到整型值在需要的时候可以自动转换为double型，另一方面，有时你也希望把double型转换为整型。在Java中，数字类型的转换是允许的，但是丢失信息也是自然的。丢失信息的转换是依靠强制转换来完成的。强制转换的语句是在变量名前加上由圆括号括起来的目标类型，例如：

double x = 9.997;

int nx = (int) x;

Then, the variable nx has the value 9 because casting a floating-point value to an integer discards the fractional part.

这样，变量nx的值就是0，因为浮点型向整型的强制转换舍弃了小数部分。

If you want to round a floating-point number to the nearest integer (which is the more useful operation in most cases), use the Math.round method:

如果你想把一个浮点数四舍五入成最接近的整数（在大多数情况下，这是更有用的操作），使用Math.round方法：

double x = 9.997;

int nx = (int) Math.round(x);

Now the variable nx has the value 10. You still need to use the cast (int) when you call round. The reason is that the return value of the round method is a long, and a long can only be assigned to an int with an explicit cast because there is the possibility of information loss.

现在，变量nx的值就是10了。在你调用round方法时，你还是需要进行强制转换(int)。原因是round方法的返回值类型是long，而long类型在给int变量赋值时，由于可能产生信息丢失，所以必须采用显式转换。

CAUTION注意

If you try to cast a number of one type to another that is out of the range for the target type, the result will be a truncated number that has a different value. For example, (byte) 300 is actually 44.

如果你试图将某种类型的数字转换为比原类型范围小的目标类型，结果将被截断，产生一个不同的值，例如(byte) 300 的结果实际上是44。

C++ NOTE C++注释

You cannot cast between boolean values and any numeric type. This convention prevents common errors. In the rare case that you want to convert a boolean value to a number, you can use a conditional expression such as b ? 1 : 0.

你不能在布尔型和数字类型之间进行转换。这种转换将产生常见错误。极少数情况下，你希望将布尔值转换为一个数字，此时你可以使用条件表达式，例如b?1:0

Parentheses and Operator Hierarchy 圆括号和运算优先级

Table 3-4 shows the precedence of operators. If no parentheses are used, operations are performed in the hierarchical order indicated. Operators on the same level are processed from left to right, except for those that are right associative, as indicated in the table. For example, because && has a higher precedence than ||, the expression

Table 3-4. Operator Precedence

Operators

Associativity

[] . () (method call)

Left to right

! ~ ++ -- + (unary) – (unary) () (cast) new

Right to left

* / %

Left to right

+ -

Left to right

<< >> >>>

Left to right

< <= > >= instanceof

Left to right

== !=

Left to right

Right to left

= += -= *= /= %= &= |= ^= <<= >>= >>>=

Right to left

表3-4展示了运算符的优先级。如果没有使用括号，运算符将按照表中显示的优先级进行运算。除了表中指明的右结合的运算符，同一级别的运算符自左向右运算。例如，&&和优先级高于||，表达式

a && b || c

means等于

(a && b) || c

Because += associates right to left, the expression

由于+=自右向左结合，表达式

a += b += c

means等于

a += (b += c)

That is, the value of b += c (which is the value of b after the addition) is added to a.

也就是b+=c的值（即第一次加法后b的值）再加到a上。

C++ NOTE C++注释

Unlike C or C++, Java does not have a comma operator. However, you can use a comma-separated list of expressions in the first and third slot of a for statement.

与C或C++不同，Java没有逗号运算符，但是你可以在一个for语句中的第一个和第三个位置使用一个逗号分隔的表达式。

C语言中的逗号运算符：

C语言中逗号“，”也是一种运算符，称为逗号运算符。其功能是把两个表达式连接起来组成一个表达式，称为逗号表达式。
其一般形式为：表达式1，表达式2 其求值过程是分别求两个表达式的值，并以表达式2的值作为整个逗号表达式的值。
void main(){
int a=2,b=4,c=6,x,y;
y=(x=a+b),(b+c);
printf("y=%d,x=%d",y,x);
}
a<--2,b<--4,c<--6,x<--0,y<--0
x<--a+b,y<---b+c
本例中，y等于整个逗号表达式的值，也就是表达式2的值，x是第一个表达式的值。对于逗号表达式还要说明几点：
1.逗号表达式一般形式中的表达式1和表达式2 也可以又是逗号表达式。例如：表达式1，(表达式2，表达式3) 形成了嵌套情形。因此可以把逗号表达式扩展为以下形式：表达式1，表达式2，…表达式n 整个逗号表达式的值等于表达式n的值。
2.程序中使用逗号表达式，通常是要分别求逗号表达式内各表达式的值，并不一定要求整个逗号表达式的值。
3.并不是在所有出现逗号的地方都组成逗号表达式，如在变量说明中，函数参数表中逗号只是用作各变量之间的间隔符。
以上是摘抄来的我本人觉得自己最常使用逗号运算符是在
for循环里
for (i = 0, j = 0; i < 3 && j < 3; i++, j+=2) {
printf("i = %d, j = %d",i,j);
}

Enumerated Types 枚举类型

Sometimes, a variable should only hold a restricted set of values. For example, you may sell clothes or pizza in four sizes: small, medium, large, and extra large. Of course, you could encode these sizes as integers 1, 2, 3, 4, or characters S, M, L, and X. But that is an error-prone setup. It is too easy for a variable to hold a wrong value (such as 0 or m).

有时候，一个变量需要仅保存一组有限值的集合。例如，你可能出售四种尺寸的衣服或者匹萨：小号、中号、大号和特大号。当然，你可以给这四种型号编号为1，2，3，4或者S,M,L,X。但这是一个具有错误倾向的设置。变量很可能会承载一个错误的值（比如0或者m）。

Starting with JDK 5.0, you can define your own enumerated type whenever such a situation arises. An enumerated type has a finite number of named values. For example,

从JDK5.0开始，你可以在遇到这种情况时定义自己的枚举类型。一个枚举类型具有有限个数的命名变量。例如：

enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };

Now you can declare variables of this type:

现在，你可以定义这种类型的变量：

Size s = Size.MEDIUM;

A variable of type Size can hold only one of the values listed in the type declaration or the special value null that indicates that the variable is not set to any value at all.

一个Size类型的变量只能承载Size类型中声明的一个值，或者承载一个特殊值null来表示这个变量没有被设置任何值。

We discuss enumerated types in greater detail in Chapter 5.

我们将在第五章更详细的讨论枚举类型。

3.5.3 Relational and boolean Operators关系和逻辑运算符

Mon, 10 Sep 2007 11:10:08 GMT

Java has the full complement of relational operators. To test for equality you use a double equal sign, ==. For example, the value of

Java有完全的关系运算符补充。要测试相等，你可以使用一个双等号，==。比如，

3 == 7

is false.

3==7的值是false。

Use a != for inequality. For example, the value of

使用!=来测试不等。比如：

3 != 7

is true.

3 != 7的值是true。

Finally, you have the usual < (less than), > (greater than), <= (less than or equal), and >= (greater than or equal) operators.

最后，还有普通的< （小于），> （大于），<= （小于等于），和 >= (大于等于) 运算符。

Java, following C++, uses && for the logical "and" operator and || for the logical "or" operator. As you can easily remember from the != operator, the exclamation point ! is the logical negation operator. The && and || operators are evaluated in "short circuit" fashion. The second argument is not evaluated if the first argument already determines the value. If you combine two expressions with the && operator,

Java，和C++一样，使用&&表示逻辑与，使用||表示逻辑或。由于你能轻易记得!=运算符，所以感叹号!就表示逻辑非。 && 和 || 运算符采用“短路”方式求值。如果第一个参数的值已经确定，则不需要考虑第二个参数的值。如果你将两个表达式用&&连接，

expression₁ && expression₂

and the truth value of the first expression has been determined to be false, then it is impossible for the result to be TRue. Thus, the value for the second expression is not calculated. This behavior can be exploited to avoid errors. For example, in the expression

并且第一个表达式的真值是false，那么运算结果不可能为true。因此第二个表达式的值不参与运算。该特性可以用来避免错误。例如，在表达式

x != 0 && 1 / x > x + y // no division by 0

the second part is never evaluated if x equals zero. Thus, 1 / x is not computed if x is zero, and no divide-by-zero error can occur.

当中，第二部分如果x等于0的话就不被计算。

Similarly, the value of expression₁ || expression₂ is automatically true if the first expression is true, without evaluation of the second expression.

类似的，表达式expression₁ || expression₂中，如果第一表达式为true，那么整个表达式的值就为true,而不计算第二个表达式的值。

Finally, Java supports the ternary ?: operator that is occasionally useful. The expression

最后，Java支持偶尔很有用的三目运算符?:。表达式

condition ? expression₁ : expression₂

evaluates to the first expression if the condition is TRue, to the second expression otherwise. For example,

如果condition为ture则计算expression₁的值，否则计算expression₂的值。例如：

x < y ? x : y

gives the smaller of x and y.

求得x和y当中较小的一个。

3.5.2 Operators运算符之增量运算符和减量运算符

Fri, 07 Sep 2007 00:58:22 GMT

Increment and Decrement Operators增量和减量运算符

Programmers, of course, know that one of the most common operations with a numeric variable is to add or subtract 1. Java, following in the footsteps of C and C++, has both increment and decrement operators: n++ adds 1 to the current value of the variable n, and n-- subtracts 1 from it. For example, the code

程序员，自然地，知道一种最普通的带有数字变量的运算符，用来实现加1或者减1。Java步C和C++的后尘，也有增量和减量运算符：n++ 给当前变量的值加1，而n-- 从n中减去1。例如，代码：

int n = 12;

n++;

changes n to 13. Because these operators change the value of a variable, they cannot be applied to numbers themselves. For example, 4++ is not a legal statement.

将n改变为13。由于这些运算符用来改变变量的值，所以他们不能被用来改变数字本身。例如4++就不是一个合法的语句。

There are actually two forms of these operators; you have seen the "postfix" form of the operator that is placed after the operand. There is also a prefix form, ++n. Both change the value of the variable by 1. The difference between the two only appears when they are used inside expressions. The prefix form does the addition first; the postfix form evaluates to the old value of the variable.

这些运算符实际上有两种形式；你见过运算符被置于操作数后面的“后缀”形式。还有一个前缀形式，++n。都是改变变量的值多一或少一。二者的不同仅体现在他们用于表达式的时候。前缀形式先做加法运算；后缀形式求得变量的原值。

int m = 7;

int n = 7;

int a = 2 * ++m; // now a is 16, m is 8

int b = 2 * n++; // now b is 14, n is 8

We recommend against using ++ inside other expressions because this often leads to confusing code and annoying bugs.

我们不推荐在其他表达式中使用++，因为这经常导致混乱的代码以及恼人的bug。

(Of course, while it is true that the ++ operator gives the C++ language its name, it also led to the first joke about the language. C++ haters point out that even the name of the language contains a bug: "After all, it should really be called ++C, because we only want to use a language after it has been improved.")

（当然，当++运算符赋予C++语言这个名字的时候，它也引发了这个语言的第一个笑话。C++的反对者指出就连这个程序语言的名字都存在bug:“毕竟，她真的该叫做C++，因为我们只想在语言被改进以后使用它。”）

3.5.1 Operators运算符之算术运算符

Thu, 30 Aug 2007 04:33:00 GMT

The usual arithmetic operators + – * / are used in Java for addition, subtraction, multiplication, and division. The / operator denotes integer division if both arguments are integers, and floating-point division otherwise. Integer remainder (sometimes called modulus) is denoted by %. For example, 15 / 2 is 7, 15 % 2 is 1, and 15.0 / 2 is 7.5.

通常的算术运算符+ – * /在Java中用来进行加，减，乘，除。当两个操作数都是整数时，运算符/表示整数除法，其他情况表示浮点除法。整数余数（有时也叫模数）用%表示。例如，15 / 2 等于 7, 15 % 2 等于 1, 而 15.0 / 2 等于 7.5。

Note that integer division by 0 raises an exception, whereas floating-point division by 0 yields an infinite or NaN result.

注意整数除法中0作除数将导致异常，而浮点除法中用0作除法将产生无穷或者NaN的结果。

There is a convenient shortcut for using binary arithmetic operators in an assignment. For example,

在一条赋值语句中有一个使用二元算术运算的捷径。例如：

x += 4;

is equivalent to

等效于

x = x + 4;

(In general, place the operator to the left of the = sign, such as *= or %=.)

（总之，就是把运算符放在等号的左边，例如*= 或者 %= 。）

NOTE注释

One of the stated goals of the Java programming language is portability. A computation should yield the same results no matter which virtual machine executes it. For arithmetic computations with floating-point numbers, it is surprisingly difficult to achieve this portability. The double type uses 64 bits to store a numeric value, but some processors use 80-bit floating-point registers. These registers yield added precision in intermediate steps of a computation. For example, consider the computation:

Java编程语言的一个初衷就是可移植性。对于一个运算应该产生相同的结果，无论何种虚拟机执行该运算。对于浮点数参与的算术运算，要实现这种可移植性是惊人的困难的。双精度类型的用64位存储一个数值，但是一些处理器使用的是80位浮点寄存器。这些寄存器在中等级别的计算中产生额外的精度。例如，考虑如下计算：

double w = x * y / z;

Many Intel processors compute x * y and leave the result in an 80-bit register, then divide by z and finally truncate the result back to 64 bits. That can yield a more accurate result, and it can avoid exponent overflow. But the result may be different from a computation that uses 64 bits throughout. For that reason, the initial specification of the Java virtual machine mandated that all intermediate computations must be truncated. The numeric community hated it. Not only can the truncated computations cause overflow, they are actually slower than the more precise computations because the truncation operations take time. For that reason, the Java programming language was updated to recognize the conflicting demands for optimum performance and perfect reproducibility. By default, virtual machine designers are now permitted to use extended precision for intermediate computations. However, methods tagged with the strictfp keyword must use strict floating-point operations that yield reproducible results. For example, you can tag main as

许多Intel处理器计算x*y并将结果存放于80位的寄存器中，然后除以z并最终将结果省略成64位的。那可以产生更为精确的结果，并可以避免指数溢出。但是完全使用64位计算将可能产生不同的结果。由于那个原因，起初Java虚拟机规格规定所有中间运算必须被舍掉多余的精度。数字团体厌恶这种处理方式。舍去操作不仅会引起溢出，而且由于舍去操作需要占用时间而花费了比精确计算更多的时间。由此，Java编程语言进行了升级，考虑了最适宜的性能和完美的再现性这两个互相冲突的要求。现在虚拟机设计者被许可使用扩展精度于中间级运算中。但是使用关键字strictfp标明的方法必须使用严格的浮点操作以产生有复验性的结果，例如，你可以标记main方法如下：

public static strictfp void main(String[] args)

Then all instructions inside the main method use strict floating-point computations. If you tag a class as strictfp, then all of its methods use strict floating-point computations.

于是main方法中的所有指令都采用严格的浮点运算。如果你标记一个类为strictfp，那么该类的所有方法都将使用严格的的浮点计算。

The gory details are very much tied to the behavior of the Intel processors. In default mode, intermediate results are allowed to use an extended exponent, but not an extended mantissa. (The Intel chips support truncation of the mantissa without loss of performance.) Therefore, the only difference between default and strict mode is that strict computations may overflow when default computations don't.

详细资料非常依赖于Intel处理器的表现。在默认模式下，中间结果被许可使用扩展指数，但不能使用扩展尾数。（Intel芯片支持不影响性能的情况下舍去尾数。）因此，默认模式和严格模式唯一的不同是严格计算可能引起溢出而默认模式不会。

If your eyes glazed over when reading this note, don't worry. Floating-point overflow isn't a problem that one encounters for most common programs. We don't use the strictfp keyword in this book.

如果阅读此注释时你的眼睛变得迟钝，不要紧。浮点溢出对大多数普通编程而言并不是个能遇到的问题。在本书中我们不使用strictfp关键字。（汗：你既然用不着，说这么一大堆废话干啥？害得老子翻译了足足一个小时，还稀里糊涂的。）

3.4 Variables变量

Tue, 28 Aug 2007 11:37:00 GMT

In Java, every variable has a type. You declare a variable by placing the type first, followed by the name of the variable. Here are some examples:

在Java中，每个变量都有一个类型。你可以用把类型写在前面，后面紧跟变量名的方式来声明变量。下面是一些例子：

double salary;

int vacationDays;

long earthPopulation;

boolean done;

Notice the semicolon at the end of each declaration. The semicolon is necessary because a declaration is a complete Java statement.

注意每一个声明后面的分号。由于每个声明都是一条完整的Java语句，所以分号是必须写的。

A variable name must begin with a letter and must be a sequence of letters or digits. Note that the terms "letter" and "digit" are much broader in Java than in most languages. A letter is defined as 'A'–'Z', 'a'–'z', '_', or any Unicode character that denotes a letter in a language. For example, German users can use umlauts such as 'ä' in variable names; Greek speakers could use a p. Similarly, digits are '0'–'9' and any Unicode characters that denote a digit in a language. Symbols like '+' or '©' cannot be used inside variable names, nor can spaces. All characters in the name of a variable are significant and case is also significant. The length of a variable name is essentially unlimited.

变量名必须以字母开头的一串字母或数字序列。注意，Java中所说的“字母”和“数字”比大多数编程语言要宽泛的多。字母是指'A'–'Z', 'a'–'z', '_',或者任何在某种语言中表示某个字母的Unicode字符。例如，德国人可以在变量名中使用元音变音'ä'；希腊人可以使用p。类似的，数字也是'0'–'9'或者任何在某种语言中表示一个数位的Unicode字符。诸如'+' or '©'此类的字符也不能被用于变量名，空格也不可以。所有的变量名中的字符乃至大小写都是有意义的。变量名的长度几乎是没有限制的。

TIP

If you are really curious as to what Unicode characters are "letters" as far as Java is concerned, you can use the isJavaIdentifierStart and isJavaIdentifierPart methods in the Character class to check.

提示

如果你真的像关心Java那样对于何种Unicode字符属于“字母”感到好奇的话，不妨用Character类中的isJavaIdentifierStart和isJavaIdentifierPart方法去检查。

You also cannot use a Java reserved word for a variable name. (See Appendix A for a list of reserved words.)

你不能用Java保留字作为变量名。

You can have multiple declarations on a single line:

你可以在同一行声明多个变量：

int i, j; // both are integers

However, we don't recommend this style. If you declare each variable separately, your programs are easier to read.

但是，我们并不推荐使用这种方式。如果你分别声明每一个变量，你的程序可读性更好。

NOTE

As you saw, names are case sensitive, for example, hireday and hireDay are two separate names. In general, you should not have two names that only differ in their letter case. However, sometimes it is difficult to come up with a good name for a variable. Many programmers then give the variable the same name of the type, such as

Box box; // ok--Box is the type and box is the variable name

Other programmers prefer to use an "a" prefix for the variable:

Box aBox;

注释

如你所见，命名是区分大小写的，例如，hireday和hireDay是两个不同的名字。通常，你不应该仅仅通过大小写来区分两个命名。但是，有时候很难给一个变量起一个好名字。很多程序员就用与类型名相同的名字来给变量命名，例如：

Box box; // ok--Box 是个类型而 box 是变量名

有的程序员喜欢给变量名加上一个“a”前缀：

Box aBox;

Initializing Variables变量初始化

After you declare a variable, you must explicitly initialize it by means of an assignment statement—you can never use the values of uninitialized variables. For example, the Java compiler flags the following sequence of statements as an error:

声明变量以后，你必须明确的用一个赋值语句对其初始化——你绝不能够使用一个没有初始化的变量。例如，Java编译器将会标记如下语句为一个错误：

int vacationDays;

System.out.println(vacationDays); // ERROR--variable not initialized

You assign to a previously declared variable by using the variable name on the left, an equal sign (=), and then some Java expression that has an appropriate value on the right.

给变量赋值时，你可以把先前声明好的变量名写在左边，再写一个等号(=)，然后右边紧跟一些Java具有适当值的表达式。

int vacationDays;

vacationDays = 12;

You can both declare and initialize a variable on the same line. For example:

你也可以把变量的声明和初始化写在一行，例如：

int vacationDays = 12;

Finally, in Java you can put declarations anywhere in your code. For example, the following is valid code in Java:

最后要说明的，在Java中，你可以把变量的声明放在你代码的任何地方。比如，下面的代码在Java中是正确的：

double salary = 65000.0;

System.out.println(salary);

int vacationDays = 12; // ok to declare a variable here

In Java, it is considered good style to declare variables as closely as possible to the point where they are first used.

在Java中，一种比较好的方式就是声明变量以后紧接着指出该变量第一次使用的位置。

C++ NOTE

C and C++ distinguish between the declaration and definition of variables. For example,

int i = 10;

is a definition, whereas

extern int i;

is a declaration. In Java, no declarations are separate from definitions.

C++ 附注

C和C++中区分声明和定义。例如：

int i = 10;

是一个定义，而

extern int i;

是一个声明。在Java中，没有独立于定义的声明。

Constants常量

In Java, you use the keyword final to denote a constant. For example,

在Java中，你可以用关键字final来指明一个常量，例如：

public class Constants

{

public static void main(String[] args)

{

final double CM_PER_INCH = 2.54;

double paperWidth = 8.5;

double paperHeight = 11;

System.out.println("Paper size in centimeters: "

+ paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH);

}

The keyword final indicates that you can assign to the variable once, and then its value is set once and for all. It is customary to name constants in all upper case.

关键字final指出你可以给变量赋值一次，而其值也只能设置一次。通常习惯上将常量名全部大写。

It is probably more common in Java to want a constant that is available to multiple methods inside a single class. These are usually called class constants. You set up a class constant with the keywords static final. Here is an example of using a class constant:

在Java中，我们或许更多时候需要一个能被一个类中的多个方法使用的常量。这种常量被称之为类常量。类常量用关键字static final来设置。下面是一个使用类常量的例子：

public class Constants2

{

public static void main(String[] args)

{

double paperWidth = 8.5;

double paperHeight = 11;

System.out.println("Paper size in centimeters: "

+ paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH);

}

public static final double CM_PER_INCH = 2.54;

}

Note that the definition of the class constant appears outside the main method. Thus, the constant can also be used in other methods of the same class. Furthermore, if (as in our example) the constant is declared public, methods of other classes can also use the constant—in our example, as Constants2.CM_PER_INCH.

注意到对类常量的定义出现在了主方法的外面。正因为如此，类常量也可以被同类的其他方法访问。此外，如果（如我们的例子）常量被声明为public，那么其他类的方法也可以使用这个常量——在我们的例子中，就像Constants2中的CM_PER_INCH一样。

C++ NOTE

const is a reserved Java keyword, but it is not currently used for anything. You must use final for a constant.

C++ 注释

const是一个Java预留的关键字，但是现在不再用于任何场合。你必须使用final来定义常量。