Old Edition	New Edition	Changes
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		Dropped
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	Glossary