Errata

Even simple arithmetic with small, byte-valued constants as follows
produces "Explicit cast needed to convert int to byte" errors:

byte b = 1 + 2;

This is not true in Java 1.1 and later.

greater than sign is now greater than or equals; that is,

int unsignedByte = signedByte >= 0 ? signedByte : 256 + signedByte;

performed on char literals (though not char variables) will overflow the
bounds of a char. Thus the paragraph beginning, "A char used
in arithmetic..." and the following code fragment and paragraph have been
changed to:

A char used in arithmetic is promoted to int. This presents the same
problems as it does for bytes. Admittedly, performing mathematical
operations on chars is a much less common thing to want to do than
performing them on bytes.

Example 2-1 now reads:

import java.io.*;

public class AsciiChart {

public static void main(String[] args) {

for (int i = 32; i < 127; i++) {
System.out.write(i);
// break line after every eight characters
if (i % 8 == 7) System.out.write('
');
else System.out.write(' ');
}
System.out.write('
');

}

}

the page is missing a closing }. It now reads:

try {
byte[] b = new byte[100];
int offset = 0;
while (offset < b.length) {
int a = System.in.available();
int bytesRead = System.in.read(b, offset, a);
if (bytesRead == -1) break; // end of stream
offset += bytesRead;
}
}
catch (IOException e) {
System.err.println("Couldn't read from System.in!");
}

the try block should say -
try {
copy(System.in, System.out);
}

(the line "copy(System.in, System.out);" was left out of the [1/02] printing)

In Example 4-1, the line which used to read:

System.err.println("Usage: java FileCopier file1 file2 ...");

Now reads:

System.err.println("Usage: java FileTyper file1 file2 ...");

if (args.length < 1) {
System.err.println("Usage: java FileDumper [-ahd] file1 file2...");
}

to

if (args.length < 1) {
System.err.println("Usage: java FileDumper [-ahd] file1 file2...");
return;
}

Socket s = s.accept();

to

Socket s = ss.accept();

in both examples.

else if (b == 10 || b == 13 || b == 9) return b;

to

else if (b == 10 || b == 13 || b == 9 || b == -1) return b;

Also changed

if (data[i] == 10 || data[i] == 13 || data[i] == 9) ;

to

if (data[i] == 10 || data[i] == 13 || data[i] == 9 || data[i] == -1) ;

In Example 6-12, the line which used to read:

System.err.println("Usage: java FileDumper [-ahd] file1 file2...");

Now reads:

System.err.println("Usage: java FileDumper2 [-ahd] file1 file2...");

if (args.length < 1) {
System.err.println("Usage: java FileDumper [-ahd] file1 file2...");
}

now reads:

if (args.length < 1) {
System.err.println("Usage: java FileDumper2 [-ahd] file1 file2...");
return;
}

(This is a correction to a previous correction.)

int offset = 0;
while (true){
int bytesRead = in.read(data, offset, data.length - offset);
offset += bytesRead;
if (bytesRead == -1 || offset >= data.length) break;
}

To fix them in Example 7-8 changed the writeUTF() method and
preceding comments as follows:

/**
* Writes a string of no more than 65,535 characters
* to the underlying output stream using UTF-8
* encoding. This method first writes a two byte short
* in <b>big</b> endian order as required by the
* UTF-8 specification. This gives the number of bytes in the
* UTF-8 encoded version of the string, not the number of characters
* in the string. Next each character of the string is written
* using the UTF-8 encoding for the character.
*
* @param s the string to be written.
* @exception UTFDataFormatException if the string is longer than
* 65,535 characters.
* @exception IOException if the underlying stream throws an IOException.
*/
public void writeUTF(String s) throws IOException {

int numchars = s.length();
int numbytes = 0;

for (int i = 0 ; i < numchars ; i++) {
int c = s.charAt(i);
if ((c >= 0x0001) && (c <= 0x007F)) numbytes++;
else if (c > 0x07FF) numbytes += 3;
else numbytes += 2;
}

if (numbytes > 65535) throw new UTFDataFormatException();

out.write((numbytes >>> 8) & 0xFF);
out.write(numbytes & 0xFF);
for (int i = 0 ; i < numchars ; i++) {
int c = s.charAt(i);
if ((c >= 0x0001) && (c <= 0x007F)) {
out.write(c);
}
else if (c > 0x07FF) {
out.write(0xE0 | ((c >> 12) & 0x0F));
out.write(0x80 | ((c >> 6) & 0x3F));
out.write(0x80 | (c & 0x3F));
written += 2;
}
else {
out.write(0xC0 | ((c >> 6) & 0x1F));
out.write(0x80 | (c & 0x3F));
written += 1;
}
}

written += numchars + 2;

}

The readShort() method near the bottom of the page now reads:

public short readShort() throws IOException {

int byte1 = in.read();
int byte2 = in.read();
// only need to test last byte read
// if byte1 is -1 so is byte2
if (byte2 == -1) throw new EOFException();
return (short) ((byte2 << 8) + byte1);

}

top of the page:

public int readUnsignedShort() throws IOException {

int byte1 = in.read();
int byte2 = in.read();
if (byte2 == -1) throw new EOFException();
return (byte2 << 8) + byte1;

}

version:

/**
* Reads a string of no more than 65,535 characters
* from the underlying input stream using UTF-8
* encoding. This method first reads a two byte short
* in <b>big</b> endian order as required by the
* UTF-8 specification. This gives the number of bytes in
* the UTF-8 encoded version of the string.
* Next this many bytes are read and decoded as UTF-8
* encoded characters.
*
* @return the decoded string
* @exception UTFDataFormatException if the string cannot be decoded
* @exception IOException if the underlying stream throws an IOException.
*/
public String readUTF() throws IOException {

int byte1 = in.read();
int byte2 = in.read();
if (byte2 == -1) throw new EOFException();
int numbytes = (byte1 << 8) + byte2;

char result[] = new char[numbytes];
int numread = 0;
int numchars = 0;

while (numread < numbytes) {

int c1 = readUnsignedByte();

int c2, c3;

// look at the first four bits of c1 to determine how many
// bytes in this char
int test = c1 >> 4;
if (test < 8) { // one byte
numread++;
result[numchars++] = (char) c1;
}
else if (test == 12 || test == 13) { // two bytes
numread += 2;
if (numread > numbytes) throw new UTFDataFormatException();
c2 = readUnsignedByte();
if ((c2 & 0xC0) != 0x80) throw new UTFDataFormatException();
result[numchars++] = (char) (((c1 & 0x1F) << 6) | (c2 & 0x3F));
}
else if (test == 14) { // three bytes
numread += 3;
if (numread > numbytes) throw new UTFDataFormatException();
c2 = readUnsignedByte();
c3 = readUnsignedByte();
if (((c2 & 0xC0) != 0x80) || ((c3 & 0xC0) != 0x80)) {
throw new UTFDataFormatException();
}
result[numchars++] = (char)
(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
}
else { // malformed
throw new UTFDataFormatException();
}

} // end while

return new String(result, 0, numchars);

}

In Example 7-10, the line which used to read:

"Usage: java FileDumper2 [-ahdsilfx] [-little] file1 file2...");

Now reads:

"Usage: java FileDumper3 [-ahdsilfx] [-little] file1 file2...");

instead of r < 1024. The entire fragment now reads:

"ByteArrayOutputStream bos = new ByteArrayOutputStream(1024);
DataOutputStream dos = new DataOutputStream(bos);
for (int r = 1; r <= 1024; r++) {
dos.writeDouble(r * 2.0 * Math.PI);
}"

In the third line of code at the top of the page, it used to read:

pin.connect(pos)

It now reads:

pin.connect(pout)

Right before the Inflating Data section, the line used to read:

System.out.println((1.0 - def.getTotalOut()/def.getTotalIn())
*100.0 + '% saved')

Now reads:

System.out.println((1.0 - def.getTotalOut()/def.getTotalIn())
*100.0 + "% saved")

That is, the single quotes around % saved are now double quotes.

correctly due to integer (as opposed to floating
point) division. The corrected lines look like this:

else if (method == ZipEntry.DEFLATED) {
System.out.println(name + " was deflated at " + lastModified);
System.out.println("from " + uncompressedSize + " bytes to "
+ compressedSize + " bytes, a savings of "
+ (100.0 - 100.0*compressedSize/uncompressedSize) + "%");

}
else {
System.out.println(name
+ " was compressed using an unrecognized method at "
+ lastModified);
System.out.println("from " + uncompressedSize + " bytes to "
+ compressedSize + " bytes, a savings of "
+ (100.0 - 100.0*compressedSize/uncompressedSize) + "%");
}

InetAddress.getHostByName("sunsite.unc.edu")

Now reads:

InetAddress.getByName("sunsite.unc.edu").

The whole code fragment now reads:

try {
ServerSocket httpd = new ServerSocket(5776, 100,
InetAddress.getByName("sunsite.unc.edu"));
}
catch (IOException e) {
System.err.println(e);
}

"the byte 3 (binary 00000011)"

has been changed to:

"the byte 7 (binary 00000111)".

Although 3 is an odd number,
it actually does have an even number of one bits.

The fix is the same too. Changed the else and else if blocks as follows:

else if (method == ZipEntry.DEFLATED) {
System.out.println(name + " was deflated at " + lastModified);
System.out.println("from " + uncompressedSize + " bytes to "
+ compressedSize + " bytes, a savings of "
+ (100.0 - 100.0*compressedSize/uncompressedSize) + "%");
}
else {
System.out.println(name
+ " was compressed using an unrecognized method at "
+ lastModified);
System.out.println("from " + uncompressedSize + " bytes to "
+ compressedSize + " bytes, a savings of "
+ (100.0 - 100.0*compressedSize/uncompressedSize) + "%");
}

"Usage: java FileDumper2 [-ahdsilfx] [-little] [-gzip|-deflated] file1...");

to

"Usage: java FileDumper4 [-ahdsilfx] [-little] [-gzip|-deflated] file1...");

The last line of Example 10-1 now reads:

System.out.println(new BigInteger(result));

The output now looks like this:

% java URLDigest http://www.oreilly.com
-24 86 -50 -110 47 -95 12 -95 -36 38 -110 -10 -53 -33 -80 -101 -33 74 -76 41
-135079919537261070114700613868500318745039031255

incorrect. That section was replaced with the following:

"In general, digest algorithms cannot finish the calculation
and return the digest until the last byte is received. When you
are ready to finish the calculation and receive the digest, you
invoke one of three overloaded digest() methods:

public byte[] digest()
public byte[] digest(byte[] input)
public int digest(byte[] output, int offset, int length)
throws DigestException

The first digest() method simply returns the digest as an array
of bytes based on the data that was already passed in through
update(). For example:

byte[] result = sha.digest();

The second digest() method receives one last chunk of data in
the input array, then returns the digest. The third digest()
method calculates the digest and places it in the array output
beginning at offset and continuing for at most length bytes,
then returns the number of bytes in the digest. If there are more
than length bytes in the digest a DigestException is thrown. After
you've called digest(), the MessageDigest object is reset so it
can be reused to calculate a new digest.

now reads "throw new NotSerializableException()" (both times):

private void writeObject(ObjectOutputStream out) throws IOException {
throw new NotSerializableException();
}

private void readObject(ObjectInputStream in) throws IOException {
throw new NotSerializableException();
}

doesn't really do what it claims to do. Here's a fixed version:

import java.util.*;
import java.io.*;

public class Person implements Serializable, ObjectInputValidation {

static Hashtable thePeople = new Hashtable();

String name;
String ss;

public Person(String name, String ss) {

this.name = name;
this.ss = ss;
thePeople.put(ss, name);

}

private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException {

in.registerValidation(this, 5);
in.defaultReadObject();

}

public void validateObject() throws InvalidObjectException {

if (thePeople.containsKey(this.ss)) {
throw new InvalidObjectException(this.name + " already exists");
}
else {
thePeople.put(this.ss, this.name);
}

}

public String toString() {
return this.name + " " + this.ss;
}

}

% java -classpath /home/users/bfrank Trivia

instead of

% java /home/users/bfrank Trivia

The second command line with the relative path is now:

% java -classpath ../bfrank Trivia

instead of

% java ../bfrank/Trivia

In the second to last paragraph, used to read:

"%202.0% 20Early%20Access%"

Now reads:

"%202.0%20Early%20Access%"

for (int i = Character.MIN_VALUE; i < Character.MAX_VALUE; i++) {

Now reads:

for (int i = Character.MIN_VALUE; i <= Character.MAX_VALUE; i++) {

That is, the less than is now a less-than-or-equal-to.

catch (IOexception e) {System.err.println(e);}

to

catch (IOException e) { System.err.println(e); }

public static final NumberFormat getpercentInstance()

to

public static final NumberFormat getPercentInstance()

(that is, an upper case P in percent)

handles all possible exponents. The corrected version reads:

public Number parse(String text, ParsePosition parsePosition) {

int oldIndex = parsePosition.getIndex();

try {
double result = parser.parse(text, parsePosition).doubleValue();
int eposition = text.toUpperCase().indexOf('E');
if (eposition != -1) {
// advance past the E
parsePosition.setIndex(eposition + 1);
// ignore a + sign
if (text.charAt(parsePosition.getIndex()) == '+') {
parsePosition.setIndex(parsePosition.getIndex() + 1);
}
int exponent = parser.parse(text, parsePosition).intValue();
result *= Math.pow(10, exponent);
}
return new Double(result);
}
catch (Exception e) {
parsePosition.setIndex(oldIndex);
return null;
}

}

now reads:

public static void testProperties(CommPort thePort) {

try {
thePort.enableReceiveThreshold(10);
System.out.println("Receive threshold supported");
}
catch (UnsupportedCommOperationException e) {
System.out.println("Receive threshold not supported");
}

try {
thePort.enableReceiveTimeout(10);
System.out.println("Receive timeout supported");
}
catch (UnsupportedCommOperationException e) {
System.out.println("Receive timeout not supported");
}

try {
thePort.enableReceiveFraming(10);
System.out.println("Receive framing supported");
}
catch (UnsupportedCommOperationException e) {
System.out.println("Receive framing not supported");
}

}