Back Matter

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Appendix A: Solutions to Exercises

Each of Chapters 1 through 17 closes with an “Exercises” section that tests your understanding of the chapter’s material. Solutions to these exercises are presented in this appendix.

Chapter 1: Getting Started with Java

1.
Java is a language and a platform. The language is partly patterned after the C and C++ languages to shorten the learning curve for C/C++ developers. The platform consists of a virtual machine and an associated execution environment.
2.
A virtual machine is a software-based processor that presents its own instruction set.
3.
The purpose of the Java compiler is to translate source code into instructions (and associated data) that are executed by the virtual machine.
4.
The answer is true: a class file’s instructions are commonly referred to as bytecode.
5.
When the JVM’s interpreter learns that a sequence of bytecode instructions is being executed repeatedly, it informs the JVM’s just-in-time (JIT) compiler to compile these instructions into native code.
6.
The Java platform promotes portability by providing an abstraction over the underlying platform. As a result, the same bytecode runs unchanged on Windows-based, Linux-based, Mac OS X–based, and other platforms.
7.
The Java platform promotes security by doing its best to provide a secure environment in which code executes. It accomplishes this task in part by using a bytecode verifier to make sure that the class file’s bytecode is valid.
8.
The answer is false: Java SE is the platform for developing applications and applets.
9.
The JDK’s javac tool is used to compile Java source code.
10.
The JDK’s java tool is used to run Java applications.
11.
Standard I/O is a mechanism consisting of standard input, standard output, and standard error that makes it possible to read text from different sources (keyboard or file), write nonerror text to different destinations (screen or file), and write error text to different destinations (screen or file).
12.
You specify the main() method’s header as public static void main(String[] args).
13.
An IDE is a development framework consisting of a project manager for managing a project’s files, a text editor for entering and editing source code, a debugger for locating bugs, and other features. The IDE that Google supports for developing Android apps is Android Studio.
14.
Android is Google’s software stack for mobile devices. This stack consists of apps (such as Browser and Contacts), a virtual machine in which apps run, middleware (software that sits on top of the operating system and provides various services to the virtual machine and its apps), and a Linux-based operating system.

Chapter 2: Learning Language Fundamentals

1.
Unicode is a computing industry standard for consistently encoding, representing, and handling text that’s expressed in most of the world’s writing systems.
2.
A comment is a language feature for embedding documentation in source code.
3.
The three kinds of comments that Java supports are single-line, multiline, and Javadoc.
4.
An identifier is a language feature that consists of letters (A–Z, a–z), digits (0–9), and the underscore (others are possible, but not used commonly or impractical). This name must begin with a letter or an underscore and cannot contain spaces.
5.
The answer is false: Java is a case-sensitive language.
6.
A type is a language feature that identifies a set of values (and their representation in memory) and a set of operations that transform these values into other values of that set.
7.
A primitive type is a type that’s defined by the language and whose values are not objects.
8.
Java supports the Boolean, character, byte integer, short integer, integer, long integer, floating-point, and double precision floating-point primitive types.
9.
An object type is a type that’s defined by the developer using a class, an interface, an enum, or an annotation type and whose values are objects.
10.
An array type is a special reference type that signifies an array, a region of memory that stores values in equal-size and contiguous slots, which are commonly referred to as elements.
11.
A variable is a named memory location that stores some type of value.
12.
An expression is a combination of literals, variable names, method calls, and operators. At runtime, it evaluates to a value whose type is referred to as the expression’s type.
13.
The two expression categories are simple expression and compound expression.
14.
A literal is a value specified verbatim.
15.
String literal "The quick brown fox jumps over the lazy dog." is illegal because, unlike ", j and (a backslash followed by a space character) are not valid escape sequences. To make this string literal legal, you must escape these backslashes, as in "The quick brown fox \jumps\ over the lazy dog.".
16.
An operator is a sequence of instructions symbolically represented in source code.
17.
The difference between a prefix operator and a postfix operator is that a prefix operator precedes its operand and a postfix operator trails its operand.
18.
The purpose of the cast operator is to convert from one type to another type. For example, you can use this operator to convert from floating-point type to 32-bit integer type.
19.
Precedence refers to an operator’s level of importance.
20.
The answer is true: most of Java’s operators are left-to-right associative.
21.
A statement is a language feature that assigns a value to a variable, controls a program’s flow by making a decision and/or repeatedly executing another statement, or performs another task.
22.
The difference between the while and do-while statements is that the while statement evaluates its Boolean expression at the top of the loop, whereas the do-while statement evaluates its Boolean expression at the bottom of the loop. As a result, while executes zero or more times, whereas do-while executes one or more times.
23.
The difference between the break and continue statements is that break transfers execution to the first statement following a switch statement or a loop, whereas continue skips the remainder of the current loop iteration, reevaluates the loop’s Boolean expression, and performs another iteration (when true) or terminates the loop (when false).
24.
Listing A-1 presents the Compass application that was called for in Chapter 2.

public class Compass {

public static void main(String[] args){

int direction = 1;

switch (direction) {

case 0: System.out.println("You are travelling north."); break;

case 1: System.out.println("You are travelling east."); break;

case 2: System.out.println("You are travelling south."); break;

case 3: System.out.println("You are travelling west."); break;

default: System.out.println("You are lost.");

}

Listing A-1

Finding a Direction in Which to Travel

25.
Listing A-2 presents the Triangle application that was called for in Chapter 2.

public class Triangle {

public static void main(String[] args){

for (int row = 1; row < 20; row += 2){

for (int col = 0; col < 19 - row / 2; col++)

System.out.print(" ");

for (int col = 0; col < row; col++)

System.out.print("*");

System.out.print(' ');

}

Listing A-2

Printing a Triangle of Asterisks

Chapter 3: Discovering Classes and Objects

1.
A class is a container for housing an application and is also a template for manufacturing objects.
2.
You declare a class by minimally specifying reserved word class followed by a name that identifies the class (so that it can be referred to from elsewhere in the source code), followed by a body. The body starts with an open brace character ({) and ends with a close brace (}). Sandwiched between these delimiters are various kinds of member declarations.
3.
The answer is false: you can declare only one public class in a source file.
4.
An object is an instance of a class.
5.
You obtain an object by using the new operator to allocate memory to store a class instance and a constructor to initialize this instance.
6.
A constructor is a block of code for constructing an object by initializing it in some manner.
7.
The answer is true: Java creates a default noargument constructor when a class declares no constructors.
8.
A parameter list is a round bracket–delimited and comma-separated list of zero or more parameter declarations. A parameter is a constructor or method variable that receives an expression value passed to the constructor or method when it’s called.
9.
An argument list is a round bracket–delimited and comma-separated list of zero or more expressions. An argument is one of these expressions whose value is passed to the corresponding parameter when a constructor or method is called.
10.
The answer is false: you invoke another constructor by specifying this followed by an argument list.
11.
Arity is the number of arguments passed to a constructor or method or the number of operator operands.
12.
A local variable is a variable that’s declared in a constructor or method and isn’t a member of the constructor or method parameter list.
13.
Lifetime is a property of a variable that determines how long the variable exists. For example, parameters come into existence when a constructor or method is called and are destroyed when the constructor or method finishes. Similarly, an instance field comes into existence when an object is created and is destroyed when the object is garbage collected.
14.
Scope is a property of a variable that determines how accessible the variable is to code. For example, a parameter can be accessed only by the code within the constructor or method in which the parameter is declared.
15.
Encapsulation refers to the merging of state and behaviors into a single source code entity. Instead of separating state and behaviors, which is done in structured programs, state and behaviors are combined into classes and objects, which are the focus of object-based programs. For example, where a structured program makes you think in terms of separate balance state and deposit/withdraw behaviors, an object-based program makes you think in terms of bank accounts, which unite balance state with deposit/withdraw behaviors through encapsulation.
16.
A field is a variable declared within a class body.
17.
The difference between an instance field and a class field is that an instance field describes some attribute of the real-world entity that an object is modeling and is unique to each object, and a class field identifies some data item that’s shared by all objects.
18.
A blank final is a read-only instance field. It differs from a true constant in that there are multiple copies of blank finals (one per object) and only one true constant (one per class).
19.
You prevent a field from being shadowed by changing the name of a same-named local variable or parameter, or by qualifying the local variable’s name or parameter’s name with this or the class name followed by the member access operator.
20.
A method is a named block of code declared within a class body.
21.
The difference between an instance method and a class method is that an instance method describes some behavior of the real-world entity that an object is modeling and can access a specific object’s state, whereas a class method identifies some behavior that’s common to all objects and cannot access a specific object’s state.
22.
Recursion is the act of a method invoking itself.
23.
You overload a method by introducing a method with the same name as an existing method but with a different parameter list into the same class.
24.
A class initializer is a static-prefixed block that’s introduced into a class body. An instance initializer is a block that’s introduced into a class body as opposed to being introduced as the body of a method or a constructor.
25.
A garbage collector is code that runs in the background and occasionally checks for unreferenced objects.
26.
The answer is false: String[] letters = new String[2] { "A", "B" }; is incorrect syntax. Remove the 2 from between the square brackets to make it correct.
27.
A ragged array is a two-dimensional array in which each row can have a different number of columns.
28.
Listing A-3 presents the Image application that was called for in Chapter 3.

public class Image {

public Image() {

System.out.println("Image() called");

}

public Image(String filename) {

this(filename, null);

System.out.println("Image(String filename) called");

}

public Image(String filename, String imageType) {

System.out.println("Image(String filename, String imageType) called");

if (filename != null){

System.out.println("reading " + filename);

if (imageType != null)

System.out.println("interpreting " + filename + " as storing a " +

imageType + " image");

}

// Perform other initialization here.

}

public static void main(String[] args){

Image image = new Image();

System.out.println();

image = new Image("image.png");

System.out.println();

image = new Image("image.png", "PNG");

}

Listing A-3

Testing the Image Class

29.
Listing A-4 presents the Conversions application that was called for in Chapter 3.

public class Conversions {

public static double c2f(double degrees) {

return degrees * 9.0 / 5.0 + 32;

}

public static double f2c(double degrees) {

return (degrees - 32) * 5.0 / 9.0;

}

public static void main(String[] args) {

System.out.println("Fahrenheit equivalent of 100 degrees Celsius is " +

Conversions.c2f(100));

System.out.println("Celsius equivalent of 98.6 degrees Fahrenheit is " +

Conversions.f2c(98.6));

System.out.println("Celsius equivalent of 32 degrees Fahrenheit is " +

f2c(32));

}

Listing A-4

Converting Between Degrees Fahrenheit and Degrees Celsius

30.
Listing A-5 presents the Utilities application that was called for in Chapter 3.

public class Utilities {

public static int factorial1(int n) {

int product = 1;

for (int i = 2; i <= n; i++)

product *= i;

return product;

}

public static int factorial2(int n) {

if (n == 0 || n == 1)

return 1; // base problem

else

return n * factorial2(n - 1);

}

public static double sum(double... values) {

int total = 0;

for (int i = 0; i < values.length; i++)

total += values[i];

return total;

}

public static void main(String[] args) {

System.out.println(factorial1(4));

System.out.println(factorial2(4));

System.out.println(factorial2(0));

System.out.println(factorial2(1));

System.out.println(sum(10.0, 20.0));

System.out.println(sum(30.0, 40.0, 50.0));

}

Listing A-5

Calculating Factorials and Summing a Variable Number of Double Precision Floating-Point Values

31.
Listing A-6 presents the GCD application that was called for in Chapter 3.

public class GCD {

public static int gcd(int a, int b) {

// The greatest common divisor is the largest positive integer that

// divides evenly into two positive integers a and b. For example,

// GCD(12, 18) is 6.

if (b == 0) // Base problem

return a;

else

return gcd(b, a % b);

}

public static void main(String[] args) {

System.out.println(gcd(12, 18));

}

Listing A-6

Recursively Calculating the Greatest Common Divisor

32.
Listing A-7 presents the Book application that was called for in Chapter 3.

public class Book {

private String name;

private String author;

private String isbn;

public Book(String name, String author, String isbn) {

this.name = name;

this.author = author;

this.isbn = isbn;

}

public String getName(){

return name;

}

public String getAuthor(){

return author;

}

public String getISBN(){

return isbn;

}

public static void main(String[] args) {

Book[] books = new Book[] {

new Book("Jane Eyre",

"Charlotte Brontë",

"0895772000"),

new Book("A Kick in the Seat of the Pants",

"Roger von Oech",

"0060155280"),

new Book("The Prince and the Pilgrim",

"Mary Stewart",

"0340649925")

};

for (int i = 0; i < books.length; i++)

System.out.println(books[i].getName() + " - " +

books[i].getAuthor() + " - " +

books[i].getISBN());

}

Listing A-7

Building a Library of Books

Chapter 4: Discovering Inheritance, Polymorphism, and Interfaces

1.
Implementation inheritance is inheritance through class extension.
2.
Java supports implementation inheritance by providing reserved word extends.
3.
A subclass can have only one superclass because Java doesn’t support multiple implementation inheritance.
4.
You prevent a class from being subclassed by declaring the class final.
5.
The answer is false: the super() call can only appear in a constructor.
6.
If a superclass declares a constructor with one or more parameters, and if a subclass constructor doesn’t use super() to call that constructor, the compiler reports an error because the subclass constructor attempts to call a nonexistent noargument constructor in the superclass. (When a class doesn’t declare any constructors, the compiler creates a constructor with no parameters, a noargument constructor, for that class. Therefore, if the superclass didn’t declare any constructors, a noargument constructor would be created for the superclass. Continuing, if the subclass constructor didn’t use super() to call the superclass constructor, the compiler would insert the call and there would be no error.)
7.
An immutable class is a class whose instances cannot be modified.
8.
The answer is false: a class cannot inherit constructors.
9.
Overriding a method means replacing an inherited method with another method that provides the same signature and the same return type but provides a new implementation.
10.
To call a superclass method from its overriding subclass method, prefix the superclass method name with reserved word super and the member access operator in the method call.
11.
You prevent a method from being overridden by declaring the method final.
12.
You cannot make an overriding subclass method less accessible than the superclass method it is overriding because subtype polymorphism would not work properly if subclass methods could be made less accessible. Suppose you upcast a subclass instance to superclass type by assigning the instance’s reference to a variable of superclass type. Now suppose you specify a superclass method call on the variable. If this method is overridden by the subclass, the subclass version of the method is called. However, if access to the subclass’s overriding method’s access could be made private, calling this method would break encapsulation; private methods cannot be called directly from outside of their class.
13.
You tell the compiler that a method overrides another method by prefixing the overriding method’s header with the @Override annotation.
14.
Java doesn’t support multiple implementation inheritance because this form of inheritance can lead to ambiguities.
15.
The name of Java’s ultimate superclass is Object. This class is located in the java.lang package.
16.
The purpose of the clone() method is to duplicate an object without calling a constructor.
17.
Object’s clone() method throws CloneNotSupportedException when the class whose instance is to be shallowly cloned doesn’t implement the Cloneable interface.
18.
The == operator cannot be used to determine if two objects are logically equivalent because this operator only compares object references and not the contents of these objects.
19.
Object’s equals() method compares the current object’s this reference to the reference passed as an argument to this method. (When we refer to Object’s equals() method, we are referring to the equals() method in the Object class.)
20.
You can optimize a time-consuming equals() method by first using == to determine if this method’s reference argument identifies the current object (which is represented in source code via reserved word this).
21.
The purpose of the finalize() method is to provide a safety net for calling an object’s cleanup method in case that method isn’t called.
22.
You shouldn’t rely on finalize() for closing open files because file descriptors are a limited resource and an application might not be able to open additional files until finalize() is called, and this method might be called infrequently (or perhaps not at all).
23.
A hash code is a number value that results from applying a mathematical function to a potentially large amount of data.
24.
The answer is true: you should override the hashCode() method whenever you override the equals() method.
25.
Object’s toString() method returns a string representation of the current object that consists of the object’s class name, followed by the @ symbol, followed by a hexadecimal representation of the object’s hash code. (When we refer to Object’s toString() method, we’re referring to the toString() method in the Object class.)
26.
You should override toString() to provide a concise but meaningful description of the object to facilitate debugging via System.out.println() method calls. It’s more informative for toString() to reveal object state than to reveal a class name, followed by the @ symbol, followed by a hexadecimal representation of the object’s hash code.
27.
Composition is a way to reuse code by composing classes out of other classes based on a “has-a” relationship between them.
28.
The answer is false: composition is used to describe “has-a” relationships and implementation inheritance is used to describe “is-a” relationships.
29.
Subtype polymorphism is a kind of polymorphism where a subtype instance appears in a supertype context, and executing a supertype operation on the subtype instance results in the subtype’s version of that operation executing.
30.
Subtype polymorphism is accomplished by upcasting the subtype instance to its supertype, by assigning the instance’s reference to a variable of that type, and, via this variable, calling a superclass method that’s been overridden in the subclass.
31.
You would use abstract classes and abstract methods to describe generic concepts (such as shape, animal, or vehicle) and generic operations (such as drawing a generic shape). Abstract classes cannot be instantiated and abstract methods cannot be called because they have no code bodies.
32.
An abstract class can contain concrete methods.
33.
The purpose of downcasting is to access subtype features. For example, you would downcast a Point variable that contains a Circle instance reference to the Circle type so that you can call Circle’s getRadius() method on the instance.
34.
Two forms of RTTI are the virtual machine verifying that a cast is legal and using the instanceof operator to determine whether or not an instance is a member of a type.
35.
A covariant return type is a method return type that, in the superclass’s method declaration, is the supertype of the return type in the subclass’s overriding method declaration.
36.
You formally declare an interface by specifying at least reserved word interface, followed by a name, followed by a brace-delimited body of method headers (constants are also allowed, but they are discouraged).
37.
A marker interface is an interface that declares no members.
38.
Interface inheritance is inheritance through interface implementation or interface extension.
39.
You implement an interface by appending an implements clause, consisting of reserved word implements followed by the interface’s name, to a class header and by overriding the interface’s method headers in the class.
40.
You form a hierarchy of interfaces by appending reserved word extends followed by an interface name to an interface header.
41.
Java’s interfaces feature is so important because it gives developers the utmost flexibility in designing their applications.
42.
Interfaces and abstract classes describe abstract types.
43.
Interfaces and abstract classes differ in that interfaces can only declare abstract methods and constants and can be implemented by any class in any class hierarchy. In contrast, abstract classes can declare constants and nonconstant fields, can declare abstract and concrete methods, and can only appear in the upper levels of class hierarchies, where they’re used to describe abstract concepts and behaviors.
44.
Listings A-8 through A-14 declare the Animal, Bird, Fish, AmericanRobin, DomesticCanary, RainbowTrout, and SockeyeSalmon classes that were called for in Chapter 4.

public abstract class Animal {

private String kind;

private String appearance;

public Animal(String kind, String appearance) {

this.kind = kind;

this.appearance = appearance;

}

public abstract void eat();

public abstract void move();

@Override

public String toString() {

return kind + " -- " + appearance;

}

Listing A-8

The Animal Class Abstracting over Birds and Fish (and Other Organisms)

public abstract class Bird extends Animal {

public Bird(String kind, String appearance){

super(kind, appearance);

}

@Override

public void eat() {

System.out.println("eats seeds and insects");

}

@Override

public void move() {

System.out.println("flies through the air");

}

Listing A-9

The Bird Class Abstracting over American Robins, Domestic Canaries, and Other Kinds of Birds

public abstract class Fish extends Animal {

public Fish(String kind, String appearance) {

super(kind, appearance);

}

@Override

public void eat() {

System.out.println("eats krill, algae, and insects");

}

@Override

public void move() {

System.out.println("swims through the water");

}

Listing A-10

The Fish Class Abstracting over Rainbow Trout, Sockeye Salmon, and Other Kinds of Fish

public class AmericanRobin extends Bird {

public AmericanRobin() {

super("americanrobin", "red breast");

}

Listing A-11

The AmericanRobin Class Denoting a Bird with a Red Breast

public class DomesticCanary extends Bird {

public DomesticCanary() {

super("domestic canary", "yellow, orange, black, brown, white, red");

}

Listing A-12

The DomesticCanary Class Denoting a Bird of Various Colors

public class RainbowTrout extends Fish {

public RainbowTrout() {

super("rainbowtrout", "bands of brilliant speckled multicolored " +

"stripes running nearly the whole length of its body");

}

Listing A-13

The RainbowTrout Class Denoting a Rainbow-Colored Fish

public class SockeyeSalmon extends Fish {

public SockeyeSalmon() {

super("sockeyesalmon", "bright red with a green head");

}

Listing A-14

The SockeyeSalmon Class Denoting a Red-and-Green Fish

45.
Listing A-15 declares the Animals class that was called for in Chapter 4.

public class Animals {

public static void main(String[] args) {

Animal[] animals = { new AmericanRobin(), new RainbowTrout(),

new DomesticCanary(), new SockeyeSalmon() };

for (int i = 0; i < animals.length; i++) {

System.out.println(animals[i]);

animals[i].eat();

animals[i].move();

System.out.println();

}

Listing A-15

The Animals Class Letting Animals Eat and Move

46.
Listings A-16 through A-18 declare the Countable interface, the modified Animal class, and the modified Animals class that were called for in Chapter 4.

public interface Countable {

String getID();

}

Listing A-16

The Countable Interface for Use in Taking a Census of Animals

public abstract class Animal implements Countable {

private String kind;

private String appearance;

public Animal(String kind, String appearance) {

this.kind = kind;

this.appearance = appearance;

}

public abstract void eat();

public abstract void move();

@Override

public String toString() {

return kind + " -- " + appearance;

}

@Override

public String getID() {

return kind;

}

Listing A-17

The Refactored Animal Class for Help in Census Taking

public class Animals {

public static void main(String[] args) {

Animal[] animals = { new AmericanRobin(), new RainbowTrout(),

new DomesticCanary(), new SockeyeSalmon(),

new RainbowTrout(), new AmericanRobin() };

for (int i = 0; i < animals.length; i++) {

System.out.println(animals[i]);

animals[i].eat();

animals[i].move();

System.out.println();

}

Census census = new Census();

Countable[] countables = (Countable[]) animals;

for (int i = 0; i < countables.length; i++)

census.update(countables[i].getID());

for (int i = 0; i < Census.SIZE; i++)

System.out.println(census.get(i));

}

Listing A-18

The Modified Animals Class for Carrying Out the Census

Chapter 5: Mastering Advanced Language Features, Part 1

1.
A nested class is a class that’s declared as a member of another class or scope.
2.
The four kinds of nested classes are static member classes, nonstatic member classes, anonymous classes, and local classes.
3.
Nonstatic member classes, anonymous classes, and local classes are also known as inner classes.
4.
The answer is false: a static member class doesn’t have an enclosing instance.
5.
You instantiate a nonstatic member class from beyond its enclosing class by first instantiating the enclosing class and then prefixing the new operator with the enclosing class instance as you instantiate the enclosed class. For example, new EnclosingClass().new EnclosedClass().
6.
It’s necessary to declare local variables and parameters final when they are being accessed by an instance of an anonymous class or a local class.
7.
The answer is true: an interface can be declared within a class or within another interface.
8.
A package is a unique namespace that can contain a combination of top-level classes, other top-level types, and subpackages.
9.
You ensure that package names are unique by specifying your reversed Internet domain name as the top-level package name.
10.
A package statement is a statement that identifies the package in which a source file’s types are located.
11.
The answer is false: you cannot specify multiple package statements in a source file.
12.
An import statement is a statement that imports types from a package by telling the compiler where to look for unqualified type names during compilation.
13.
You indicate that you want to import multiple types via a single import statement by specifying the wildcard character (*).
14.
During a runtime search, the virtual machine reports a “no class definition found” error when it cannot find a class file.
15.
You specify the user classpath to the virtual machine via the -classpath (or -cp) option used to start the virtual machine or, when not present, the CLASSPATH environment variable.
16.
A static import statement is a version of the import statement that lets you import a class’s static members so that you don’t have to qualify them with their class names.
17.
You specify a static import statement as import, followed by static, followed by a member access operator–separated list of package and subpackage names, followed by the member access operator, followed by a class’s name, followed by the member access operator, followed by a single static member name or the asterisk wildcard, for example, import static java.lang.Math.cos; (import the cos() static method from the Math class).
18.
An exception is a divergence from an application’s normal behavior.
19.
Objects are superior to error codes for representing exceptions because error code Boolean or integer values are less meaningful than object names and because objects can contain information about what led to the exception. These details can be helpful to a suitable workaround. Furthermore, error codes are easy to ignore.
20.
A throwable is an instance of Throwable or one of its subclasses.
21.
Exception describes exceptions that result from external factors (such as not being able to open a file) and from flawed code (such as passing an illegal argument to a method). Error describes virtual machine–oriented exceptions such as running out of memory or being unable to load a class file.
22.
A checked exception is an exception that represents a problem with the possibility of recovery and for which the developer must provide a workaround.
23.
A runtime exception is an exception that represents a coding mistake.
24.
You would introduce your own exception class when no existing exception class in the standard class library meets your needs.
25.
The answer is false: you use a throws clause to identify exceptions that are thrown from a method by appending this clause to a method’s header.
26.
The purpose of a try statement is to provide a scope (via its brace-delimited body) in which to present code that can throw exceptions. The purpose of a catch block is to receive a thrown exception and provide code (via its brace-delimited body) that handles that exception by providing a workaround.
27.
The purpose of a finally block is to provide cleanup code that’s executed whether an exception is thrown or not.
28.
Listing A-19 presents the G2D class that was called for in Chapter 5.

public class G2D {

private Matrix xform;

public G2D(){

xform = new Matrix();

xform.a = 1.0;

xform.e = 1.0;

xform.i = 1.0;

}

private class Matrix {

double a, b, c;

double d, e, f;

double g, h, i;

}

Listing A-19

The G2D Class with Its Matrix Nonstatic Member Class

29.
To extend the logging package (presented in Chapter 5’s discussion of packages) to support a null device in which messages are thrown away, first introduce Listing A-20’s NullDevice package-private class.

package logging;

public class NullDevice implements Logger {

private String dstName;

public NullDevice(String dstName) {

}

public boolean connect() {

return true;

}

public boolean disconnect(){

return true;

}

public boolean log(String msg){

return true;

}

Listing A-20

Implementing the Proverbial “Bit Bucket” Class

Continue by introducing, into the LoggerFactory class, a NULLDEVICE constant and code that instantiates NullDevice with a null argument—a destination name isn’t required—when newLogger()’s dstType parameter contains this constant’s value. Check out Listing A-21.

package logging;

public abstract class LoggerFactory {

public final static int CONSOLE = 0;

public final static int FILE = 1;

public final static int NULLDEVICE = 2;

public static Logger newLogger(int dstType, String...dstName){

switch (dstType) {

case CONSOLE : return new Console(dstName.length == 0 ?

null : dstName[0]);

case FILE : return new File(dstName.length == 0 ?

null : dstName[0]);

case NULLDEVICE: return new NullDevice(null);

default : return null;

}

Listing A-21

A Refactored LoggerFactory Class

30.
Modifying the logging package (presented in Chapter 5’s discussion of packages) so that Logger’s connect() method throws a CannotConnectException instance when it cannot connect to its logging destination, and the other two methods each throw a NotConnectedException instance when connect() was not called or when it threw a CannotConnectException instance, results in Listing A-22’s Logger interface.

package logging;

public interface Logger {

void connect() throws CannotConnectException;

void disconnect() throws NotConnectedException;

void log(String msg) throws NotConnectedException;

}

Listing A-22

A Logger Interface Whose Methods Throw Exceptions

Listing A-23 presents the CannotConnectException class.

package logging;

public class CannotConnectException extends Exception {

}

Listing A-23

An Uncomplicated CannotConnectException Class

The NotConnectedException class has the same structure but with a different name.

Listing A-24 presents the Console class.

package logging;

public class Console implements Logger {

private String dstName;

public Console(String dstName) {

this.dstName = dstName;

}

public void connect() throws CannotConnectException {

}

public void disconnect() throws NotConnectedException {

}

public void log(String msg) throws NotConnectedException {

System.out.println(msg);

}

Listing A-24

The Console Class Satisfying Logger's Contract Without Throwing Exceptions

Listing A-25 presents the File class.

package logging;

public class File implements Logger {

private String dstName;

public File(String dstName) {

this.dstName = dstName;

}

public void connect() throws CannotConnectException {

if (dstName == null)

throw new CannotConnectException();

}

public void disconnect() throws NotConnectedException {

if (dstName == null)

throw new NotConnectedException();

}

public void log(String msg) throws NotConnectedException {

if (dstName == null)

throw new NotConnectedException();

System.out.println("writing " + msg + " to file " + dstName);

}

Listing A-25

The File Class Satisfying Logger’s Contract by Throwing Exceptions As Necessary

31.
When you modify TestLogger to respond appropriately to thrown CannotConnectException and NotConnectedException objects, you end up with something similar to Listing A-26.

import logging.*;

public class TestLogger {

public static void main(String[] args) {

try {

Logger logger = LoggerFactory.newLogger(LoggerFactory.CONSOLE);

logger.connect();

logger.log("test message #1");

logger.disconnect();

} catch (CannotConnectException cce) {

System.err.println("cannot connect to console-based logger");

} catch (NotConnectedException nce) {

System.err.println("not connected to console-based logger");

}

try {

Logger logger = LoggerFactory.newLogger(LoggerFactory.FILE, "x.txt");

logger.connect();

logger.log("test message #2");

logger.disconnect();

} catch (CannotConnectException cce) {

System.err.println("cannot connect to file-based logger");

} catch (NotConnectedException nce) {

System.err.println("not connected to file-based logger");

}

try {

Logger logger = LoggerFactory.newLogger(LoggerFactory.FILE);

logger.connect();

logger.log("test message #3");

logger.disconnect();

} catch (CannotConnectException cce) {

System.err.println("cannot connect to file-based logger");

} catch (NotConnectedException nce) {

System.err.println("not connected to file-based logger");

}

Listing A-26

A TestLogger Class That Handles Thrown Exceptions

Chapter 6: Mastering Advanced Language Features, Part 2

1.
An annotation is an instance of an annotation type and associates metadata with an application element. It’s expressed in source code by prefixing the type name with the @ symbol.
2.
Constructors, fields, local variables, methods, packages, parameters, and types (annotation, class, enum, and interface) can be annotated.
3.
The three compiler-supported annotation types are Override, Deprecated, and SuppressWarnings.
4.
You declare an annotation type by specifying the @ symbol, immediately followed by reserved word interface, followed by the type’s name, followed by a body.
5.
A marker annotation is an instance of an annotation type that supplies no data apart from its name; the type’s body is empty.
6.
An element is a method header that appears in the annotation type’s body. It cannot have parameters or a throws clause. Its return type must be primitive (such as int), String, Class, an enum type, an annotation type, or an array of the preceding types. It can have a default value.
7.
You assign a default value to an element by specifying default followed by the value, whose type must match the element’s return type. For example, String developer() default "unassigned";.
8.
A meta-annotation is an annotation that annotates an annotation type.
9.
Java’s four meta-annotation types are Target, Retention, Documented, and Inherited.
10.
Generics can be defined as a suite of language features for declaring and using type-agnostic classes and interfaces.
11.
You would use generics to ensure that your code is typesafe by avoiding thrown ClassCastExceptions.
12.
The difference between a generic type and a parameterized type is that a generic type is a class or interface that introduces a family of parameterized types by declaring a formal type parameter list, and a parameterized type is an instance of a generic type.
13.
Anonymous classes cannot be generic because they have no names.
14.
The five kinds of actual type arguments are concrete types, concrete parameterized types, array types, type parameters, and wildcards.
15.
The answer is true: you cannot specify a primitive-type name (such as double or int) as an actual type argument.
16.
A raw type is a generic type without its type parameters.
17.
The compiler reports an unchecked warning message when it detects an explicit cast that involves a type parameter. The compiler is concerned that downcasting to whatever type is passed to the type parameter might result in a violation of type safety.
18.
You suppress an unchecked warning message by prefixing the constructor or method that contains the unchecked code with the @SuppressWarnings("unchecked") annotation.
19.
The answer is true: List<E>’s E type parameter is unbounded.
20.
You specify a single upper bound via reserved word extends followed by a type name.
21.
A recursive type bound is a type parameter bound that includes the type parameter.
22.
Wildcard type arguments are necessary because by accepting any actual type argument they provide a typesafe workaround to the problem of polymorphic behavior not applying to multiple parameterized types that differ only in regard to one type parameter being a subtype of another type parameter. For example, because List<String> isn’t a kind of List<Object>, you cannot pass an object whose type is List<String> to a method parameter whose type is List<Object>. However, you can pass a List<String> object to List<?>, provided that you’re not going to add the List<String> object to the List<?>.
23.
A generic method is a class or instance method with a type-generalized implementation.
24.
Although you might think otherwise, Listing 6-28’s methodCaller() generic method calls someOverloadedMethod(Object o). This method, instead of someOverloadedMethod(Date d), is called because overload resolution happens at compile time, when the generic method is translated to its unique bytecode representation, and erasure (which takes care of that mapping) causes type parameters to be replaced by their leftmost bound or Object (when there is no bound). After erasure, you are left with Listing A-27’s nongeneric methodCaller() method.

public static void methodCaller(Object t) {

someOverloadedMethod(t);

}

Listing A-27

The Nongeneric methodCaller() Method That Results from Erasure

25.
Reification is representing the abstract as if it was concrete.
26.
The answer is false: type parameters are not reified.
27.
Erasure is the throwing away of type parameters following compilation so that they are not available at runtime. Erasure also involves replacing uses of other type variables by the upper bound of the type variable (such as Object) and inserting casts to the appropriate type when the resulting code isn’t type correct.
28.
An enumerated type is a type that specifies a named sequence of related constants as its legal values.
29.
Three problems that can arise when you use enumerated types whose constants are int-based are lack of compile-time type safety, brittle applications, and the inability to translate int constants into meaningful string-based descriptions.
30.
An enum is an enumerated type that’s expressed via reserved word enum.
31.
You use a switch statement with an enum by specifying an enum constant as the statement’s selector expression and constant names as case values.
32.
You can enhance an enum by adding fields, constructors, and methods; you can even have the enum implement interfaces. Also, you can override toString() to provide a more useful description of a constant’s value and subclass constants to assign different behaviors.
33.
The purpose of the abstract Enum class is to serve as the common base class of all Java language–based enumeration types.
34.
The difference between Enum’s name() and toString() methods is that name() always returns a constant’s name, but toString() can be overridden to return a more meaningful description instead of the constant’s name.
35.
The answer is true: Enum’s generic type is Enum<E extends Enum<E>>.
36.
Listing A-28 presents a ToDo marker annotation type that annotates only type elements and that also uses the default retention policy.

import java.lang.annotation.ElementType;

import java.lang.annotation.Target;

@Target(ElementType.TYPE)

public @interface ToDo {

}

Listing A-28

The ToDo Annotation Type for Marking Types That Need to Be Completed

37.
Listing A-29 presents a rewritten StubFinder application that works with Listing 6–4’s Stub annotation type (with appropriate @Target and @Retention annotations) and Listing 6–5’s Deck class.

import java.lang.reflect.Method;

public class StubFinder {

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

if (args.length != 1){

System.err.println("usage: java StubFinder classfile");

return;

}

Method[] methods = Class.forName(args[0]).getMethods();

for (int i = 0; i < methods.length; i++)

if (methods[i].isAnnotationPresent(Stub.class)){

Stub stub = methods[i].getAnnotation(Stub.class);

System.out.println("Stub ID = " + stub.id());

System.out.println("Stub Date = " + stub.dueDate());

System.out.println("Stub Developer = " + stub.developer());

System.out.println();

}

Listing A-29

Reporting a Stub’s ID, Due Date, and Developer via a New Version of StubFinder

38.
Listing A-30 presents the generic Stack class and the StackEmptyException and StackFullException helper classes that were called for in Chapter 6.

public class Stack<E> {

private E[] elements;

private int top;

@SuppressWarnings("unchecked")

public Stack(int size) {

if (size < 2)

throw new IllegalArgumentException("" + size);

elements = (E[]) new Object[size];

top = -1;

}

public void push(E element) throws StackFullException {

if (top == elements.length - 1)

throw new StackFullException();

elements[++top] = element;

}

public E pop() throws StackEmptyException {

if (isEmpty())

throw new StackEmptyException();

return elements[top--];

}

public boolean isEmpty() {

return top == -1;

}

public static void main(String[] args)

throws StackFullException, StackEmptyException

{

Stack<String> stack = new Stack<String>(5);

assert stack.isEmpty();

stack.push("A");

stack.push("B");

stack.push("C");

stack.push("D");

stack.push("E");

// Uncomment the following line to generate a StackFullException.

//stack.push("F");

while (!stack.isEmpty())

System.out.println(stack.pop());

// Uncomment the following line to generate a StackEmptyException.

//stack.pop();

assert stack.isEmpty();

}

class StackEmptyException extends Exception {

}

class StackFullException extends Exception {

}

Listing A-30

Stack and Its StackEmptyException and StackFullException Helper Classes Proving That Not All Helper Classes Need to Be Nested

39.
Listing A-31 presents the Compass enum that was called for in Chapter 6.

enum Compass {

NORTH, SOUTH, EAST, WEST

}

Listing A-31

A Compass Enum with Four Direction Constants

Listing A-32 presents the UseCompass class that was called for in Chapter 6.

public class UseCompass {

public static void main(String[] args) {

int i = (int) (Math.random() * 4);

Compass[] dir = { Compass.NORTH, Compass.EAST, Compass.SOUTH,

Compass.WEST };

switch(dir[i]) {

case NORTH: System.out.println("heading north"); break;

case EAST : System.out.println("heading east"); break;

case SOUTH: System.out.println("heading south"); break;

case WEST : System.out.println("heading west"); break;

default : assert false; // Should never be reached.

}

Listing A-32

Using the Compass Enum to Keep from Getting Lost

Chapter 7: Exploring the Basic APIs, Part 1

1.
Math declares double constants E and PI that represent, respectively, the natural logarithm base value (2.71828…) and the ratio of a circle’s circumference to its diameter (3.14159…). E is initialized to 2.718281828459045 and PI is initialized to 3.141592653589793.
2.
Math.abs(Integer.MIN_VALUE) equals Integer.MIN_VALUE because there doesn’t exist a positive 32-bit integer equivalent of MIN_VALUE. (Integer.MIN_VALUE equals -2147483648 and Integer.MAX_VALUE equals 2147483647.)
3.
Math’s random() method returns a pseudorandom number between 0.0 (inclusive) and 1.0 (exclusive).
4.
The five special values that can arise during floating-point calculations are +infinity, -infinity, NaN, +0.0, and -0.0.
5.
BigDecimal is an immutable class that represents a signed decimal number (such as 23.653) of arbitrary precision with an associated scale. You might use this class to store floating-point values accurately, which represent monetary values and properly round the result of each monetary calculation.
6.
The RoundingMode constant that describes the form of rounding commonly taught at school is HALF_UP.
7.
BigInteger is an immutable class that represents a signed integer of arbitrary precision. It stores its value in two’s complement format.
8.
A primitive type wrapper class is a class whose instances wrap themselves around primitive-type values.
9.
Java’s primitive type wrapper classes are Boolean, Byte, Character, Double, Float, Integer, Long, and Short.
10.
Java provides primitive type wrapper classes to facilitate storing primitive-type values in collections and as a convenient place to associate useful constants and class methods with the primitive types.
11.
The answer is false: Boolean is the smallest of the primitive type wrapper classes.
12.
You should use Character class methods instead of expressions such as ch >= '0' && ch <= '9' to determine whether or not a character is a digit, a letter, and so on because it’s too easy to introduce a bug into the expression, expressions are not very descriptive of what they’re testing, and the expressions are biased toward Latin digits (0–9) and letters (A–Z and a–z).
13.
You determine whether or not double variable d contains +infinity or -infinity by passing this variable as an argument to Double’s boolean isInfinite(double d) class method, which returns true when this argument is +infinity or -infinity.
14.
Number is the superclass of Byte, Character, and the other primitive type wrapper classes.
15.
The answer is true: a string literal is a String object.
16.
The purpose of String’s intern() method is to store a unique copy of a String object in an internal table of String objects. intern() makes it possible to compare strings via their references and == or !=. These operators are the fastest way to compare strings, which is especially valuable when sorting a huge number of strings.
17.
String and StringBuffer differ in that String objects contain immutable sequences of characters, whereas StringBuffer objects contain mutable sequences of characters.
18.
StringBuffer and StringBuilder differ in that StringBuffer methods are synchronized, whereas StringBuilder’s equivalent methods are not synchronized. As a result, you would use the thread-safe but slower StringBuffer class in multithreaded situations and the nonthread-safe but faster StringBuilder class in single-threaded situations.
19.
You invoke the System.arraycopy() method to copy an array to another array.
20.
You invoke the System.currentTimeMillis() method to obtain the current time in milliseconds.
21.
A thread is an independent path of execution through an application’s code.
22.
The purpose of the Runnable interface is to identify those objects that supply code for threads to execute via this interface’s solitary void run() method.
23.
The purpose of the Thread class is to provide a consistent interface to the underlying operating system’s threading architecture. It provides methods that make it possible to associate code with threads as well as to start and manage those threads.
24.
The answer is false: a Thread object associates with a single thread.
25.
A race condition is a scenario in which multiple threads are accessing shared data, and the final result of these accesses is dependent on the timing of how the threads are scheduled. Race conditions can lead to bugs that are hard to find and results that are unpredictable.
26.
Synchronization is the act of allowing only one thread at a time to execute code within a method or a block.
27.
Synchronization is implemented in terms of monitors and locks.
28.
Synchronization works by requiring that a thread that wants to enter a monitor-controlled critical section first acquires a lock. The lock is released automatically when the thread exits the critical section.
29.
The answer is true: variables of type long or double are not atomic on 32-bit virtual machines.
30.
The purpose of reserved word volatile is to let threads running on multiprocessor or multicore machines access the main memory copy of an instance field or class field. Without volatile, each thread might access its cached copy of the field and won’t see modifications made by other threads to their copies.
31.
The answer is false: Object’s wait() methods cannot be called from outside of a synchronized method or block.
32.
Deadlock is a situation where locks are acquired by multiple threads, neither thread holds its own lock but holds the lock needed by some other thread, and neither thread can enter and later exit its critical section to release its held lock because some other thread holds the lock to that critical section.
33.
The purpose of the ThreadLocal class is to associate per-thread data (such as a user ID) with a thread.
34.
Listing A-33 presents the PrimeNumberTest application that was called for in Chapter 7.

public class PrimeNumberTest {

public static void main(String[] args) {

if (args.length != 1){

System.err.println("usage: java PrimeNumberTest integer");

System.err.println("integer must be 2 or higher");

return;

}

try {

int n = Integer.parseInt(args[0]);

if (n < 2) {

System.err.println(n + " is invalid because it is less than 2");

return;

}

for (int i = 2; i <= Math.sqrt(n); i++)

if (n % i == 0){

System.out.println (n + " is not prime");

return;

}

System.out.println(n + " is prime");

} catch (NumberFormatException nfe) {

System.err.println("unable to parse " + args[0] + " into an int");

}

Listing A-33

Checking a Positive Integer Argument to Discover If It’s Prime

35.
Listing A-34 presents the MultiPrint application that was called for in Chapter 7.

public class MultiPrint {

public static void main(String[] args) {

if (args.length != 2) {

System.err.println("usage: java MultiPrint text count");

return;

}

String text = args[0];

int count = Integer.parseInt(args[1]);

for (int i = 0; i < count; i++)

System.out.println(text);

}

Listing A-34

Printing a Line of Text Multiple Times

36.
The following loop uses StringBuffer to minimize object creation:

String[] imageNames = new String[NUM_IMAGES];

StringBuffer sb = new StringBuffer();

for (int i = 0; i < imageNames.length; i++) {

sb.append("image");

sb.append(i);

sb.append(".png");

imageNames[i] = sb.toString();

sb.setLength(0); // Erase previous StringBuffer contents.

}

37.
Listing A-35 presents the DigitsToWords application that was called for in Chapter 7.

public class DigitsToWords {

public static void main(String[] args) {

if (args.length != 1) {

System.err.println("usage: java DigitsToWords integer");

return;

}

System.out.println(convertDigitsToWords(Integer.parseInt(args[0])));

}

public static String convertDigitsToWords(int integer) {

if (integer < 0 || integer > 9999)

throw new IllegalArgumentException("Out of range: " + integer);

if (integer == 0)

return "zero";

String[] group1 = {

"one",

"two",

"three",

"four",

"five",

"six",

"seven",

"eight",

"nine"

};

String[] group2 = {

"ten",

"eleven",

"twelve",

"thirteen",

"fourteen",

"fifteen",

"sixteen",

"seventeen",

"eighteen",

"nineteen"

};

String[] group3 = {

"twenty",

"thirty",

"forty",

"fifty",

"sixty",

"seventy",

"eighty",

"ninety"

};

StringBuffer result = new StringBuffer();

if (integer >= 1000) {

int tmp = integer / 1000;

result.append(group1[tmp - 1] + " thousand");

integer -= tmp * 1000;

if (integer == 0)

return result.toString();

result.append(" ");

}

if (integer >= 100) {

int tmp = integer / 100;

result.append(group1[tmp - 1] + " hundred");

integer -= tmp * 100;

if (integer == 0)

return result.toString();

result.append(" and ");

}

if (integer >= 10 && integer <= 19){

result.append(group2[integer - 10]);

return result.toString();

}

if (integer >= 20){

int tmp = integer / 10;

result.append(group3[tmp - 2]);

integer -= tmp * 10;

if (integer == 0)

return result.toString();

result.append("-");

}

result.append(group1[integer - 1]);

return result.toString();

}

Listing A-35

Converting an Integer Value to Its Textual Representation

38.
Listing A-36 presents the EVDump application that was called for in Chapter 7.

public class EVDump {

public static void main(String[] args) {

System.out.println(System.getenv()); // System.out.println() calls toString()

// on its object argument and outputs this

// string

}

Listing A-36

Dumping All Environment Variables to Standard Output

39.
Listing A-37 presents the revised CountingThreads application that was called for in Chapter 7.

public class CountingThreads {

public static void main(String[] args) {

Runnable r = new Runnable(){

@Override

public void run(){

String name = Thread.currentThread().getName();

int count = 0;

while (true)

System.out.println(name + ": " + count++);

}

};

Thread thdA = new Thread(r);

thdA.setDaemon(true);

Thread thdB = new Thread(r);

thdB.setDaemon(true);

thdA.start();

thdB.start();

}

Listing A-37

Counting via Daemon Threads

When you run this application, the two daemon threads start executing, and you will probably see some output. However, the application will end as soon as the default main thread leaves the main() method and dies.

40.
Listing A-38 presents the StopCountingThreads application that was called for in Chapter 7.

import java.io.IOException;

public class StopCountingThreads {

private static volatile boolean stopped = false;

public static void main(String[] args) {

Runnable r = new Runnable(){

@Override

public void run(){

String name = Thread.currentThread().getName();

int count = 0;

while (!stopped)

System.out.println(name + ": " + count++);

}

};

Thread thdA = new Thread(r);

Thread thdB = new Thread(r);

thdA.start();

thdB.start();

try { System.in.read(); } catch (IOException ioe) {}

stopped = true;

}

Listing A-38

Stopping the Counting Threads When Return/Enter Is Pressed

Chapter 8: Exploring the Basic APIs, Part 2

1.
Instances of the Random class generate sequences of random numbers by starting with a special 48-bit value that’s known as a seed. This value is subsequently modified by a mathematical algorithm, which is known as a linear congruential generator.
2.
Some of the capabilities offered by the Reflection API are letting applications dynamically load and learn about loaded classes and other reference types and letting applications instantiate classes, call methods, access fields, and perform other tasks reflectively.
3.
Reflection shouldn’t be used indiscriminately for several reasons. Application performance suffers because it takes longer to perform operations with reflection than without reflection. Also, reflection-oriented code can be harder to read, and the absence of compile-time type checking can result in runtime failures.
4.
The class that’s the entry point into the Reflection API is java.lang.Class.
5.
The answer is false: not all of the Reflection API is contained in the java.lang.reflect package. For example, Class is located in the java.lang package.
6.
The three ways to obtain a Class object are to invoke Class’s forName() method, to invoke Object’s getClass() method, and to use a class literal.
7.
The answer is true: you can use class literals with primitive types.
8.
You instantiate a dynamically loaded class by invoking Class’s newInstance() method.
9.
You invoke Constructor’s Class[]<?> getParameterTypes() method to obtain a constructor’s parameter types.
10.
Class’s Field getField(String name) method throws NoSuchFieldException when it cannot locate the named field.
11.
You determine if a method is declared to receive a variable number of arguments by invoking Method’s isVarArgs() method on the Method object that represents the method.
12.
The answer is true: you can reflectively make a private method accessible. You do this by invoking the setAccessible() method that each of Constructor, Field, and Method inherits from its AccessibleObject superclass.
13.
The purpose of Package’s isSealed() method is to indicate whether or not a package is sealed (all classes that are part of the package are archived in the same JAR file). This method returns true when the package is sealed.
14.
The answer is true: getPackage() requires at least one class file to be loaded from the package before it returns a Package object describing that package.
15.
You reflectively create and access a Java array by invoking the class methods declared in the java.lang.reflect.Array class.
16.
The purpose of the StringTokenizer class is to provide access to a string’s individual components.
17.
The java.util package’s Timer and TimerTask classes are the standard class library’s convenient and simpler alternative to the Threads API for scheduling task execution.
execution time of the previous execution. When an execution is delayed for any reason (such as garbage collection), subsequent executions are also delayed.
18.
Listing A-39 presents the Guess application that was called for in Chapter 8.

import java.util.Random;

public class Guess {

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

Random r = new Random();

int hiddenValue = 'a' + r.nextInt(26);

while (true){

int guess = 0;

while (guess < 'a' || guess > 'z'){

System.out.print("Guess between a and z inclusive: ");

guess = System.in.read();

System.out.println();

// Flush carriage return or carriage return/newline combination

// so that each character isn't automatically read during the

// next System.in.read() method call.

int x = 0;

while (x != ' ')

x = System.in.read();

}

if (guess < hiddenValue)

System.out.println("too low");

else

if (guess > hiddenValue)

System.out.println("too high");

else {

System.out.println("you got it");

break;

}

Listing A-39

Guessing Game

19.
Listing A-40 presents the Classify application that was called for in Chapter 8.

public class Classify {

public static void main(String[] args) {

if (args.length != 1){

System.err.println("usage: java Classify pkgAndTypeName");

return;

}

try{

Class<?> clazz = Class.forName(args[0]);

if (clazz.isAnnotation())

System.out.println("Annotation");

else if (clazz.isEnum())

System.out.println("Enum");

else if (clazz.isInterface())

System.out.println("Interface");

else

System.out.println("Class");

} catch (ClassNotFoundException cnfe) {

System.err.println("could not locate " + args[0]);

}

Listing A-40

Classifying a Command-Line Argument as an Annotation Type, Enum, Interface, or Class

Specify java Classify java.lang.Override, and you’ll see Annotation as the output. Also, java.Classify java.math.RoundingMode outputs Enum, java Classify java.lang.Runnable outputs Interface, and java Classify java.lang.Class outputs Class.

20.
Listing A-41 presents the Tokenize application that was called for in Chapter 8.

import java.util.StringTokenizer;

public class Tokenize {

public static void main(String[] args) {

String date = "03-12-2014 03:05:20";

StringTokenizer st = new StringTokenizer(date, "- :");

System.out.println("Month = " + st.nextToken());

System.out.println("Day = " + st.nextToken());

System.out.println("Year = " + st.nextToken());

System.out.println("Hour = " + st.nextToken());

System.out.println("Minute = " + st.nextToken());

System.out.println("Second = " + st.nextToken());

}

Listing A-41

Extracting the Month, Day, Year, Hour, Minute, and Second Tokens from a Date String

21.
Listing A-42 presents the BackAndForth application that was called for in Chapter 8.

import java.util.Timer;

import java.util.TimerTask;

public class BackAndForth {

public static enum Direction { FORWARDS, BACKWARDS }

public static void main(String[] args) {

TimerTask task = new TimerTask() {

final static int MAXSTEPS = 20;

Direction direction = Direction.FORWARDS;

int steps = 0;

@Override

public void run() {

switch (direction){

case FORWARDS :

System.out.print(" ");

System.out.print("*");

break;

case BACKWARDS:

System.out.print(" ");

System.out.print("*");

}

if (++steps == MAXSTEPS) {

direction = (direction == Direction.FORWARDS)

? Direction.BACKWARDS

: Direction.FORWARDS;

steps = 0;

}

};

Timer timer = new Timer();

timer.schedule(task, 0, 100);

}

Listing A-42

Repeatedly Moving an Asterisk Back and Forth via a Timer

Chapter 9: Exploring the Collections Framework

1.
A collection is a group of objects that are stored in an instance of a class designed for this purpose.
2.
The Collections Framework is a group of types that offers a standard architecture for representing and manipulating collections.
3.
The Collections Framework largely consists of core interfaces, implementation classes, and utility classes.
4.
A comparable is an object whose class implements the Comparable interface.
5.
You would have a class implement the Comparable interface when you want objects to be compared according to their natural ordering.
6.
A comparator is an object whose class implements the Comparator interface. Its purpose is to allow objects to be compared according to an order that’s different from their natural ordering.
7.
The answer is false: a collection uses a comparable (an object whose class implements the Comparable interface) to define the natural ordering of its elements.
8.
The Iterable interface describes any object that can return its contained objects in some sequence.
9.
The Collection interface represents a collection of objects that are known as elements.
10.
A situation where Collection’s add() method would throw an instance of the UnsupportedOperationException class is an attempt to add an element to an unmodifiable collection.
11.
The purpose of the enhanced for loop statement is to simplify collection or array iteration.
12.
The enhanced for loop statement is expressed as for (type id: collection) or for (type id: array) and reads “for each type object in collection, assign this object to id at the start of the loop iteration” or “for each type object in array, assign this object to id at the start of the loop iteration.”
13.
The answer is true: the enhanced for loop works with arrays. For example, int[] x = { 1, 2, 3 }; for (int i: x) System.out.println(i); declares array x and outputs all of its int-based elements.
14.
Autoboxing is the act of wrapping a primitive-type value in an object of a primitive type wrapper class whenever a primitive type is specified but a reference is required. This feature saves the developer from having to instantiate a wrapper class explicitly when storing the primitive-type value in a collection.
15.
Unboxing is the act of unwrapping a primitive-type value from its wrapper object whenever a reference is specified but a primitive type is required. This feature saves the developer from having to call a method explicitly on the object (such as intValue()) to retrieve the wrapped value.
16.
A list is an ordered collection, which is also known as a sequence. Elements can be stored in and accessed from specific locations via integer indexes.
17.
A ListIterator instance uses a cursor to navigate through a list.
18.
A view is a list that’s backed by another list. Changes that are made to the view are reflected in this backing list.
19.
You would use the subList() method to perform range-view operations over a collection in a compact manner. For example, list.subList(fromIndex, toIndex).clear(); removes a range of elements from list, where the first element is located at fromIndex and the last element is located at toIndex - 1.
20.
The ArrayList class provides a list implementation that’s based on an internal array.
21.
The LinkedList class provides a list implementation that’s based on linked nodes.
22.
The answer is false: ArrayList provides slower element insertions and deletions than LinkedList.
23.
A set is a collection that contains no duplicate elements.
24.
The TreeSet class provides a set implementation that’s based on a tree data structure. As a result, elements are stored in sorted order.
25.
The HashSet class provides a set implementation that’s backed by a hashtable data structure.
26.
The answer is true: to avoid duplicate elements in a hashset, your own classes must correctly override equals() and hashCode().
27.
The difference between HashSet and LinkedHashSet is that LinkedHashSet uses a linked list to store its elements, resulting in its iterator returning elements in the order in which they were inserted.
28.
The EnumSet class provides a Set implementation that’s based on a bitset.
29.
A sorted set is a set that maintains its elements in ascending order, sorted according to their natural ordering or according to a comparator that’s supplied when the sorted set is created. Furthermore, the set’s implementation class must implement the SortedSet interface.
30.
A navigable set is a sorted set that can be iterated over in descending order as well as ascending order and which can report closest matches for given search targets.
31.
The answer is false: HashSet isn’t an example of a sorted set. However, TreeSet is an example of a sorted set.
32.
A sorted set’s add() method would throw ClassCastException when you attempt to add an element to the sorted set because the element’s class doesn’t implement Comparable.
33.
A queue is a collection in which elements are stored and retrieved in a specific order. Most queues are categorized as “first-in, first-out,” “last-in, first-out,” or priority.
34.
The answer is true: Queue’s element() method throws NoSuchElementException when it’s called on an empty queue.
35.
The PriorityQueue class provides an implementation of a priority queue, which is a queue that orders its elements according to their natural ordering or by a comparator provided when the queue is instantiated.
36.
A map is a group of key/value pairs (also known as entries).
37.
The TreeMap class provides a map implementation that’s based on a red-black tree. As a result, entries are stored in sorted order of their keys.
38.
The HashMap class provides a map implementation that’s based on a hashtable data structure.
39.
A hashtable uses a hash function to map keys to integer values.
40.
Continuing from the previous exercise, the resulting integer values are known as hash codes. They identify hashtable array elements, which are known as buckets or slots.
41.
A hashtable’s capacity refers to the number of buckets.
42.
A hashtable’s load factor refers to the ratio of the number of stored entries divided by the number of buckets.
43.
The difference between HashMap and LinkedHashMap is that LinkedHashMap uses a linked list to store its entries, resulting in its iterator returning entries in the order in which they were inserted.
44.
The IdentityHashMap class provides a Map implementation that uses reference equality (==) instead of object equality (equals()) when comparing keys and values.
45.
The EnumMap class provides a Map implementation whose keys are the members of the same enum.
46.
A sorted map is a map that maintains its entries in ascending order, sorted according to the keys’ natural ordering or according to a comparator that’s supplied when the sorted map is created. Furthermore, the map’s implementation class must implement the SortedMap interface.
47.
A navigable map is a sorted map that can be iterated over in descending order as well as ascending order and which can report closest matches for given search targets.
48.
The answer is true: TreeMap is an example of a sorted map.
49.
The purpose of the Arrays class’s static <T> List<T> asList(T... array) method is to return a fixed-size list backed by the specified array. (Changes to the returned list “write through” to the array.)
50.
The answer is false: binary search is faster than linear search.
51.
You would use Collections’ static <T> Set<T> synchronizedSet(Set<T> s) method to return a synchronized variation of a hashset.
52.
The seven legacy collections-oriented types are Vector, Enumeration, Stack, Dictionary, Hashtable, Properties, and BitSet.
53.
Listing A-43 presents the JavaQuiz application that was called for in Chapter 9.

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public class JavaQuiz {

private static class QuizEntry {

private String question;

private String[] choices;

private char answer;

QuizEntry(String question, String[] choices, char answer){

this.question = question;

this.choices = choices;

this.answer = answer;

}

String[] getChoices(){

// Demonstrate returning a copy of the choices array

// to prevent clients from directly manipulating

// (and possibly screwing up) the internal

// choices array.

String[] temp = new String[choices.length];

System.arraycopy(choices, 0, temp, 0, choices.length);

return temp;

}

String getQuestion() {

return question;

}

char getAnswer() {

return answer;

}

static QuizEntry[] quizEntries = {

new QuizEntry("What was Java's original name?",

new String[] { "Oak", "Duke", "J", "None of the above" },

'A'),

new QuizEntry("Which of the following reserved words is also a literal?",

new String[] { "for", "long", "true", "enum" },

'C'),

new QuizEntry("The conditional operator (?:) resembles which statement?",

new String[] { "switch", "if-else", "if", "while" },

'B')

};

public static void main(String[] args) {

// Populate the quiz list.

List<QuizEntry> quiz = new ArrayList<QuizEntry>();

for (QuizEntry entry: quizEntries)

quiz.add(entry);

// Perform the quiz.

System.out.println("Java Quiz");

System.out.println("--------- ");

Iterator<QuizEntry> iter = quiz.iterator();

while (iter.hasNext()) {

QuizEntry qe = iter.next();

System.out.println(qe.getQuestion());

String[] choices = qe.getChoices();

for (int i = 0; i < choices.length; i++)

System.out.println(" " + (char) ('A' + i) + ": " + choices[i]);

int choice = -1;

while (choice < 'A' || choice > 'A' + choices.length) {

System.out.print("Enter choice letter: ");

Try {

choice = System.in.read();

// Remove trailing characters up to and including the newline

// to avoid having these characters automatically returned in

// subsequent System.in.read() method calls.

while (System.in.read() != ' ');

choice = Character.toUpperCase((char) choice);

} catch (java.io.IOException ioe){

}

if (choice == qe.getAnswer())

System.out.println("You are correct! ");

else

System.out.println("You are not correct! ");

}

Listing A-43

How Much Do You Know About Java? Take the Quiz and Find Out!

54.
(int) (f ^ (f >>> 32)) is used instead of (int) (f ^ (f >> 32)) in the hash code generation algorithm because >>> always shifts a 0 to the right, which doesn’t affect the hash code, whereas >> shifts a 0 or a 1 to the right (whatever value is in the sign bit), which affects the hash code when a 1 is shifted.
55.
Listing A-44 presents the FrequencyDemo application that was called for in Chapter 9.

import java.util.Collections;

import java.util.LinkedList;

import java.util.List;

public class FrequencyDemo {

public static void main(String[] args) {

List<String> listOfArgs = new LinkedList<String>();

String lastArg = (args.length == 0) ? null : args[args.length - 1];

for (int i = 0; i < args.length - 1; i++)

listOfArgs.add(args[i]);

System.out.println("Number of occurrences of " + lastArg + " = " +

Collections.frequency(listOfArgs, lastArg));

}

Listing A-44

Reporting the Frequency of Last Command-Line Argument Occurrences in the Previous Command-Line Arguments

Chapter 10: Functional Programming

1.
Right. This is one of the main characteristics of functional programming inside an object-oriented environment.
2.
Wrong. Although using streams without functional constructs doesn’t make much sense, a stream per se is not a functional subconcept.
3.
Wrong. The other way round is true.
4.
A consumer is a function with one input and no output.
5.
As supplier is a function with no input and one output.
6.
The solution is shown in Listing A-45.

d -> d + 1.0 // This is the shortest form.

(d) -> d + 1.0 // ...and...

(Double d) -> d + 1.0 // ...and...

d -> { return d + 1.0; } // ...are possible as well.

Listing A-45

Adding 1.0 to Any Double

7.
The solution is shown in Listing A-46.

Function<BigDecimal,String> f1 = bd ->

NumberFormat.getCurrencyInstance(Locale.US).format(bd);

Listing A-46

A Currency Value Formatter

8.
Wrong. The int array gets seen as a single stream object.
9.
Stream.iterate(100L, l -> l + 1 ) creates a stream of Long objects. The second possible answer is LongStream.iterate(100, l -> l + 1 ), which creates a LongStream.
10.
IntStream.iterate(0, i -> i + 1).limit(100) is a correct answer, but more elegant is IntStream.rangeClosed(0, 99). If you really need a stream of integer objects, you can also use Stream.iterate(0, i -> i + 1).limit(100).
11.
The solution is IntStream.iterate(1, i->i+1).map(i -> i*i).
12.
The solution is new HashSet<>(Arrays.asList(1,6,3,7)).stream().
13.
The solution is shown in Listing A-47.

new HashSet<>(Arrays.asList(1,6,3,7))

.stream()

.mapToInt(i -> i)

Listing A-47

Building an IntStream

14.
The solution is shown in Listing A-48. The boxed() function converts a stream of native data type to an object stream.

new HashSet<>(Arrays.asList(1,6,3,7))

.stream()

.mapToInt(i -> i)

.boxed()

Listing A-48

Back to Integer Objects

15.
The stream’s filter() function allows us to extract certain members of a stream. So we can write stringStream.filter( s -> s.length() >= 3);.
16.
Just add .collect(Collectors.toList());.
17.
The solution is shown in Listing A-49.

IntStream.

iterate(1, i->i+1).

map(i -> i*i).

limit(10).

forEach(System.out::println);

Listing A-49

Limiting and Outputting

18.
1 * 6 * 7 * 3 can be calculated via
Stream.of(1,6,7,3).reduce(1, (i,j) -> i * j).
19.
The solution is shown in Listing A-50.

Stream.of(1,6,7,3).collect(

ArrayDeque::new,

(bas,inj) -> { bas.add(inj); },

(bas1,bas2) -> { bas1.addAll(bas2); });

Listing A-50

Building a Deque from a Stream

20.
The solution is shown in Listing A-51.

Arrays.asList("Hello", "World", "A").

stream().

map(Object::hashCode).

collect(Collectors.toList());

Listing A-51

Hash Codes from a Stream

21.
The solution is shown in Listing A-52.

DoubleStream dstr = IntStream.iterate(1, i -> i + 2).

mapToDouble( i -> (((i+1)/2)%2==1) ? 1.0/i : -1.0/i );

Listing A-52

An Infinite Stream

22.
Write double pi1 = dstr.limit(1_000_000).sum() * 4;
System.out.println("pi ~ " + pi1);.
23.
The solution is shown in Listing A-53.

DoubleStream dstr = IntStream.iterate(1, i -> i + 2).

mapToDouble( i -> (((i+1)/2)%2==1) ? 1.0/i : -1.0/i );

long t1 = System.currentTimeMillis();

double pi1 = dstr.limit(1_000_000).sum() * 4;

long t2 = System.currentTimeMillis();

System.out.println("pi ~ " + pi1);

System.out.println("Took " + (t2-t1) + "ms");

// On our laptop, this took 36ms.

Listing A-53

Metering a Pi Calculation

Chapter 11: Exploring the Concurrency Utilities

1.
Concurrency Utilities is a framework of classes and interfaces that overcome problems with the Threads API. Specifically, low-level concurrency primitives such as synchronized and wait()/notify() are often hard to use correctly; too much reliance on the synchronized primitive can lead to performance issues, which affect an application’s scalability; and higher-level constructs such as thread pools and semaphores aren’t included with Java’s low-level threading capabilities.
2.
The packages in which Concurrency Utilities types are stored are java.util.concurrent, java.util.concurrent.atomic, and java.util.concurrent.locks.
3.
A task is an object whose class implements the Runnable interface (a runnable task) or the Callable interface (a callable task).
4.
An executor is an object whose class directly or indirectly implements the Executor interface, which decouples task submission from task-execution mechanics.
5.
The Executor interface focuses exclusively on Runnable, which means that there’s no convenient way for a runnable task to return a value to its caller (because Runnable’s run() method doesn’t return a value); Executor doesn’t provide a way to track the progress of executing runnable tasks, cancel an executing runnable task, or determine when the runnable task finishes execution; Executor cannot execute a collection of runnable tasks; and Executor doesn’t provide a way for an application to shut down an executor (much less to shut down an executor properly).
6.
The differences existing between Runnable’s run() method and Callable’s call() method are as follows: run() cannot return a value, whereas call() can return a value; and run() cannot throw checked exceptions, whereas call() can throw checked exceptions.
7.
A future is an object whose class implements the Future interface. It represents an asynchronous computation and provides methods for canceling a task, for returning a task’s value, and for determining whether or not the task has finished.
8.
The Executors class’s newFixedThreadPool() method creates a thread pool that reuses a fixed number of threads operating off of a shared unbounded queue. At most, nThreads threads are actively processing tasks. If additional tasks are submitted when all threads are active, they wait in the queue for an available thread. If any thread terminates because of a failure during execution before the executor shuts down, a new thread will take its place when needed to execute subsequent tasks. The threads in the pool will exist until the executor is explicitly shut down.
9.
A synchronizer is a class that facilitates a common form of synchronization.
10.
The concurrency-oriented extensions to the Collections Framework provided by the Concurrency Utilities are ArrayBlockingQueue, BlockingDeque, BlockingQueue, ConcurrentHashMap, ConcurrentMap, ConcurrentNavigableMap, ConcurrentLinkedQueue, ConcurrentSkipListMap, ConcurrentSkipListSet, CopyOnWriteArrayList, CopyOnWriteArraySet, DelayQueue, LinkedBlockingDeque, LinkedBlockingQueue, PriorityBlockingQueue, and SynchronousQueue.
11.
A lock is an instance of a class that implements the Lock interface, which provides more extensive locking operations than can be achieved via the synchronized reserved word. Lock also supports a wait/notification mechanism through associated Condition objects.
12.
The biggest advantage that Lock objects hold over the implicit locks that are obtained when threads enter critical sections (controlled via the synchronized reserved word) is their ability to back out of an attempt to acquire a lock.
13.
You obtain a Condition instance for use with a particular Lock instance by invoking Lock’s Condition newCondition() method.
14.
An atomic variable is an instance of a class that encapsulates a single variable and supports lock-free, thread-safe operations on that variable, for example, AtomicInteger.
15.
The AtomicIntegerArray class describes an int array whose elements may be updated atomically.
16.
The atomic variable equivalent of int total = ++counter; is as follows:
AtomicInteger counter = new AtomicInteger(0);
int total = counter.incrementAndGet();
The atomic variable equivalent of int total = counter--; is as follows:
AtomicInteger counter = new AtomicInteger(0);
int total = counter.getAndDecrement();

Chapter 12: Performing Classic I/O

1.
The purpose of the File class is to offer access to the underlying platform’s available filesystem(s).
2.
Instances of the File class contain the pathnames of files and directories that may or may not exist in their filesystems.
3.
File’s listRoots() method returns an array of File objects denoting the root directories (roots) of available filesystems.
4.
A path is a hierarchy of directories that must be traversed to locate a file or a directory. A pathname is a string representation of a path; a platform-dependent separator character (such as the Windows backslash [] character) appears between consecutive names.
5.
The difference between an absolute pathname and a relative pathname is as follows: an absolute pathname is a pathname that starts with the root directory symbol, whereas a relative pathname is a pathname that doesn’t start with the root directory symbol (it’s interpreted via information taken from some other pathname).
6.
You obtain the current user (also known as working) directory by specifying System.getProperty("user.dir").
7.
A parent pathname is a string that consists of all pathname components except for the last name.
8.
Normalize means to replace separator characters with the default name-separator character so that the pathname is compliant with the underlying filesystem.
9.
You obtain the default name-separator character by accessing File’s separator and separatorChar class fields. The first field stores the character as a char and the second field stores it as a String.
10.
A canonical pathname is a pathname that’s absolute and unique, and it is formatted the same way every time.
11.
The difference between File’s getParent() and getName() methods is that getParent() returns the parent pathname and getName() returns the last name in the pathname’s name sequence.
12.
The answer is false: File’s exists() method determines whether or not a file or directory exists.
13.
A normal file is a file that’s not a directory and that satisfies other platform-dependent criteria: it’s not a symbolic link or named pipe, for example. Any nondirectory file created by a Java application is guaranteed to be a normal file.
14.
File’s lastModified() method returns the time that the file denoted by this File object’s pathname was last modified or 0 when the file doesn’t exist or an I/O error occurred during this method call. The returned value is measured in milliseconds since the Unix epoch (00:00:00 GMT, January 1, 1970).
15.
The answer is true: File’s list() method returns an array of Strings where each entry is a file name rather than a complete path.
16.
The difference between the FilenameFilter and FileFilter interfaces is as follows: FilenameFilter declares a single boolean accept(File dir, String name) method, whereas FileFilter declares a single boolean accept(String pathname) method. Either method accomplishes the same task of accepting (by returning true) or rejecting (by returning false) the inclusion of the file or directory identified by the argument(s) in a directory listing.
17.
The answer is false: File’s createNewFile() method checks for file existence and creates the file when it doesn’t exist in a single operation that’s atomic with respect to all other filesystem activities that might affect the file.
18.
The default temporary directory where File’s createTempFile(String, String) method creates temporary files can be located by reading the java.io.tmpdir system property.
19.
You ensure that a temporary file is removed when the virtual machine ends normally (it doesn’t crash and the power isn’t lost) by registering the temporary file for deletion through a call to File’s deleteOnExit() method.
20.
You would accurately compare two File objects by first calling File’s getCanonicalFile() method on each File object and then comparing the returned File objects.
21.
The purpose of the RandomAccessFile class is to create and/or open files for random access in which a mixture of write and read operations can occur until the file is closed.
22.
The purpose of the "rwd" and "rws" mode arguments is to ensure that any writes to a file located on a local storage device are written to the device, which guarantees that critical data isn’t lost when the system crashes. No guarantee is made when the file doesn’t reside on a local device.
23.
A file pointer is a cursor that identifies the location of the next byte to write or read. When an existing file is opened, the file pointer is set to its first byte at offset 0. The file pointer is also set to 0 when the file is created.
24.
The answer is false: when you call RandomAccessFile’s seek(long) method to set the file pointer’s value, and when this value is greater than the length of the file, the file’s length doesn’t change. The file length will only change by writing after the offset has been set beyond the end of the file.
25.
A stream is an ordered sequence of bytes of arbitrary length. Bytes flow over an output stream from an application to a destination, and flow over an input stream from a source to an application (do not mix up with streams from the Streams API).
26.
The purpose of OutputStream’s flush() method is to write any buffered output bytes to the destination. If the intended destination of this output stream is an abstraction provided by the underlying platform (such as a file), flushing the stream only guarantees that bytes previously written to the stream are passed to the underlying platform for writing; it doesn’t guarantee that they’re actually written to a physical device such as a disk drive.
27.
The answer is true: OutputStream’s close() method automatically flushes the output stream. If an application ends before close() is called, the output stream is automatically closed and its data is flushed.
28.
The purpose of InputStream’s mark(int) and reset() methods is to reread a portion of a stream. mark(int) marks the current position in this input stream. A subsequent call to reset() repositions this stream to the last marked position so that subsequent read operations reread the same bytes. Don’t forget to call markSupported() to find out if the subclass supports mark() and reset().
29.
You would access a copy of a ByteArrayOutputStream instance’s internal byte array by calling ByteArrayOutputStream’s toByteArray() method.
30.
The answer is false: FileOutputStream and FileInputStream don’t provide internal buffers to improve the performance of write and read operations.
31.
You would use PipedOutputStream and PipedInputStream to communicate data between a pair of executing threads.
32.
A filter stream is a stream that buffers, compresses/uncompresses, encrypts/decrypts, or otherwise manipulates an input stream’s byte sequence before it reaches its destination.
33.
Two streams are chained together when a stream instance is passed to another stream class’s constructor.
34.
You improve the performance of a file output stream by chaining a BufferedOutputStream instance to a FileOutputStream instance and calling the BufferedOutputStream instance’s write() methods so that data is buffered before flowing to the file output stream. You improve the performance of a file input stream by chaining a BufferedInputStream instance to a FileInputStream instance so that data flowing from a file input stream is buffered before being returned from the BufferedInputStream instance by calling this instance’s read() methods.
35.
DataOutputStream and DataInputStream support FileOutputStream and FileInputStream by providing methods to write and read primitive-type values and strings in a platform-independent way. In contrast, FileOutputStream and FileInputStream provide methods for writing/reading bytes and arrays of bytes only.
36.
Object serialization is a virtual machine mechanism for serializing object state into a stream of bytes. Its deserialization counterpart is a virtual machine mechanism for deserializing this state from a byte stream.
37.
The purpose of the Serializable interface is to tell the virtual machine that it’s okay to serialize objects of the implementing class.
38.
When the serialization mechanism encounters an object whose class doesn’t implement Serializable, it throws an instance of the NotSerializableException class.
39.
The three stated reasons for Java not supporting unlimited serialization are as follows: security, performance, and objects not amenable to serialization.
40.
You initiate serialization by creating an ObjectOutputStream instance and calling its writeObject() method. You initiate deserialization by creating an ObjectInputStream instance and calling its readObject() method.
41.
The answer is false: class fields are not automatically serialized.
42.
The purpose of the transient reserved word is to mark instance fields that don’t participate in default serialization and default deserialization.
43.
The deserialization mechanism causes readObject() to throw an instance of the InvalidClassException class when it attempts to deserialize an object whose class has changed.
44.
The deserialization mechanism detects that a serialized object’s class has changed as follows: every serialized object has an identifier, and the deserialization mechanism compares the identifier of the object being deserialized with the serialized identifier of its class (all serializable classes are automatically given unique identifiers unless they explicitly specify their own identifiers) and causes InvalidClassException to be thrown when it detects a mismatch.
45.
You can add an instance field to a class and avoid trouble when deserializing an object that was serialized before the instance field was added by introducing a long serialVersionUID = long integer value; declaration into the class. The long integer value must be unique, and it is known as a stream unique identifier (SUID).
46.
You customize the default serialization and deserialization mechanisms without using externalization by declaring private void writeObject(ObjectOutputStream) and void readObject(ObjectInputStream) methods in the class.
47.
You tell the serialization and deserialization mechanisms to serialize or deserialize the object’s normal state before serializing or deserializing additional data items by first calling ObjectOutputStream’s defaultWriteObject() method in writeObject(ObjectOutputStream) and by first calling ObjectInputStream’s defaultReadObject() method in readObject(ObjectInputStream).
48.
The difference between PrintStream’s print() and println() methods is that the print() methods don’t append a line terminator to their output, whereas the println() methods append a line terminator.
49.
PrintStream’s noargument void println() method outputs the line.separator system property’s value to ensure that lines are terminated in a portable manner (such as a carriage return followed by a newline/line feed on Windows, or only a newline/line feed on Unix/Linux).
50.
Java’s stream classes are not good at streaming characters because bytes and characters are two different things: a byte represents an 8-bit data item and a character represents a 16-bit data item. Also, byte streams have no knowledge of character sets and their character encodings.
51.
Java provides writer and reader classes as the preferred alternative to stream classes when it comes to character I/O.
52.
The purpose of the OutputStreamWriter class is to serve as a bridge between an incoming sequence of characters and an outgoing stream of bytes. Characters written to this writer are encoded into bytes according to the default or specified character encoding. The purpose of the InputStreamReader class is to serve as a bridge between an incoming stream of bytes and an outgoing sequence of characters. Characters read from this reader are decoded from bytes according to the default or specified character encoding.
53.
You identify the default character encoding by reading the value of the file.encoding system property.
54.
The purpose of the FileWriter class is to connect conveniently to the underlying file output stream using the default character encoding. The purpose of the FileReader class is to connect conveniently to the underlying file input stream using the default character encoding.
55.
Listing A-54 presents the Touch application that was called for in Chapter 12.

import java.io.File;

import java.util.Date;

public class Touch {

public static void main(String[] args) {

if (args.length != 1) {

System.err.println("usage: java Touch pathname");

return;

}

new File(args[0]).setLastModified(new Date().getTime());

}

Listing A-54

Setting a File or Directory’s Timestamp to the Current Time

56.
Listing A-55 presents the Copy application that was called for in Chapter 12.

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

public class Copy {

public static void main(String[] args) {

if (args.length != 2) {

System.err.println("usage: java Copy srcfile dstfile");

return;

}

BufferedInputStream bis = null;

BufferedOutputStream bos = null;

try {

FileInputStream fis = new FileInputStream(args[0]);

bis = new BufferedInputStream(fis);

FileOutputStream fos = new FileOutputStream(args[1]);

bos = new BufferedOutputStream(fos);

int b; // We chose b instead of byte because byte is a reserved word.

while ((b = bis.read()) != -1)

bos.write(b);

} catch (FileNotFoundException fnfe) {

System.err.println(args[0] + " could not be opened for input, or " +

args[1] + " could not be created for output");

} catch (IOException ioe){

System.err.println("I/O error: " + ioe.getMessage());

} finally {

if (bis != null)

try {

bis.close();

} catch (IOException ioe){

}

if (bos != null)

try {

bos.close();

} catch (IOException ioe){

}

Listing A-55

Copying a Source File to a Destination File with Buffered I/O

57.
Listing A-56 presents the Split application that was called for in Chapter 12.

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class Split {

private static final int FILESIZE = 1400000;

private static byte[] buffer = new byte[FILESIZE];

public static void main(String[] args){

if (args.length != 1) {

System.err.println("usage: java Split pathname");

return;

}

File file = new File(args[0]);

long length = file.length();

int nWholeParts = (int) (length / FILESIZE);

int remainder = (int) (length % FILESIZE);

System.out.printf("Splitting %s into %d parts%n", args[0],

(remainder == 0) ? nWholeParts : nWholeParts + 1);

BufferedInputStream bis = null;

BufferedOutputStream bos = null;

try {

FileInputStream fis = new FileInputStream(args[0]);

bis = new BufferedInputStream(fis);

for (int i = 0; i < nWholeParts; i++){

bis.read(buffer);

System.out.println("Writing part " + i);

FileOutputStream fos =

new FileOutputStream("part" + i);

bos = new BufferedOutputStream(fos);

bos.write(buffer);

bos.close();

bos = null;

}

if (remainder != 0) {

int br = bis.read(buffer);

if (br != remainder) {

System.err.println("Last part mismatch: expected " +

remainder + " bytes");

System.exit(0);

}

System.out.println("Writing part " + nWholeParts);

FileOutputStream fos = new FileOutputStream("part" +

nWholeParts);

bos = new BufferedOutputStream(fos);

bos.write(buffer, 0, remainder);

}

} catch (IOException ioe) {

ioe.printStackTrace();

} finally {

if (bis != null)

try {

bis.close();

} catch (IOException ioe) {

}

if (bos != null)

try {

bos.close();

} catch (IOException ioe) {

}

Listing A-56

Splitting a Large File into Numerous Smaller Part Files

Chapter 13: Accessing Networks

1.
A network is a group of interconnected nodes that can be shared among the network’s users.
2.
An intranet is a network located within an organization, and an internet is a network connecting organizations to each other.
3.
Intranets and internets often use TCP/IP to communicate between nodes. Transmission Control Protocol (TCP) is a connection-oriented protocol, User Datagram Protocol (UDP) is a connectionless protocol, and Internet Protocol (IP) is the basic protocol over which TCP and UDP perform their tasks.
4.
A host is a computer-based TCP/IP node.
5.
A socket is an endpoint in a communications link between two processes.
6.
A socket is identified by an IP address that identifies the host and by a port number that identifies the process running on that host.
7.
An IP address is a 32-bit or 128-bit unsigned integer that uniquely identifies a network host or some other network node.
8.
A packet is an addressable message chunk. Packets are often referred to as IP datagrams.
9.
A socket address is comprised of an IP address and a port number.
10.
The InetAddress subclasses that are used to represent IPv4 and IPv6 addresses are Inet4Address and Inet6Address.
11.
The loopback interface is a software-based network interface where outgoing data loops back as incoming data.
12.
The local host is represented by hostname localhost or by an IP address that’s commonly expressed as 127.0.0.1 (IPv4) or ::1 (IPv6).
13.
Sockets based on the Socket class are commonly referred to as stream sockets because Socket is associated with the InputStream and OutputStream classes.
14.
In the context of a Socket instance, binding makes a client socket address available to a server socket so that a server process can communicate with the client process via the server socket.
15.
A proxy is a host that sits between an intranet and the Internet for security purposes. Java represents proxy settings via instances of the java.net.Proxy class.
16.
The answer is false: the ServerSocket() constructor creates an unbound server socket.
17.
The difference between the DatagramSocket and MulticastSocket classes is as follows: DatagramSocket lets you perform UDP-based communications between a pair of hosts, whereas MulticastSocket lets you perform UDP-based communications between many hosts.
18.
The difference between unicasting and multicasting is as follows: unicasting is the act of a server sending a message to a single client, whereas multicasting is the act of a server sending a message to multiple clients.
19.
A URL is a character string that specifies where a resource (such as a web page) is located on a TCP-/IP-based network (such as the Internet). Also, it provides the means to retrieve that resource.
20.
A URN is a character string that names a resource and doesn’t provide a way to access that resource (the resource might not be available).
21.
The answer is true: URLs and URNs are also URIs.
22.
The equivalent of openStream() is to execute openConnection().getInputStream().
23.
The answer is false: you don’t need to invoke URLConnection’s void setDoInput(boolean doInput) method with true as the argument before you can input content from a web resource. The default setting is true.
24.
When it encounters a space character, URLEncoder converts it to a plus sign.
25.
The purpose of the URI class is to represent names (URNs) and resources (URLs). Also, it provides normalization, resolution, and relativization operations; the resulting URI can be converted into a URL as long as it represents a resource.
26.
The NetworkInterface class represents a network interface as a name and a list of IP addresses assigned to this interface. Furthermore, it’s used to identify the local interface on which a multicast group is joined.
27.
A MAC address is an array of bytes containing a network interface’s hardware address.
28.
MTU stands for maximum transmission unit. This size represents the maximum length of a message that can fit into an IP datagram without needing to fragment the message into multiple IP datagrams.
29.
The answer is false: NetworkInterface’s getName() method returns a network interface’s name (such as eth0 or lo), not a human-readable display name.
30.
InterfaceAddress’s getNetworkPrefixLength() method returns the subnet mask under IPv4.
31.
HTTP cookie (cookie for short) is a state object.
32.
It’s preferable to store cookies on the client rather than on the server because of the potential for millions of cookies (depending on a website’s popularity).
33.
The four java.net types that are used to work with cookies are CookieHandler, CookieManager, CookiePolicy, and CookieStore.
34.
Listing A-57 presents the enhanced EchoClient application that was called for in Chapter 13.

import java.io.BufferedReader;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.IOException;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.net.Socket;

import java.net.UnknownHostException;

public class EchoClient {

public static void main(String[] args) {

if (args.length != 1) {

System.err.println("usage : java EchoClient message");

System.err.println("example: java EchoClient "This is a test."");

return;

}

Socket socket = null;

try {

socket = new Socket("localhost", 9999);

OutputStream os = socket.getOutputStream();

OutputStreamWriter osw = new OutputStreamWriter(os);

PrintWriter pw = new PrintWriter(osw);

pw.println(args[0]);

pw.flush();

InputStream is = socket.getInputStream();

InputStreamReader isr = new InputStreamReader(is);

BufferedReader br = new BufferedReader(isr);

System.out.println(br.readLine());

} catch (UnknownHostException uhe) {

System.err.println("unknown host: " + uhe.getMessage());

} catch (IOException ioe) {

System.err.println("I/O error: " + ioe.getMessage());

}

finally {

if (socket != null)

try {

socket.close();

} catch (IOException ioe){

}

Listing A-57

Echoing Data to and Receiving It Back from a Server and Explicitly Closing the Socket

35.
Listing A-58 presents the enhanced EchoServer application that was called for in Chapter 13.

import java.io.BufferedReader;

import java.io.File;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.IOException;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

public class EchoServer {

public static void main(String[] args) {

System.out.println("Starting echo server...");

ServerSocket ss = null;

try {

ss = new ServerSocket(9999);

File file = new File("kill");

while (!file.exists()) {

Socket s = ss.accept(); // waiting for client request

try{

InputStream is = s.getInputStream();

InputStreamReader isr = new InputStreamReader(is);

BufferedReader br = new BufferedReader(isr);

String msg = br.readLine();

System.out.println(msg);

OutputStream os = s.getOutputStream();

OutputStreamWriter osw = new OutputStreamWriter(os);

PrintWriter pw = new PrintWriter(osw);

pw.println(msg);

pw.flush();

}catch (IOException ioe){

System.err.println("I/O error: " + ioe.getMessage());

}finally{

try {

s.close();

} catch (IOException ioe) {

}

}catch (IOException ioe){

System.err.println("I/O error: " + ioe.getMessage());

} finally {

if (ss != null)

try {

ss.close();

}catch (IOException ioe){

}

Listing A-58

Receiving Data from and Echoing It Back to a Client and Explicitly Closing the Socket After a kill File Appears

Chapter 14: Migrating to New I/O

1.
New I/O is a more powerful I/O architecture that supports memory-mapped file I/O, readiness selection, file locking, and more. This architecture largely consists of buffers, channels, selectors, regular expressions, and charsets, but it also could be considered to include a printf-style formatting facility.
2.
A buffer is an object that stores a fixed amount of data to be sent to or received from an I/O service (a means for performing input/output). It sits between an application and a channel that writes the buffered data to the service or reads the data from the service and deposits it into the buffer.
3.
A buffer’s four properties are capacity, limit, position, and mark.
4.
When you invoke Buffer’s array() method on a buffer backed by a read-only array, this method throws ReadOnlyBufferException.
5.
When you invoke Buffer’s flip() method on a buffer, the limit is set to the current position and then the position is set to zero. When the mark is defined, it is discarded. The buffer is now ready to be drained.
6.
When you invoke Buffer’s reset() method on a buffer where a mark has not been set, this method throws InvalidMarkException.
7.
The answer is false: buffers are not thread-safe.
8.
You create a byte buffer by invoking one of its allocate(), allocateDirect(), or wrap() class methods.
9.
A view buffer is a buffer that manages another buffer’s data.
10.
A view buffer is created by calling a Buffer subclass’s duplicate() method.
11.
You create a read-only view buffer by calling a Buffer subclass method such as ByteBuffer asReadOnlyBuffer() or CharBuffer asReadOnlyBuffer().
12.
ByteBuffer’s methods for storing a single byte in a byte buffer are ByteBuffer put(int index, byte b) and ByteBuffer put(byte b). ByteBuffer’s methods for fetching a single byte from a byte buffer are byte get(int index) and byte get().
13.
Attempting to use the relative put() method or the relative get() method when the current position is greater than or equal to the limit causes BufferOverflowException or BufferUnderflowException to occur.
14.
The answer is false: calling flip() twice doesn’t return you to the original state. Instead, the buffer has a zero size.
15.
The difference between Buffer’s clear() and reset() methods is as follows: the clear() method marks a buffer as empty, whereas reset() changes the buffer’s current position to the previously set mark or throws InvalidMarkException when there’s no previously set mark.
16.
ByteBuffer’s compact() method compacts a buffer by copying all bytes between the current position and the limit to the beginning of the buffer. The byte at index p = position() is copied to index 0, the byte at index p + 1 is copied to index 1, and so on until the byte at index limit() - 1 is copied to index n = limit() - 1 - p. The buffer’s current position is then set to n + 1 and its limit is set to its capacity. The mark, when defined, is discarded.
17.
The purpose of the ByteOrder class is to help you deal with byte-order issues when writing/reading multibyte values to/from a multibyte buffer.
18.
A direct byte buffer is a byte buffer that interacts with channels and native code to perform I/O. The direct byte buffer attempts to store byte elements in a memory area that a channel uses to perform direct (raw) access via native code that tells the operating system to drain or fill the memory area directly.
19.
You obtain a direct byte buffer by invoking ByteBuffer’s allocateDirect() method.
20.
A channel is an object that represents an open connection to a hardware device, a file, a network socket, an application component, or another entity that’s capable of performing write, read, and other I/O operations. Channels efficiently transfer data between byte buffers and I/O service sources or destinations.
21.
The capabilities that the Channel interface provides are closing a channel (via the close() method) and determining whether or not a channel is open (via the isOpen() method).
22.
The answer is true: a channel that implements InterruptibleChannel is asynchronously closeable.
23.
A file channel is a channel to an underlying file.
24.
An exclusive lock is a lock that prevents other file locks from being used within the region governed by the exclusive lock. In contrast, a shared lock is a lock that may apply to a region governed by other shared locks.
25.
The fundamental difference between FileChannel’s lock() and tryLock() methods is that the lock() methods can block and the tryLock() methods never block.
26.
The FileLock lock() method throws OverlappingFileLockException when either a lock is already held that overlaps this lock request or another thread is waiting to acquire a lock that will overlap with this request.
27.
The pattern that you should adopt to ensure that an acquired file lock is always released follows:
FileLock lock = fileChannel.lock();
try {
   // interact with the file channel
} catch (IOException ioe) {
   // handle the exception
} finally {
   lock.release();
}
28.
FileChannel provides the MappedByteBuffer map(FileChannel.MapMode mode, long position, long size) method for mapping a region of a file into memory.
29.
The answer is true: socket channels are selectable and can function in nonblocking mode.
30.
The answer is false: datagram channels are thread-safe.
31.
Socket channels support nonblocking mode because the blocking nature of sockets created from Java’s socket classes is a serious limitation to a network-oriented Java application’s scalability.
32.
You would obtain a socket channel’s associated socket by invoking its socket() method.
33.
You obtain a server socket channel by invoking ServerSocketChannel’s open() class method.
34.
A selector is an object created from a subclass of the abstract Selector class. It maintains a set of channels, which it examines to determine which of them are ready for reading, writing, completing a connection sequence, accepting another connection, or some combination of these tasks. The actual work is delegated to the operating system via a POSIX select() or similar system call.
35.
A regular expression (also known as a regex or regexp) is a string-based pattern that represents the set of strings that match this pattern.
36.
Instances of the Pattern class represent patterns via compiled regexes. Regexes are compiled for performance reasons; pattern matching via compiled regexes is much faster than if the regexes were not compiled.
37.
Pattern’s compile() methods throw PatternSyntaxException when they discover illegal syntax in their regular expression arguments.
38.
Instances of the Matcher class attempt to match compiled regexes against input text.
39.
The difference between Matcher’s matches() and lookingAt() methods is that unlike matches(), lookingAt() doesn’t require the entire region to be matched.
40.
A character class is a set of characters appearing between [ and ].
41.
There are six kinds of character classes: simple, negation, range, union, intersection, and subtraction.
42.
A capturing group saves a match’s characters for later recall during pattern matching.
43.
A zero-length match is a match of zero length in which the start and end indexes are equal.
44.
A quantifier is a numeric value implicitly or explicitly bound to a pattern. Quantifiers are categorized as greedy, reluctant, or possessive.
45.
The difference between a greedy quantifier and a reluctant quantifier is that a greedy quantifier attempts to find the longest match, whereas a reluctant quantifier attempts to find the shortest match.
46.
Possessive and greedy quantifiers differ in that a possessive quantifier only makes one attempt to find the longest match, whereas a greedy quantifier can make multiple attempts.
47.
The two main classes that contribute to the NIO printf-style formatting facility are Formatter and Scanner.
48.
The %n format specifier outputs a platform-specific line separator.
49.
Listing A-59 presents the enhanced Copy application that was called for in Chapter 14.

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.nio.ByteBuffer;

import java.nio.channels.FileChannel;

public class Copy {

public static void main(String[] args) {

if (args.length != 2){

System.err.println("usage: java Copy srcfile dstfile");

return;

}

FileChannel fcSrc = null;

FileChannel fcDest = null;

try {

FileInputStream fis = new FileInputStream(args[0]);

fcSrc = fis.getChannel();

FileOutputStream fos = new FileOutputStream(args[1]);

fcDest = fos.getChannel();

ByteBuffer buffer = ByteBuffer.allocateDirect(2048);

while ((fcSrc.read(buffer)) != -1){

buffer.flip();

while (buffer.hasRemaining())

fcDest.write(buffer);

buffer.clear();

}

}catch (FileNotFoundException fnfe){

System.err.println(args[0] +

" could not be opened for input, or " +

args[1] + " could not be created for output");

}catch (IOException ioe){

System.err.println("I/O error: " + ioe.getMessage());

} finally {

if (fcSrc != null)

try{

fcSrc.close();

} catch (IOException ioe) {

}

if (fcDest != null)

try {

fcDest.close();

} catch (IOException ioe) {

}

Listing A-59

Copying a File via a Byte Buffer and a File Channel

50.
Listing A-60 presents the ReplaceText application that was called for in Chapter 14.

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.regex.PatternSyntaxException;

public class ReplaceText {

public static void main(String[] args) {

if (args.length != 3){

System.err.println("usage: " +

"java ReplaceText text oldText newText");

return;

}

try {

Pattern p = Pattern.compile(args[1]);

Matcher m = p.matcher(args[0]);

String result = m.replaceAll(args[2]);

System.out.println(result);

} catch (PatternSyntaxException pse) {

System.err.println(pse);

}

Listing A-60

Replacing All Matches of the Pattern with Replacement Text

Chapter 15: Accessing Databases

1.
A database is an organized collection of data.
2.
A relational database is a database that organizes data into tables that can be related to each other.
3.
A database management system is a set of programs that enables you to store, modify, and extract information from a database. It also provides users with tools to add, delete, access, modify, and analyze data stored in one location.
4.
The answer is false: Derby’s embedded driver causes the database engine to run in the same virtual machine as the application.
5.
JDBC is an API for communicating with RDBMSs in an RDBMS-independent manner.
6.
A JDBC driver implements the java.sql.Driver interface.
7.
The answer is false: there are four kinds of JDBC drivers.
8.
A type 3 JDBC driver doesn’t depend on native code and communicates with a middleware server via an RDBMS-independent protocol. The middleware server then communicates the client’s requests to the data source.
9.
JDBC provides the java.sql.DriverManager class and the javax.sql.DataSource interface for communicating with a data source.
You obtain a connection to an Apache Derby data source via the embedded driver by passing a URL of the form jdbc:derby:databaseName;URLAttributes to one of DriverManager’s getConnection() methods.
10.
A SQL state error code is a five-character string consisting of a two-character class value followed by a three-character subclass value.
11.
The difference between SQLNonTransientException and SQLTransientException is as follows: SQLNonTransientException describes failed operations that cannot be retried without changing application source code or some aspect of the data source, and SQLTransientException describes failed operations that can be retried immediately.
12.
JDBC’s three statement types are Statement, PreparedStatement, and CallableStatement.
13.
The Statement method that you call to execute an SQL SELECT statement is ResultSet executeQuery(String sql).
14.
A result set’s cursor provides access to a specific row of data.
15.
The SQL FLOAT type maps to Java’s double type.
16.
A prepared statement represents a precompiled SQL statement.
17.
The answer is true: CallableStatement extends PreparedStatement.
18.
A stored procedure is a list of SQL statements that perform a specific task.
19.
You call a stored procedure by first obtaining a CallableStatement implementation instance (via one of Connection’s prepareCall() methods) that’s associated with an escape clause, by next executing CallableStatement methods such as void setInt( String parameterName, int x) to pass arguments to escape clause parameters, and by finally invoking the boolean execute() method that CallableStatement inherits from its PreparedStatement superinterface.
20.
Metadata is data about data.
21.
Metadata includes a list of catalogs, base tables, views, indexes, schemas, and additional information.

Chapter 16: Working with XML and JSON Documents

1.
XML (Extensible Markup Language) is a metalanguage for defining vocabularies (custom markup languages), which is key to XML’s importance and popularity.
2.
The XML declaration is special markup that informs an XML parser that the document is XML.
3.
The XML declaration’s three attributes are version, encoding, and standalone. The version attribute is nonoptional.
4.
The answer is false: an element can consist of the empty-element tag, which is a stand-alone tag whose name ends with a forward slash (/), such as <break/>.
5.
Following the XML declaration, an XML document is anchored in a root element.
6.
Mixed content is a combination of child elements and content.
7.
A character reference is a code that represents the character. The two kinds of character references are numeric character references (such as Σ) and character entity references (such as <).
8.
A CDATA section is a section of literal HTML or XML markup and content surrounded by the <![CDATA[ prefix and the ]]> suffix. You would use a CDATA section when you have a large amount of HTML/XML text and don’t want to replace each literal < (start of tag) and & (start of entity) character with its < and & predefined character entity reference, which is a tedious and possibly error-prone undertaking—you might forget to replace one of these characters.
9.
A namespace is a Uniform Resource Identifier–based container that helps differentiate XML vocabularies by providing a unique context for its contained identifiers.
10.
A namespace prefix is an alias for the URI.
11.
The answer is true: a tag’s attributes don’t need to be prefixed when those attributes belong to the element.
12.
A comment is a character sequence beginning with . A comment can appear anywhere in an XML document except before the XML declaration, except within tags, and except within another comment.
13.
A processing instruction is an instruction that’s made available to the application parsing the document. The instruction begins with <? and ends with ?>.
14.
The rules that an XML document must follow to be considered well formed are as follows: all elements must either have start and end tags or consist of empty-element tags, tags must be nested correctly, all attribute values must be quoted, empty elements must be properly formatted, and you must be careful with case. Furthermore, XML parsers that are aware of namespaces enforce two additional rules: all element and attribute names must not include more than one colon character; and no entity names, processing instruction targets, or notation names can contain colons.
15.
For an XML document to be valid, the document must adhere to certain constraints. For example, one constraint might be that a specific element must always follow another specific element.
16.
The two commonly used grammar languages are document type definition and XML Schema.
17.
SAX is an event-based API for parsing an XML document sequentially from start to finish. As a SAX-oriented parser encounters an item from the document’s infoset, it makes this item available to an application as an event by calling one of the methods in one of the application’s handlers, which the application has previously registered with the parser. The application can then consume this event by processing the infoset item in some manner.
18.
You obtain a SAX 2–based parser by calling one of the org.xml.sax.helpers.XMLReaderFactory class’s createXMLReader() methods, which returns an XMLReader instance.
19.
The purpose of the XMLReader interface is to describe a SAX parser. This interface makes available several methods for configuring the SAX parser and parsing an XML document’s content.
20.
You tell a SAX parser to perform validation by invoking XMLReader’s setFeature(String name, boolean value) method, passing " http://xml.org/sax/features/validation " to name and true to value.
21.
Ignorable whitespace is whitespace located between tags where the DTD doesn’t allow mixed content.
22.
The purpose of the org.xml.sax.helpers.DefaultHandler class is to serve as a convenience base class for SAX 2 applications. It provides default implementations for all of the callbacks in the four core SAX 2 handler interfaces: ContentHandler, DTDHandler, EntityResolver, and ErrorHandler.
23.
An entity is aliased data. An entity resolver is an object that uses the public identifier to choose a different system identifier. Upon encountering an external entity, the parser calls the custom entity resolver to obtain this identifier.
24.
DOM is an API for parsing an XML document into an in-memory tree of nodes and for creating an XML document from a tree of nodes. After a DOM parser has created a document tree, an application uses the DOM API to navigate over and extract infoset items from the tree’s nodes.
25.
You obtain a document builder by first instantiating DocumentBuilderFactory via one of its newInstance() methods and then invoking newDocumentBuilder() on the returned DocumentBuilderFactory instance to obtain a DocumentBuilder instance.
26.
You use a document builder to parse an XML document by invoking one of DocumentBuilder’s parse() methods.
27.
You use a document builder to create a new XML document by invoking DocumentBuilder’s Document newDocument() method and by invoking Document’s various “create” methods.
28.
When creating a new XML document, you cannot use the DOM API to specify the XML declaration’s encoding attribute.
29.
XPath is a non-XML declarative query language (defined by the W3C) for selecting an XML document’s infoset items as one or more nodes.
30.
XSLT is a family of languages for transforming and formatting XML documents.
31.
JSON stands for JavaScript Object Notation and is a format for data exchange between web pages and servers or between servers and other servers
32.
The solution is shown in Listing A-61.

{

"title": "Grilled Cheese Sandwich",

"ingredients" : [

"bread slice",

"cheese slice",

"margarine pat"

"instructions" :

"Place frying pan on element ..."

}

Listing A-61

The JSON Code

33.
The solution is shown in Listing A-62.

Map<String, Object> properties = new HashMap<String, Object>() {{

put(JsonGenerator.PRETTY_PRINTING, true);

}};

JsonGeneratorFactory jgf = Json.createGeneratorFactory(properties);

StringWriter sw = new StringWriter();

JsonGenerator jg = jgf.createGenerator(sw);

jg.writeStartObject()

.write("title", "Grilled Cheese Sandwich")

.writeStartArray("ingredients")

.write("bread slice")

.write("cheese slice")

.write("margarine pat")

.writeEnd()

.write("instructions", "Place frying pan ...")

.writeEnd()

.close();

String json = sw.toString();

Listing A-62

Writing JSON from Java

34.
The solution is shown in Listing A-63.

{

"title": "Grilled Cheese Sandwich",

"ingredients" : [

{ "name" : "bread slice", quantity: 2 },

{ "name" : "cheese slice" },

{ "name" : "margarine pat", quantity: 2 }

"instructions" : "Place frying pan ..."

}

Listing A-63

Adjusted JSON Code

35.
The solution is shown in Listing A-64.

public class Recipe {

static public class Ingredient {

public String name;

pubic int quantity = 1;

// constructors, getter, setter, ...

}

public String title;

public List<Ingredient> ingredients;

public String instructions;

// constructors, getter, setter, ...

}

Recipe r = new Recipe() {{

ingredients = new ArrayList<Ingredient>();

ingredients.add(new Ingredient(){{ name="bread slice"; quantity=2; }});

ingredients.add(new Ingredient(){{ name="cheese slice"; }});

ingredients.add(new Ingredient(){{ name="margarine pat"; quantity=2; }});

instructions = "Place frying pan ...";

}};

String json = JsonbBuilder.create(

new JsonbConfig().withFormatting(true)).toJson(r);

System.out.println(json);

Listing A-64

Converting from Java to JSON

36.
The solution is shown in Listing A-65.

String json = "...";

try {

Jsonb jsonb = JsonbBuilder.create();

Recipe r = jsonb.fromJson(new StringReader(json), Recipe.class);

System.out.print(r.title);

}catch(Exception e) {

e.printStackTrace(System.err);

}

Listing A-65

Converting from JSON to Java

Chapter 17: Date and Time

1.
A date is a recorded temporal moment, a time zone is a set of geographical regions that share a common number of hours relative to Greenwich Mean Time (GMT), and a calendar is a system of organizing the passage of time.
2.
The Date class represents a date as a positive or negative milliseconds value that’s relative to the Unix epoch (January 1, 1970 GMT).
3.
You obtain a calendar for the default locale that uses a specific time zone by invoking the Calendar getInstance(TimeZone zone) factory method.
4.
The answer is false: Calendar declares a Date getTime() method that returns a calendar’s time representation as a Date instance.
5.
You would obtain a date formatter to format the time portion of a date in a particular style for the default locale by invoking the DateFormat getTimeInstance(int style) factory method.
6.
Wrong. LocalDate’s granularity is day.
7.
Wrong. If you want to have the time zone or a time offset included, you must use ZonedDateTime or OffsetDateTime.
8.
The solution is shown in Listing A-66. The ‘T’ in the format string is enclosed in single quotation marks to mark it as a literal character.

SimpleDateFormat sdf = new SimpleDateFormat(

"yyyy-MM-dd'T'HH:mm:ss.SSS");

System.out.println(sdf.format(new Date()));

Listing A-66

Formatting Date and Time

9.
The solution is shown in Listing A-67.

DateTimeFormatter dtf = DateTimeFormatter.ofPattern(

"yyyy-MM-dd'T'HH:mm:ss.SSS");

System.out.println(LocalDateTime.now().format(dtf));

Listing A-67

Formatting Date and Time Using the New API

10.
Use System.out.println(Clock.systemUTC().millis());.
11.
The solution is shown in Listing A-68. The zone ID must be added in this case; otherwise, we’d get a ParseException.

DateTimeFormatter dtf2 = DateTimeFormatter.

ofPattern("yyyy-MM-dd HH:mm:ss z");

ZonedDateTime zdt = ZonedDateTime.

parse("2020-01-10 22:16:45"

+ " " + ZoneId.systemDefault().toString(),

dtf2);

System.out.println(zdt);

Listing A-68

Parsing a Date and Time String

12.
Write LocalDateTime ldt = zdt.toLocalDateTime();.
13.
The solution is shown in Listing A-69. The zone ID must be added in this case; otherwise, we’d get a ParseException.

DateTimeFormatter dtf3 = DateTimeFormatter.ofPattern(

"yyyy-MM-dd HH:mm:ss z");

ZonedDateTime zdt2 = ZonedDateTime.parse("2020-01-10 22:16:45"

+ " +00:00", // <- ParseException without that

dtf3);

System.out.println(zdt2);

Listing A-69

Parsing a Date and Time String

14.
The solution is shown in Listing A-70.

DateTimeFormatter dtf4 = DateTimeFormatter.ofPattern(

"yyyy-MM-dd HH:mm:ss");

LocalDateTime ldt4 = LocalDateTime.parse(

"2020-01-10 22:16:45",

dtf4);

LocalDateTime ldt5 = LocalDateTime.parse(

"2020-01-12 13:10:45",

dtf4);

System.out.println( Duration.between(ldt4, ldt5).getSeconds() );

Listing A-70

Calculating a Duration

15.
The solution is shown in Listing A-71.

import java.time.Clock;

import java.time.Duration;

import java.time.Instant;

import java.time.ZoneId;

public class ClockTwiceAsFast extends Clock {

private Instant myStartInstant;

public ClockTwiceAsFast() {

myStartInstant = Clock.systemUTC().instant();

}

@Override

public Clock withZone(ZoneId zone) {

return this;

}

@Override

public ZoneId getZone() {

return ZoneId.of("Z");

}

@Override

public Instant instant() {

Duration dur2 = Duration.between(myStartInstant,

Clock.systemUTC().instant()).

multipliedBy(2L);

return myStartInstant.plus(dur2);

}

Listing A-71

A Twice-As-Fast Clock

Index

Abstract classes and methods

abstract reserved word

graphics class

instantiating shape

shape class

Advanced language features

annotations

SeeAnnotations

anonymous class

enums

SeeEnumerated type

exceptions

SeeExceptions

generics

SeeGenerics

import statement

local class

mastering packages

nested types

nonstatic member classes

packages

SeePackages

static imports

static member classes

within classes

allocate() class method

American Standard Code for Information Interchange (ASCII)

Android

APIs

application framework

C/C++ libraries

Dalvik virtual machine

description

Google

HelloWorld

implementation

Java code

Java programming language

layered architecture

Linux kernel

Linux process

mobile devices

permissions

runtime environment

sandbox

security model

software stacks

user interface screen

virtual machine

android.database.sqlite packages

Annotations

declaration

element

stub annotation type

stubbed-out method

stub instance’s value() element

stub instance’s elements

@deprecated annotations

deprecated field

description

@override annotations

processing

StubFinder application

throws exception

retention policies

@Stub annotations

@suppresswarnings annotations

Application program interfaces (APIs)

Android

arrays and collections utility

binary search

collections class

linear search

methods

Java Android

JDK 7 documentation

legacy collection

BitSet

dictionary

hashtable

stack

vector

software library

arraycopy() method

ArrayDeque

definition

stack

Array index operator ([])

ArrayList

constructors

demonstration

description

Array type

Assignment operator (=)

Atomic variables

classes

getNextID() class method

synchronization

Autoboxing

Base problem

Basic APIs

absolute values, byte and short integers

BigDecimal

SeeBigDecimal

BigInteger

circumstances

exploring number

overloaded methods

primitive type wrapper classes

Boolean

character

float and double

integer, long, short, and byte

String objects

constructors and methods

description

iteration

StringBuffer

constructors and methods

demonstration

StringBuilder

fragment code

initialization code

synchronization

checking account

deadlock

mutual exclusion, monitors, and locks

object

output

race condition

thread-local variables

visibility

waiting and notification

system methods

threads

description

joining default thread with background thread

methods

Runnable, Thread(Runnable runnable), currentThread(), getName(), and start()

thread sleep

void run() method

Windows 7 platform

BigDecimal

based invoice calculations

class

constants

double/float

floating-point-based invoice calculations

floating-point calculations

InvoiceCalc

RoundingMode constants

salesTaxPercent

BigInteger

description

factorial() methods

output

Bitwise operators

boolean isInfinite() method

boolean isNaN() method

boolean isOpen() methods

Boolean primitive type wrapper class

BufferedOutputStream and BufferedInputStream

ByteArrayOutputStream and ByteArrayInputStream

Byte-order mark (BOM)

CallableStatement

Connection’s prepareCall() methods

cstmt.execute() method

definition

Derby syntax

Camel casing

Cast operator

compound expressions application

description

primitive-type conversions

16-bit unsigned character values

Channels, NIO

asynchronously closeable

bytes coping, standard input/output streams

data transfer

definition

direct byte buffer

implementation methods

interruptible

I/O classes

java.nio.channels package

ReadableByteChannel

shut down

WritableByteChannel

Character encoding

Character, primitive type wrapper classes

Character set

Checked exception

Classes

application

arrays

creation syntax

element initialization

initialization

multidimensional

object references

ragged array

behaviors representation via methods

class initializers

class methods

dumpMatrix()

header

public static void main(String[] args)

syntax

declaration

garbage collector

hiding information

client code

contract

equality determination

getters

helper methods

implementation

interface separation

Java support

private methods

protected

public

related language feature

revising implementation

setters

initialization order

instance initializers

objects and

application

argument

construction syntax

default constructor

explicit constructors

noargument constructor

parameter

reference variables

return statement

chaining instance method calls

instance method

Java

setName() instance method

syntax

state and behaviors encapsulation

field-access rules

fields, declaration and access

instance field, declaration and access

SeeInstance field

instance methods

method-invocation rules

overloading methods

pass-by-value passes

recursion

state via fields

Class field initializer

Classic I/O APIs

File instance

filesystem

SeeFilesystem

java.io package

RandomAccessFile API

standard I/O

streaming sequences

writers and readers

SeeWriters and readers

Class initializers

Classloader

Clock

clone() method

Collections framework

addAll() method

add method

comparable vs. comparator

core interfaces

description

hierarchy

definition

elements

implementation classes

iterable and collection

methods

utility classes

Collector.of() function

comparator() method

CompareTo() method

Compile-time constant

Composition

Compound expression

definition

operators

Concurrency utilities

atomic variables

concurrent collections

java.util.concurrent package

properties

thread-safe collections

Condition interface

definition

executors

lock

low-level threads API, problems

packages

ReentrantLock class

synchronizers

Conditional operators

Constructors method

CookieHandler getDefault() class method

CookieManager class

CookieHandler class

CookieManager, objects

description

HTTP protocol handler

HTTP response

listing

copy() method

copyAlt() method

Covariant return type

definition

demonstration

upcasting and downcasting

createStatement() method

createTempFile() methods

Database management system (DBMS)

Databases, accessing

Java DB

SeeJava DB

Java supports database

JDBC

SeeJava Database Connectivity (JDBC

SQLite

Data definition language (DDL)

DatagramPacket class

DatagramSocket

client context

DatagramPacket(byte[] buf, int length)

DatagramSocket() constructor

DatagramSocket(int port) constructor

definition

EchoClient

main() method

void receive(DatagramPacket dgp)

void send(DatagramPacket dgp)

DataOutputStream and DataInputStream

Date constructors and methods

Dates, Time Zones, and Calendars

Deadlock

Default noargument constructor

deleteOnExit() method

@Deprecated annotations

Deques

array deque

definition

methods

queue/equivalent methods

distinct() stream method

Document object model (DOM)

advantages, SAX

creating XML document

DocumentBuilder

outputs

creating XML documents

DocumentBuilder

DOMDemo

exploring DOM API

levels

nodes

attribute

comment

document type

element node

entity

entity reference

leaf node

notation

parent node

processing instruction node

section

text node

parsing XML document

DOMDemo

node methods

XML content

validation

Document type definition (DTD)

Double’s equals() method

doubleToIntBits() method

Downcasting

array

DowncastDemo

trouble

Drawable interfaces

declaration

draw() method

implementation

DumpArgs

command-line interface

javac

for loop

main()

source code

System.out.println(args[i])

dumpMatrix() class method

Duration and periods

EchoClient

EchoServer

EchoText

Boolean

command-line arguments

javac

main()

outputting text

standard input stream

System.in.read()

System.out.println()

while loop

Employee’s main() method

Employees database creation

Encapsulation

EnclosingClass

encode() method

Enterprise Edition (EE)

Enumerated type

class

compile-time type safety

description

enhancement

extending class

switch statement

traditional

EnumMap

Enums, 1range

EnumSet

Equality operators

Equals() method

hashCode() method

point objects

relation, nonnull object references

equalTo() method

Exceptions

cleanup

custom exception classes

description

error

handling

resource management

rethrowing

source code representations

error codes vs. objects

throwable class hierarchy

throwing

types

Executors

class’s static methods, tasks

definition

interface

“obtain word entries” task

Expressions

compound

description

simple

SeeSimple expressions

Extending classes

inheriting members

multiple implementation inheritance

overriding a method

relating two classes

Extensible Markup Language (XML)

ASCII character

character references

CDATA section

description

embedded XML document

entity

numeric

SVG

comments

declaration

description

DOM, parsing and creating

DTD

elements and attributes

child elements

mixed content

root element

tree structure

grammar document

HTML documents

namespaces

default

description

Google Chrome

pair

prefix

rules

URI-based container

well-formed documents

XHTML language

non-ASCII character

processing instruction

SAX, parsing

schema

definition

target

valid document

vocabulary documents

Externalization

factorial() method

File locking

FileOutputStream and FileInputStream

Filesystem

construction

creation/manipulation

description

Dir(ectory) application

disk space information

DumpRoots application

File object’s abstract pathname

java.io.File class

pathname’s file/directory

setting/getting permission

specify java Dir c:windows exe

stored abstract pathname

filter() method

Filter input stream

Filter output stream

Finalization

definition

super.finalize()

First-In, First-Out (FIFO) queue

flatMap*() method

Float’s equals() method

floatToIntBits() method

flush() method

forEach() method

Formatters

Formatter’s Appendable out() method

Functional programming

collection

definition

distinct

filtering

functions

lambda calculus

limiting

mapping

methods as functions

operators

parallelization

performing actions

protonpack

ranges

reduction

single-method interfaces

skipping

sorting

streams

stream utility

Garbage collector

referenced object

unreferenced object

Generics

and arrays

generic type

actual type argument

declaration and using

description

output

parameter bounds

parameterized types

parameter scope

raw type

wildcards

methods

copyList generic method

formal_type_parameter_list

generic constructors

type inference algorithm

type safety

getBoolean() method

getCookieStore()

getDatabaseMajorVersion() method

getFreeSpace() method

getInterfaceAddresses() method

getLength() method

getMethods() method

getMTU() method

getSharedChar() method

getUsableSpace() method

Greedy quantifier

Greenwich Mean Time (GMT)

hashCode() method

Hash codes

hashing

Java documentation

Hash map

collision

demonstration

hash function

load factor

HashSet, description

HyperText Markup Language (HTML)

HyperText Transfer Protocol (HTTP)

Identifiers

Identity check

If-else statement

Boolean expression

conditional operator

dangling-else problem

GradeLetters application

Embedded ij script session

Implementation inheritance

vs. composition

InetAddress class

InetSocketAddress

Inheritance

definition

implementation

interface

single and multiple

Inner classes

Instance field

blank final

Car Class declaration

constant

direct access

Employee class, constant declaration

initialization via constructors

initializer

lifetime

nonzero default value

scope

syntax

instanceMethod1() method

instanceMethod2() method

Instants

Integrated development environment (IDE)

command-line arguments

DumpArgs

Eclipse user interface

JDK’s tools

JRE System Library items

Program arguments

splash screen

version 4.3.1

welcome tab

workbench

workspace

Interface inheritance

Interfaces

agile software development

declaration

drawable interface

extending

formalizing class

implementation

profiling

International Electrotechnical Commission (IEC)

International Organization for Standardization (ISO)

Internet Assigned Names Authority (IANA)

Internet Protocol (IP)

Intersection character class

int getDatabaseMinorVersion() method

InvalidMediaFormatException class

isAcceptable() method

iterator() method

Iterator interface

autoboxing and unboxing

enhanced for loop statement

methods

iterator() method

J, K

Java

APIs

bytecode

C and C++

class file

classloader

description

enums

1range

execution environment

IDE

SeeIntegrated development environment (IDE

implementation sizes

interpretation

JDK

SeeJava SE Development Kit (JDK

JIT compilation

JNI

JVM

loops and expressions

object code

operators

portability

secure environment

single-line and multi-line

source code

standard class library

sun microsystems

Java 6

boolean setExecutable(boolean executable)

boolean setExecutable(boolean executable, boolean ownerOnly)

boolean setReadable(boolean readable)

boolean setReadable(boolean readable, boolean ownerOnly)

boolean setWritable(boolean writable)

boolean setWritable(boolean writable, boolean ownerOnly)

long getFreeSpace() returns

long getTotalSpace() returns

long getUsableSpace() returns

Java DB

command-line tools

demos

embedded database engine, start up/shut down

embedded driver

embedded mode, Derby

installation and configuration

multiple clients communication

starting, Apache Derby server

java.lang.Math class

java.lang.Number class

java.lang.Object class

java.lang.reflect package

Java native interface (JNI)

java.nio.Buffer class

JavaScript Object Notation (JSON)

builder pattern

configuration property

constructor

description

parsing

processing

vs. XML

Java SE Development Kit (JDK)

Android

SeeAndroid

APIs

App.class

brace characters

Command-line interface

documentation

DumpArgs

EchoText

HelloWorld.class

home directory

IDE

Javac

line feed

main()

public class

source code

static and void

String[] args

System.out.println

java.text.NumberFormat class

java.util.concurrent.atomic package

java.util.concurrent.locks package

java.util.regex.Pattern class

Java virtual machine (JVM)

Java Database Connectivity (JDBC)

DataSource

DriverManager

drivers types

Java 7

statements

CallableStatement

definition

executeQuery() method

JDBCDemo application

methods

PreparedStatement

ResultSet

SQL Type/Java type mappings

URLAttributes

URL syntax

Xerial SQLite driver

Join group operation

JsonGenerator.PRETTY_PRINTING property

Just-in-time (JIT)

Lambda calculus

Last-In, First-Out (LIFO) queue

Learning language fundamentals

application structure

comments

description

Javadoc

multiline

single-line

description

expressions

SeeExpressions

identifiers

operators

SeeOperators

precedence and associativity

32-bit integer

compound expression

interprets

open and close parentheses

public class CompoundExpressions

statements

SeeLearning statements

types

array

data items

integers

user-defined

variables

Learning statements

assignment

break and labeled break

employee search application

infinite loop

compound

continue statement

decision

do-while statement

empty

If-else

SeeIf-else statement

if statement

labeled continue

loop

for statement

simple

switch

while statement

Leave group operation

Lempel-Ziv-Welch (LZW)

Lexicographic/dictionary

Linear congruential generator

LineNumberInputStream

List

ArrayList

description

LinkedList

methods

listIterator() method

Local class

Local dates and times

Locking

Locking framework

condition

methods

lock

acquisition and release

methods

ReadWriteLock

ReentrantReadWriteLock

constructors

methods

Logger’s connect() method

LoggerFactory abstract class

Logging message

Logical operators

LongStream class

main() method

map*() methods

Maps

collection views

EnumMap

entry methods

hash map

IdentityHashMap

navigable maps

SeeNavigable maps

TreeMap

WeakHashMap

Math class’s random() method

Member access operator (.)

Memory-mapped file I/O

Meta-annotations

Metadata

CATALOG and SCHEMA

employee Data Source

function escape clause

SQL

SYS schema stores

Method call operator()

Method class

1range

Method-invocation stack

Method overloading

Multicasting

definition

group address

Multidimensional arrays

Multiplicative operators

Multipurpose Internet Mail Extensions [MIME] type

Mutual exclusion

NamedNodeMap getAttributes() method

Native instructions

Natural ordering

Navigable maps

definition

methods

Navigable sets

description

tree set

Negation character class

NetworkInterface

description

enumeration

javac NetInfo.java

methods

NetworkInterfaceAddress

enumeration

methods

NetInfo

Network interface card (NIC)

New I/O

buffer

byte-oriented buffer logical layout

definition

demonstration

documentation

java.nio package

properties

channels

SeeChannels, NIO

charsets

BOM

byte sequences

character-encoding scheme

character set

coded character set

code point

definition

IANA

standards

string class

Unicode

definition

formatter

constructors

conversions

demonstration

output

printf()

problem solving ways

syntaxes

void close() method

regular expressions

SeeRegular expressions

scanner

constructors

delimiter pattern

selectors

attachment

code fragment

definition

interest set

key

nonblocking mode

readiness selection

ready set

receiving time, server

SelectableChannel registration methods

selectable channels

selected keys

server socket channel

serving time to client

source code

streams

tasks

Nonstatic member class

declaration

description

instance method

NumberFormat’s format() method

NumberFormat getCurrencyInstance() method

Object-based language

Objects creation

SeeClasses

Object serialization

Object type

Offset dates and times

Operators

additive

array index

assignment

bitwise

cast

SeeCast operator

conditional

equality

logical

member access

method call

multiplicative

object creation

relational

shift

unary minus/plus

outputList() method

OutputStreamWriter’s write() methods

@Override annotations

Packages

description

and JAR files

names

playing

searching

compile-time search

runtime search

statement

structure

Parallelism

Parallelization

parse() method

parseObject() methods

Parsing

Pass-by-value

Pathname

Performance, reflection

PipedOutputStream and PipedInputStream

Polymorphism

coercion

description

overloading

parametric

subtype

Portable Network Graphics (PNG)

Possessive quantifier

Predefined character class

Preincrement and postdecrement operators

PreparedStatement

Primitive types

binary vs. decimal

definition

minimum and maximum values

twos-complement representation

Primitive type wrapper classes

Boolean

definition

printDetails() instance method

PrintStream

description

features

print() and println() methods

stream classes

void println() method

PriorityQueue

comparator

description

integers

ordering elements

PrivateAccess class

Protocol stack

Protonpack

Pseudorandom numbers

public boolean isNaN() method

public static void main(String[] args) method

Queues

First-In, First-Out (FIFO) queue

Last-In, First-Out (LIFO) queue

methods

PriorityQueue

SeePriorityQueue

Race condition, threads

Ragged array

Random

array of integers, shuffling

boolean nextBoolean()

double nextDouble() method

double nextGaussian()

float nextFloat()

int nextInt()

int nextInt(int n)

linear congruential generator

long nextLong()

pseudorandom numbers

random(long seed)

random number generators

void nextBytes(byte[] bytes)

RandomAccessFile API

description

stream

SeeStreams

Range character class

Readiness selection

Rectangle class

reduce() function

Reflection

array

class methods

class object

decompileClass() method

decompiler tool

forName() method

getClass() method

dynamically loaded class

newInstance() method

VideoPlayer class

field

class

main() method

method

class

main()

package

manifest.mf

obtaining information

performance

Regular expressions

boundary matchers

capturing groups

character classes

definition

matcher methods

ox regex

period metacharacter

playing with

practical

quantifier

zero-length matches

Reification

Relational DBMSs (RDBMSs)

Reluctant quantifier

ResultSet getCatalogs() method

ResultSet getSchemas() method

Root directory

Runnable’s run() method

Runtime exception

Runtime type identification (RTTI)

SavingsAccount class

Scalable Vector Graphics (SVG)

Scrambling

output, fonts yield

stream of bytes

select() method

SelectableChannel class

Selector open() class method

ServerSocket

accept() method

communication

echoing data

setCookiePolicy()

setName() instance method

Sets

EnumSet

HashSet

navigable sets

SeeNavigable sets

sorted sets

SeeSorted sets

TreeSet

SeeTreeSet

setScale() method

setSharedChar() method

Shallow cloning

Shuffle() methods

Simple API for XML (SAX)

Handler

ignorable whitespace

methods

ControlHandler

lexicalHandler

XMLReader object

SAXDemo

svg-examples

validation

Simple character class

Simple expressions

application

array initializers

Boolean and character literal

counter variable

escape sequences

floating-point literal

integer literal

literals

null literal

one and two-dimensional array

primitive-type conversions via widening conversion rules

string literal

void method

Single-line comment

Single-method Interfaces

Socket

InputStream getInputStream() method

OutputStream getOutputStream() method

Socket-suffixed classes

Socket

echoing data

InetAdress dstAdress, int dsPort

network management software

options

packets

processes

String dsName, int dsPort

void close() method

SocketAddress

Sorted maps

definition

methods

Sorted sets

TreeSet

SQLite

Standard Edition (SE)

Static member class

class and instance methods

declaration

description

multiple implementations

rectangle implementations

Streams

BufferedOutputStream and BufferedInputStream

ByteArrayOutputStream and ByteArrayInputStream

DataOutputStream and DataInputStream

FileOutputStream and FileInputStream

FilterOutputStream and FilterInputStream

java.io package

LineNumberInputStream and StringBufferInputStream

output and input

PipedOutputStream and PipedInputStream

PrintStream

serialization and deserialization

DataOutputStream and DataInputStream classes

default

virtual machine mechanism

Stream utility

String

Table of Contents for Back Matter

Create new playlist

Sign In

Sign Up

Table of Contents for
Back Matter