Old Edition
New Edition
Big Java 1st Edition
Computing Concepts with Java Essentials 3rd edition
Big Java 2nd Edition
Java Concepts 4th edition
"Computing" and "Essentials" dropped from title
Chapter 1: Introduction
Chapter 1: Introduction

1.1: What is a computer?
1.1: What is programming Sections are merged
1.2: What is programming?

1.3: The anatomy of a computer
1.2: The anatomy of a computer Updated to reflect 2004 technology
1.4: Translating human-readable programs to machine code
1.3: Translating human-readable programs to machine code
1.5: Programming languages

1.6: The Java programming language
1.4: The Java programming language Added information on Java versions
1.7: Becoming familiar with your computer
1.5: Becoming familiar with your computer Screen shots have been updated; now use Eclipse
1.8: Compiling a simple program
1.6: Compiling a simple program Program is now called HelloTester (The Tester suffix is used throughout the book since the old Test suffix conflicts with the JUnit support in BlueJ)
The advanced topic "Escape sequences" has been moved to chapter 4
1.9: Errors
1.7: Errors

1.10: The compilation process
1.8: The compilation process
Chapter 2: An Introduction to Objects and Classes
Chapter 2: Using Objects
This chapter has been split into two chapters, on using objects of existing classes and on implementing new classes.

2.1: Types and variables In the old edition, these topics were explained very briefly and then fully introduced in chapter 3.

2.2: The assignment operator

2.3: Objects, classes, and methods
Two new sections that explains these topics in great detail

2.4: Method parameters and return values

2.5: Number types
This material was previously in section 3.10
2.1: Using and constructing objects
2.6: Constructing objects

2.7: Accessor and mutator methods
This material was previously in section 7.3
2.2: Object variables
2.8: Implementing a test program Some of the material is now in section 2.10

2.9. The API documentation
This section explains how to read the documentation for existing classes

2.10. Object references
This material was previously in section 2.2

Chapter 3: Implementing classes

3.1: Black boxes
This new section explains the difference between using and implementing classes and motivates the object-oriented approach.
2.3: Defining a class
3.2: Designing the public interface of a class
2.8: Commenting the public interface 3.3: Commenting the public interface This material has been moved before the implementation section, to stress the importance of interface design. Students have seen the documentation of library classes in section 2.9.
2.5: Instance fields 3.4: Instance fields
2.9: Specifying the implementation of a class 3.5: Implementing constructors and methods
2.4: Testing a class
3.6: Testing a class
This material has been moved after the implementation section. Students have seen the basic testing process in section 2.8.
2.6: Constructors

This material is now in section 3.2
2.7: Designing the public interface of a class

This material is now in section 3.2
2.10: Variable types
3.7: Categories of variables

2.11: Explicit and implicit method parameters
3.8: Implicit and explicit method parameters

Chapter 3: Fundamental Data Types
Chapter 4: Fundamental Data Types
3.1: Number types
4.1: Number  types

3.2: Assignment
4.3: Assignment, increment, and decrement
These sections have been swapped
3.3: Constants
4.2: Constants
We now use a CashRegister instead of a Purse. (Some students found it pointless to implement a purse.)
3.4: Arithmetic and mathematical functions
4.4: Arithmetic and mathematical functions
3.5: Calling static methods
4.5: Calling static methods
3.6: Type conversion

This material is now in section 4.1
3.7: Strings
4.6: Strings
The advanced topic on formatting numbers is now in section 4.7, and it uses printf instead of NumberFormat
3.8: Reading input
4.7: Reading input
This section uses Scanner instead of JOptionPane
3.9: Characters

This material is now in advanced topic 4.5. Note that in Java 5, A char is no longer a Unicode character, but a code unit in the UTF-16 character encoding. Some Unicode characters now require two char values. 
3.10: Comparing primitive types and objects

This material is now in section 2.5
Chapter 4: Applets and Graphics
Chapter 5: Programming Graphics
Applets are now covered as an advanced topic. Graphics are now painted into a component inside a frame. As before, this chapter is optional.
4.1: Why applets?

This material is now in advanced topic 5.1
4.2: A brief introduction into HTML

This material is now in Appendix ???
4.3: A simple applet
5.1: Frame windows
Note that Java 5 no longer requires the use of the content pane of a frame.

5.2. Drawing shapes Here, we extend JComponent instead of Applet. Note that it is not necessary to call super.paintComponent!
4.4: Graphical shapes
5.3: Graphical shapes

4.5: Colors
5.4: Colors

4.6: Fonts

This section has been dropped since users of previous edition found the mathematics required for accurate positioning too challenging.
4.7: Drawing complex shapes
5.5: Drawing complex shapes
4.8: Reading text input
5.6: Reading text input

4.9: Comparing visual and numerical information
5.7: Comparing visual and numerical information
4.10: Coordinate transformations

This section has been dropped since users of previous edition found the mathematics too challenging.
Chapter 5. Decisions
Chapter 6. Decisions

5.1: The if statement
6.1: The if statement
5.2: Comparing values
6.2: Comparing values Accurately computing floating point values (i.e., normalizing by 1/(max(|x|, |y|)) has been dropped.
5.3: Multiple alternatives
6.3: Multiple alternatives The tax return example has been reworded to clarify the tax brackets
Advanced topic 6.3 discusses enumerated types, a Java 5 feature
5.4: Using Boolean expressions
6.4: Using Boolean expressions De Morgan's law is now an advanced topic
6. Iteration
7. Iteration
6.1: while loops
7.1: while loops
6.2: for loops
7.2: for loops
6.3: Nested loops
7.3: Nested loops
6.4: Processing input
7.4: Processing sentinel values
Material on processing input has been removed since it is now easy to do with the Scanner class
Advanced topics on input redirections have been moved to advanced topic 10.1.
6.5: Random numbers and simulation
7.5: Random numbers and simulation
Chapter 13. Array Lists and Arrays
Chapter 8. Arrays and Array Lists
By popular demand, this chapter has been moved forward.
13.4: Declaring and accessing arrays. 8.1: Arrays
By popular demand, arrays are now covered before array lists.
13.1: Array lists 8.2: Array lists
Array lists are now generic, e.g. ArrayList<BankAccount>
13.3: Storing numbers in array lists
8.3: Wrappers and auto-boxing
Auto-boxing is new for Java 5.

8.4: The generalized for loop
This section is new for Java 5.
13.2: Simple array list algorithms
8.5: Simple array algorithms This section uses a Bank class instead of a Purse.
13.7: Two-dimensional arrays
8.6: Two-dimensional arrays

13.5: Copying arrays
8.7: Copying arrays
This technical material has been moved to the back of the chapter.
13.6: Partially filled arrays

This material is now in advanced topic 8.4.

Advanced topic 8.5 discusses methods with a variable number of parameters, a Java 5 feature
Chapter 7. Designing Classes
Chapter 9. Designing Classes
7.1: Choosing classes 9.1: Choosing classes

7.2: Cohesion and coupling 9.2: Cohesion and coupling
Uses CashRegister instead of Purse
7.3: Accessor and mutator methods
9.3: Accessors, mutators, and immutable classes
Some of this material is now in section 2.7
7.4: Side effects 9.4: Side effects

7.5: Preconditions and postconditions 9.5: Preconditions and postconditions
Uses assertions instead of throwing exceptions
7.6: Static methods 9.6: Static methods
Uses Financial.percentOf instead of Numeric.approxEqual
7.7: Static fields 9.7: Static fields

7.8: Scope 9.8: Scope

7.9: Packages 9.9: Packages

Chapter 8: Testing and Debugging
Chapter 10: Testing and Debugging
8.1: Unit tests
10.1: Unit tests
This material is now split over two sections. Note that the Test classes have been renamed to Harness so they don't conflict with JUnit.

10.2: Providing test inputs

8.2: Test case evaluation 10.3: Test case evaluation

8.3: Regression testing and test coverage
10.4: Regression testing and test coverage Advanced topic 10.2 discusses JUnit.
8.4: Program traces, logging, and assertions
10.5: Logging
This section is now focused on logging. Assertions are now covered in section 9.5.
8.5: The debugger
10.6. Using a debugger
This section now uses the Eclipse debugger
8.6: A sample debugging session
10.7: A sample debugging session

Chapter 9. Interfaces and polymorphism
Chapter 11. Interfaces and polymorphism
9.1: Developing reusable solutions
11.1: Using interfaces for code reuse

9.2: Converting between types
11.2: Converting between class and interface types

9.3: Polymorphism
11.3: Polymorphism

9.4: Using a strategy interface for improving reusability
11.4: Using interfaces for callbacks
The "callback" metaphor has been added to help students understand the control flow.

11.5: Inner classes
This material has been placed in a separate section.
Feel free to skip this section if you don't cover graphical user interfaces.
9.5: Processing timer events
11.6: Processing timer events Feel free to skip this section if you don't cover graphical user interfaces.

11.7. Accessing surrounding variables
This section continues the discussion of inner classes, using a simpler example than in the old edition. (Now we move a rectangle with every timer tick rather than updating a bank account.)
Feel free to skip this section if you don't cover graphical user interfaces.
Chapter 10. Event Handling
Chapter 12. Event Handling This chapter uses applications, not applets.
As before, this chapter is optional.
12.1. Events, event listeners, and event sources 12.1. Events, event sources, and event listeners
This section now uses button clicks, not mouse clicks, for greater simplicity

12.2. Building applications with buttons
We use a label instead of a text area to show output.
10.3. Processing text input
12.3. Processing text input We use a bank account example instead of moving rectangles
10.2. Mouse events
12.4. Mouse events
10.4. Multiple buttons with similar behavior

Dropped; users of the previous edition felt that this material was too complex.
10.5. Frame windows

This material is now in Section 5.1.
10.6. Text components

This material is now in Section 14.5.
Chapter 11. Inheritance
Chapter 13. Inheritance
No major changes
Chapter 12. Graphical User Interfaces
Chapter 14. Graphical User Interfaces
12.1. Using Inheritance to Customize Panels
This material is now in Section 5.2.
12.3. Using Inheritance to Customize Frames 14.1. Using Inheritance to Customize Frames

12.2. Layout Management
14.2. Layout Management
12.4. Choices
14.3. Choices

12.5. Menus
14.4. Menus

14.5. Text Areas

12.6. Exploring the Swing Documentation
14.6. Exploring the Swing Documentation
Chapter 14. Exception Handling
Chapter 15. Exception Handling
14.1. Throwing Exceptions
15.1. Throwing Exceptions
14.2. Checked Exceptions
15.2. Checked and Unchecked Exceptions Now uses the Scanner class.
14.4. Catching Exceptions
15.3. Catching Exceptions
Now uses the Scanner class.
14.5. The finally Clause
15.4. The finally Clause Emphasizes to use either try/finally or try/catch, but not try/catch/finally
14.3. Designing Your Own Exception Types
15.5. Designing Your Own Exception Types
14.6. A Complete Example
15.6. Case Study: A Complete Example The example has changed. It is now a modification of the DataSet class.
15. Streams
16. Files and Streams

15.2. Reading and Writing Text Files 16.1. Reading and Writing Text Files
This section contains the most important file processing techniques. If there is insufficient time, the remaining sections can be skipped. Now uses the Scanner class.
15.1. Streams, Readers and Writers
16.2. Text and Binary Files

15.3. File Dialogs

This material is now in Advanced Topic 16.1.
15.4. An Encryption Program 16.3. An Encryption Program

15.5. Command Line Arguments

This material is now in Advanced Topic 16.2.
15.7. Random Access
16.4. Random Access

15.6. Object Streams
16.5. Object Streams
The example has changed.
16. System Design
17. Object-Oriented Design

16.1. The Software Life Cycle 17.1. The Software Life Cycle
16.2. Discovering Classes
17.2. Discovering Classes
16.3. Relationships Between Classes
17.3. Relationships Between Classes The "association" relationship ---> has been replaced with a more student-friendly "aggregation" relationship <>---.
16.4. Example: Printing an Invoice
17.4. Case Study: Printing an Invoice Now uses a generic ArrayList
16.5. Example: An Automatic Teller Machine
17.5. Example: An Automatic Teller Machine Now has the user interface decoupled from the business logic. Both a text and graphical user interface are provided.
17. Recursion
18. Recursion

17.1. Triangle Numbers
18.1. Triangle Numbers
17.2. Permutations
18.2. Permutations Now uses a simpler example that stores the permutations in an ArrayList<String> rather than enumerating them.
17.3. Recursive Helper Methods
18.3. Recursive Helper Methods
17.5. The Efficiency of Recursion 18.4. The Efficiency of Recursion

17.4. Mutual Recursion
18.5. Mutual Recursion
18. Sorting and Searching
19. Sorting and Searching
No major changes
19. An Introduction to Data Structures
20. An Introduction to Data Structures
19.1. Using Linked Lists
20.1. Using Linked Lists Uses generic types
19.2. Implementing Linked Lists
20.2. Implementing Linked Lists Changed Link to Node
19.3. Abstract and Concrete Types
20.3. Abstract and Concrete Types
19.4. Stacks and Queues
19.4. Stacks and Queues
20. Advanced Data Structures
21. Advanced Data Structures
20.1. Sets
21.1. Sets
Uses generic types
20.2. Maps
21.2. Maps
Uses generic types
20.3. Hash Tables
21.3. Hash Tables
20.4. Computing Hash Codes
21.4. Computing Hash Codes
20.5. Binary Search Trees
21.5. Binary Search Trees

21.6. Tree Traversal

20.6. Using Tree Sets and Tree Maps
21.7. Using Tree Sets and Tree Maps Uses generic types

21.8. Priority Queues

21.9. Heaps

21.10. The Heapsort Algorithm

22. Generic Classes

22.1. Type Variables

22.2. Implementing Generic Classes

22.3. Generic Methods

22.4. Constraining Type Variables

22.5. Raw Types

21. Multithreading (Big Java) 23. Multithreading (Big Java)
21.1. Thread Basics
23.1. Running Threads
23.2 Terminating Threads

21.2. Synchronization
23.3. Race Conditions
23.4. Synchronizing Object Access
Uses Lock, Condition objects
21.3. Avoiding Deadlocks
23.5. Avoiding Deadlocks

21.4. An Application of Threads: Algorithm Animation
23.6. Case Study: Algorithm Animation

22. Internet Networking (Big Java)
24. Internet Networking (Big Java)

22.1. The Internet Protocol
24.1. The Internet Protocol

22.2. Application Level Protocols
24.2. Application Level Protocols
22.3. A Client Program
24.3. A Client Program
22.4. A Server Program
24.4. A Server Program
22.5. URL Connections
24.5. URL Connections
22.6. Posting Form Data

23. Relational Databases (Big Java)

23.1. Organizing Database Information
25.1. Organizing Database Information
23.2. Queries
25.2. Queries
23.3. Installing a Database
25.3. Installing a Database Covers open-source databases
23.4. Database Programming in Java
25.4. Database Programming in Java
23.5. Case Study: A Bank Database
25.5. Case Study: A Bank Database
23.6. Advanced Database Concepts

24. XML (Big Java)
26. XML (Big Java)

24.1. XML Tags and Documents
26.1. XML Tags and Documents
24.2. Parsing XML Documents
26.2. Parsing XML Documents Uses XPath, greatly simplifying parsing
24.3. Creating XML Documents
26.3. Creating XML Documents
24.4. Document Type Definitions
24.5. Parsing with Document Type Definitions
26.4. Validating  XML Documents
25. JavaServer Pages and Servlets (Big Java)
27. JavaServer Faces (Big Java)
Uses JSF instead of the lower-level JSP
25.1. Dynamic Web Content
27.1. A Simple JSF Program

25.2. Encapsulating Computations in JavaBeans
27.2. JavaBeans Components

25.3. Handling Request Parameters

JSF handles this internally
25.4. HTML Forms
27.3. JSF Components

25.5. Session Tracking

JSF handles this internally
25.6. Branching and Forwarding Pages
27.4. Navigation Between Pages

25.7. A Three-Tier Application
27.5. A Three-Tier Application
25.8. Servlets
25.9. Compilation of JSP Pages

"Server-side assembly programming" is no longer covered
Appendix A1. Java Language Coding Guidelines
Appendix A. Java Language Coding Guidelines
Appendix A3 (Concepts), A6 (Big Java). The Basic Latin and Latin-1 Subsets of Unicode Appendix B. The Basic Latin and Latin-1 Subsets of Unicode

Appendix A2 (Concepts), A5 (Big Java). The Java Library
Appendix C. The Java Library

Appendix D. Adapting Java 5 Programs to Older Compilers

Appendix A2 (Big Java), Java Syntax Summary
Appendix E, Java Syntax Summary
Appendix A3 (Big Java), Java Operator Summary
Appendix F, Java Operator Summary
Appendix A4 (Big Java), Java Keyword Summary
Appendix G, Java Keyword Summary
Appendix A7 (Big Java), Metric Conversion Factors
Appendix H, Metric Conversion Factors
Appendix A8 (Big Java), HTML Summary
Appendix I, HTML Summary
Appendix A9 (Big Java), Tool Summary
Appendix J, Tool Summary
Appendix A10 (Big Java), javadoc Summary
Appendix K, javadoc Summary
Appendix A11 (Big Java), Number Systems
Appendix L, Number Systems
Appendix A12 (Big Java), Bit and Shift Operations
Appendix M, Bit and Shift Operations
Appendix A13 (Big Java), UML Summary
Appendix N, UML Summary
Appendix A4 (Concepts), A14 (Big Java). Glossary