"do any harm: it cannot infect" now reads "do any harm: untrusted code
cannot infect ..."

Unicode character of PI was described:
..., and u3c00 is the character PI.
Now reads:
..., and u03c0 is the character PI.

second code example; The code reads:

byte sum = (byte) (b1 + b2); // Sum wraps to 128,
which is the smallest byte

It should be changed to read:

byte sum = (byte) (b1 + b2); // Sum wraps to -128,
which is the smallest byte

***The following error applies only to the 3/01 printing of the book:***

All three comments are missing a multiplication sign.

Changed:
byte sum = b1 + b2; // Sum wraps to...
To:
byte sum = (byte)(b1 + b2); // Sum wraps to...

Changed the four lines to read:

double inf = 1.0/0.0; // Infinity
double neginf = -1.0/0.0; // -Infinity
double negzero = -1.0/inf; // Negative zero
double NaN = 0.0/0.0; // Not-a-Number

Also, in the paragraph above these lines of code, changed "such as 0/0" to
"such as 0.0/0.0".

Also, in the last paragraph before the "Strings" heading,
changed the sentence:

1/0 yields positive infinity, but 1 divided by
negative zero yields negative infinity.

To:

1.0/0.0 yields positive infinity, but 1.0 divided by
negative zero yields negative infinity.

Did read:
Float.isNan() and Double.isNan() methods.
Now reads:
Float.isNaN() and Double.isNaN() methods.

"The only way to distinguish negative zero..."
Now reads:
"One way to distinguish negative zero..."

Changed the 2nd sentence of the second paragraph to read:

A widening conversion occurs when a value of one type is converted to
a wider type--one that has a larger range of legal values.

Deleted the 3rd sentence of the 2nd paragraph, which began,
"A narrowing conversion...fewer bits."

And changed the beginning of the 3rd paragraph to read:

Narrowing conversions are another matter, however. A narrowing conversion
occurs when a value is converted to a type that is not wider than it.
Narrowing conversions are not always safe: it is reasonable to convert...

Also, changed "$ndash;128" to "-128"

The following code line:
1.7 // An integer literal
Now reads:
1.7 // A floating-point literal

Changed the last line of this paragraph to read:

"...operands must be convertible to the same type."

Did read:
byte b = ~12 //~00000110 ==> 11111001 or -13 decimal
Now reads:
byte b = ~12 //~00001100 ==> 11110011 or -13 decimal

Did read:
10 & 7
Now reads:
10 ^ 7

-50 >>> 2 // 11001110 >>> 2 = 00110011 = 51
0xff >>> 4 // 11111111 >>> 4 = 00001111 = 15 = 255/16

now reads

0xff >>> 4 // 11111111 >>> 4 = 00001111 = 15 = 255/16
-50 >>> 2 // 0xFFFFFFCE >>> 2 = 0x3FFFFF33 = 1073741811

Changed the last line of this paragraph to read:

"...of any type, but they must be convertible to the same type."

Changed first sentence to read "In Java, objects (and arrays) are ..."

and finishes on 45:

The code now reads:

for(int i= 0; i < 10; i++) {
a[i]++; // Body of this loop is a compound statement.
b[i]--; // It consists of two expression statements
} // within curly braces.

Note "statement" previously in Line 3 should be the end of Line 2.

First sentence did read:
"does not allow you to use a variable"
Now reads:
"does not allow you to use a local variable"

The line did read:

int j = 0; // Declare j; i and j are in scope here

Now reads:

int j = 0; // Declare j; the scope of j begins here
i++; // i is in scope here; increment it

... 0"));
only one ')' is needed

java.langThrowable
should be
java.lang.Throwable

Changed "java.langThrowable" to "java.lang.Throwable".

did read:
throw new IllegalArgumentException("x must be >= 0"));

now reads:
throw new IllegalArgumentException("x must be >= 0");

did read:

throw new IllegalArgumentException("x must be >= 0"));

now reads:

throw new IllegalArgumentException("x must be >= 0");

In the paragraph that starts "In previous discussions...", changed
the second to last sentence to read:

The finally clause gives us a way to write a while loop that handles the
continue statement in the same way that a for loop does.

After the second code block, added this new sentence:

Note, however, that placing the increment statement within a finally block
causes this while loop to respond to break statements differently than the
for loop does.

Changed "A method is a named collection of Java..."
to "A method is a named sequence of Java..."

Changed the fourth bullet item to read:

The checked exceptions that the method can throw (the signature may
also list unchecked exceptions, but these are not required)

java.lang.Constructor
Now reads:
java.lang.reflect.Constructor

At the start of the paragraph that begins "String literals can be only a
single line...":

The new opening sentence now reads "String literals cannot contain comments,
and may consist of only a single line."

At the start of the paragraph that begins "String literals can be only a
single line...":

A new opening sentence now reads "String literals cannot contain comments,
and may consist of only a single line."

Changed the following lines:

Class typeInt = int.type;
Class typeIntArray = int[].type;

To:

Class typeInt = int.class;
Class typeIntArray = int[].class;

Deleted this paragraph and replaced it with:

Every array has a length field that specifies the number of elements it
contains. Note that this field is read-only: you can use it to read the
length of the array, but you cannot assign any value to it or use it to
set or change the length of an array.

Changed the following two lines:

int[] values; // Array elements initialized elsewhere
int total = 0; // Store sum of elements here

To read:

int[] values; // Assume array is created and initialized elsewhere
int total = 0; // Store sum of elements here

Changed from:
public static void main(String args[])
To:
public static void main(String[] args)

Changed "C:>" to "%" at the beginning of the code line.

second-to-last sentence:
"(or -cp)" was added after "option".

Changed "C:>" to "%" at the beginning of each code line.

Should mention that subclassing replaces most union behavior

Changed second sentence to read:
...simulate C varargs functions for simple cases, and arguments can also
be passed as an Object[],...

The line:
private static final NUMPTS = 500;
Now reads:
private static final int NUMPTS = 500;

And the last lines:

double x = 0.0, delta_x;
delta_x = (Circle.PI/2)/(NUMPTS-1);

Now read:

double x = 0.0;
double delta_x = (Circle.PI/2)/(NUMPTS-1);

This code example is now on two lines, reading:

// Invoke the finalizer of our superclass.
super.finalize();

1st sentence:
"...from within the method that overrides it."
Now reads:
"...from within the class that overrides it."

protected checkRadius(double radius){
...
}

the method should be:

protected void checkRadius(double radius){
...
}

The line:
protected checkRadius(double radius) {
Now reads:
protected void checkRadius(double radius) {

"upper-left" now reads "upper-right" to correspond with the example

The line:
public setUpperRightCorner(double x, double y);
Now reads:
public void setUpperRightCorner(double x, double y);

Did read:
public interface SuperShape implements Positionable, Transformable {}

Now reads:
public interface SuperShape extends Positionable, Transformable {}

did reads:

public interface SuperShape implements Positionable, Transformable {}

now reads:

public interface SuperShape extends Positionable, Transformable {}

In the following lines:

// This method returns an Enumeration...
public java.util.Enumeration enumerate() ...

Moved the second line right two spaces so it lines up
under "//".

And in these lines:

// The constructor uses the private head field...
public Enumerator() ( current ...

Moved the second line right four spaces so it lines up
under "//".

"...code using the LinkedStack class..."
Now reads:
"...code (in a different package) using the LinkedStack class..."

The 4th line:
Linkable current; = head;
Now reads:
Linkable currrent;

The line:

t.getChars(0, 3, ca, 1); // Put 1st 4 chars of s into ca at position 2

Now reads:

t.getChars(0, 3, ca, 1); // Put 1st 3 chars of s into ca[1]-ca[3]

t1 = Object.toString(); // Convert objects to strings with toString()

now reads

t1 = object.toString(); // Convert objects to strings with toString()

The 3rd line:
short sh = Short.parseShort(sh);
Now reads:
short sh = Short.parseShort(s);

The statement "The valueOf() method can handle arbitrary bases" is incorrect--
it can only handle bases between Character.MIN_RADIX (==2) and
Character.MAX_RADIX (==36) inclusive.

// The valueOf() method can handle arbitrary bases

now reads

// The valueOf() method can handle arbitrary bases between 2 and 36

float f = generator.nextFloat(); // 0.0 <= d < 1.0

now reads:

float f = generator.nextFloat(); // 0.0 <= f < 1.0

config.getProperties("filterclass", // The property name
"com.davidflangan.filters.Default"); // A default

now reads

config.getProperty("filterclass", // The property name
"com.davidflanagan.filters.Default"); // A default

Also:

String classdir = config.getProperties("classpath");

now reads

String classdir = config.getProperty("classpath");

"import java.net.URLClassLoader;" now reads "import java.net.*;"

Also:

The line "Another technique:" was added after

} catch (Exception e) { /* Handle exceptions */ }

The code example is written:

Timer.schedule(displayTime, 0, 1000);

which is not correct. The line should be

timer.schedule(displayTime, 0, 1000);

to access the object "timer" and not the class "Timer".

Did read:
boolean keepRunning = true;
Now reads:
volatile boolean keepRunning = true;

did read:

boolean keepRunning = true;

now reads:

volatile boolean keepRunning = true;

sorter.join();

now reads

try { sorter.join(); } catch(InterruptedException e) {}

reads "When a thread calls the wait() method of an object, any locks the thread
holds are temporarily released, and the thread is added..."

import java.util.*;

was inserted.

public Complex add(Complex c1, Complex c2) {

now reads

public static Complex add(Complex c1, Complex c2) {

Did read:
% setenv JAVA_COMPILER NONE // Unix syntax

Now reads:
% setenv JAVA_COMPILER NONE // Unix csh syntax

{343} constants of class Double;
Did read:
public static final double MIN_VALUE;
Now reads:
public static final double MIN_VALUE; =4.9E-324

(added the value)

"boolean value" now reads "Boolean object."

Deleted the sentence that began "equals() tests whether" and ended
"byte-for-byte equivalence)."

3rd paragraph:
Deleted the first sentence and replaced it with:

The default implementation of the equals() method simply uses the ==
operator to test whether this object reference and the specified object
reference refer to the same object. Many subclasses override this method
to compare the individual fields of two distinct objects (i.e., they
override the method to test for the equivalence of distinct objects rather
than equality of object references).

INDEX:

* BufferedReader entry now refers to pages 283-284.

* Added a new entry for "Resources for further information"
under "ResourceBundle class."

"1.2" flags were added to the lines for the public constants ONE and ZERO.

In the fourth line down under the Set heading allAll(); now reads :

addAll().