This edition retains contemporary topics from earlier editions that define a coherent approach to the implementation and use of data structures in Java. These topics, listed below, have been updated to align with the latest software engineering practices suggested by the designers and implementors of Java 2 Standard Edition 7.0. The most important of these topics are listed here:

Better input/output support (Chapter 1 and Appendix B) continues in this edition, including formatted output (with the System.out.printf method) and the input of primitive values (with the java.util.Scanner class). Earlier input and output classes (EasyReader and Format-Writer) are available online at http://www.cs.colorado.edu/~main/
Earlier integration of the Java Class Libraries begins in Chapter 2 of this edition. Although the emphasis of this textbook remains on the underlying design and implementation of classic data structures, we’ve found it increasingly important to give students significant exposure to the elements of class libraries. We begin this process in Section 2.5 with the easy-to-use BigInteger class. Chapters 3 to 5 give more examples that use the Java Class Libraries including Arrays, HashSet, ArrayList, LinkedList, ListIterator and others.
A modified approach to generic collection classes occurs in Chapter 5 of this edition. Starting with J2SE 5.0, generic methods and generic classes allowed libraries to depend on an unspecified underlying data type (that we’ll call E. Originally, collection classes were often implemented with arrays in which the component type was an unspecified generic type (i.e., a private member variable of type E []).
Over the years, it was recognized that the E [] practice had a potential pitfall: We could use a typecast to pretend that we had that kind of array, but at run time, the program really had an array of Java objects (i.e., a private member variable of type Object [] which by design contains only E (objects). Within the generic class itself, this type mismatch did not cause a problem (because generic types are not checked at run time). But if the generic class provides the array to an outside application, then the possibility of a runtime type error existed.
The solution, eloquently written about by Neal Gafter, is for the generic class to use an array of Java objects (rather than an array of type E [] along with specific programming practices (described in Chapter 5) that ensure that unchecked typecasts cannot lead to runtime type errors. Starting in Chapter 5 and continuing throughout the rest of the textbook, we now use this new approach for all of our generic classes.
Variable arity methods (Chapter 3) allow a method to have a variable number of arguments. Generic classes have special considerations for variable arity methods that are newly discussed in Chapter 5 of this edition.
Enhanced for-loops (Chapters 3 and 5) were introduced in the previous edition of this textbook. They allow easy iteration through the elements of an array, through a collection of elements that has implemented the Iterable interface, or through the elements of an enum type.
Autoboxing and auto-unboxing of primitive values (Chapter 5) continue to be used in this edition to allow the storage and retrieval of primitive data values (such as an int) in Java’s generic collections (such as the Vector).
Java’s priority queue (Chapter 7) has been added as a new topic in the fourth edition.
The binary search and sort methods from the Java Class Libraries have a new presentation in Chapters 11 (searching) and 12 (sorting).
The important new topic of concurrency is introduced through a concurrent sort in Chapter 12. The approach uses the RecursiveAction and ForkJoinPool classes from Java2SE 7, which provides an extremely clean introduction with very few distractions for the first-year student.
Covariant return types allow the return type of an overridden inherited method to be any descendant class of the original return type. We use this idea for clone methods throughout the text, thereby avoiding a typecast with each use of a clone method and increasing type security. The larger use of the technique is postponed until the chapter on inheritance (Chapter 13).
Enum types (Chapter 13) provide a convenient way to define a new data type whose objects may take on a small set of discrete values.

Data Structures and Other Objects Using Java, 4th edition

VitalSource eTextbook

Access details

Features

Paperback

Details

Explore

Products & Services

Support

Extend Your Learning

About us