a01 rege1813 02 se fm - pearson educationbut as douglas adams says in the hitchhiker’s guide to...
TRANSCRIPT
Preface
The newly revised Building Java Programs textbook is designed for use in an intro-ductory course in computer science. The new chapters in this edition will make it use-ful in a more advanced course in computer science as well. We have class-tested itwith thousands of undergraduates at the University of Washington, most of whomwere not computer science majors.
Introductory computer science courses have a long history at many universities ofbeing “killer” courses with high failure rates. But as Douglas Adams says in TheHitchhiker’s Guide to the Galaxy, “Don’t panic.” Students can master this material ifthey can learn it gradually. The introductory courses at the University of Washingtonare experiencing record enrollments and other schools that have adopted our textbookreport that students are succeeding with our approach.
Since the publication of our first edition, there has been a movement toward the“objects later” approach that we have championed (as opposed to the “objects early”approach). We know from years of experience that a broad range of scientists, engi-neers, and others can learn how to program in a procedural manner. Once we havebuilt a solid foundation of procedural techniques, we turn to object-oriented pro-gramming. By the end of the course, students will have learned about both styles ofprogramming.
Here are some of the changes that we have made in the second edition:
• Three new chapters. We have created three new chapters that extend thecoverage of the book, using material that we present in our second course incomputer science. Chapter 15 explores the issues that arise in the course ofimplementing a robust and powerful collection class. Chapter 16 explores pro-gramming with linked lists, and Chapter 17 explores programming with binarytrees.
• Improved case studies. Chapters 6 and 7 contain new case studies that are moreinteresting than those included in the first edition. The other case studies throughoutthe textbook have been expanded to better explain subtle points with which studentsoften struggle.
• Reorganization of “using objects” material. Material in Chapters 3, 4, and 6has been reorganized into a new section in Chapter 7 on “reference semantics.”We have found that this approach works better for explaining these importantconcepts.
iii
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page iii
iv Preface
• New section on procedural design heuristics. Chapter 4 now includes a dis-cussion of design guidelines for procedural programming.
• New section on de Morgan’s laws. Chapter 5 has been updated to include asection on de Morgan’s laws and their application to programming withboolean expressions.
• Rebalancing of object coverage. We have adjusted Chapters 8 and 9, whichcover objects and inheritance, to provide more coherent coverage of thesetopics.
• New appendix on Java language features. A new appendix describes languagedetails not covered in the chapters such as enumerated types and packages.
• Arrays class coverage. A new section in Chapter 7 includes coverage of theutility methods available from the Arrays class.
• Expanded self-checks and programming exercises. We have significantlyincreased the number and quality of self-check exercises and programming exer-cises incorporating new problems in each chapter.
The following features have been retained from the first edition:
• Focus on problem solving. Many textbooks focus on language details whenthey introduce new constructs. We focus instead on problem solving. Whatnew problems can be solved with each construct? What pitfalls are noviceslikely to encounter along the way? What are the most common ways to use anew construct?
• Emphasis on algorithmic thinking. Our procedural approach allows us toemphasize algorithmic problem solving: breaking a large problem into smallerproblems, using pseudocode to refine an algorithm, and grappling with the chal-lenge of expressing a large program algorithmically.
• Layered approach. Programming in Java involves many concepts that are diffi-cult to learn all at once. Teaching Java to a novice is like trying to build a houseof cards. Each new card has to be placed carefully. If the process is rushed andyou try to place too many cards at once, the entire structure collapses. We teachnew concepts gradually, layer by layer, allowing students to expand their under-standing at a manageable pace.
• Case studies. We end most chapters with a significant case study that showsstudents how to develop a complex program in stages and how to test it as itis being developed. This structure allows us to demonstrate each new pro-gramming construct in a rich context that can’t be achieved with short codeexamples.
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page iv
Layers and Dependencies
Many introductory computer science books are language-oriented, but the early chap-ters of our book are layered. For example, Java has many control structures (includingfor loops, while loops, and if/else statements), and many books include all ofthese control structures in a single chapter. While that might make sense to someonewho already knows how to program, it can be overwhelming for a novice who islearning how to program. We find that it is much more effective to spread these controlstructures into different chapters so that students learn one structure at a time ratherthan trying to learn them all at once.
The following table shows how the layered approach works in the first six chapters:
Preface v
The Layers
Programming
Chapter Control flow Data techniques Input/Output
1 methods String literals procedural println, print
decomposition
2 definite loops (for) variables local variables
expressions class constants
int, double pseudocode
3 return values using objects parameters console input
graphics (optional)
4 conditional char pre/post conditions printf
(if/else) throwing exceptions
5 indefinite loops boolean assertions
(while) robust programs
6 Scanner token-based processing file input/output
line-based processing
Chapters 1–6 are designed to be worked through in order, with greater flexibil-ity of study then beginning in Chapter 7. Chapter 6 may be skipped, although thecase study in Chapter 7 involves reading from a file, a topic that is covered inChapter 6.
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page v
vi Preface
The following is a dependency chart for the book:
Supplements
Answers to all self-check problems appear in Appendix A. In addition, students canaccess the following resources at http://www.pearsonhighered.com/regesstepp/ or ourweb site at http://www.buildingjavaprograms.com/:
• Source code and data files for all case studies and other complete programexamples.
• The DrawingPanel class used in the optional graphics Supplement 3G.
• The Practice-It! web programming practice system.
Chapters 1–6Programming Fundamentals
Chapter 9Inheritance and Interfaces
Chapter 13Searching and Sorting
Chapter 14Graphical User Interfaces
Chapter 10ArrayLists
Chapter 12Recursion
Chapter 8Classes
Chapter 7Arrays
Chapter 11Java Collections Framework
Chapter 15Implementing a Collection Class
Chapter 16Linked Lists
Chapter 17Binary Trees
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page vi
Preface vii
Instructors can access the following resources from our web site at http://www.buildingjavaprograms.com/:
• PowerPoint slides suitable for lectures.
• Solutions to exercises and programming projects, along with homework specifi-cation documents for many projects.
• Sample Exams and solution keys.
• Additional Lab Exercises and Programming Exercises with solution keys.
To access protected instructor resources, contact us at [email protected]. The same materials are also available at http://www.pearsonhighered.com/regesstepp/. To receive a password for this site or to ask other questions relatedto resources, contact your Addison-Wesley sales representative or send email to [email protected].
Practice-It!
For the second edition, we have written a web application called Practice-It! that isavailable from our web site at http://www.buildingjavaprograms.com/practice/. Thisapplication allows students to practice the exercises from the book and from ourintroductory programming courses. The system presents a menu of exercises andallows the user to type a solution to a problem and submit it to our server. The systemwill test the solution and report whether the code solves the problem correctly. Forself-checks and University of Washington problems, you may also view the instructor’ssolutions. Many of our own students have reported that they find this system useful,especially when they are studying for exams.
VideoNotes
We have recorded a series of instructional videos to accompany the second edition ofthe textbook. They are available at http://www.pearsonhighered.com/regesstepp.Roughly 3–4 videos are posted for each chapter. An icon in the margin of the pageindicates when a VideoNote is available for a given topic. In each video, we spend5–15 minutes walking through a particular concept or problem, talking about the chal-lenges and methods necessary to solve it. These videos make a good supplement to theinstruction given in lecture classes and in the textbook. Your new copy of the secondedition has an access code that will allow you to view the videos.
Acknowledgments
First, we would like to thank the many students and teaching assistants who have usedand commented on early drafts of this text. We could not have written this book with-out their input. Special thanks go to Hélène Martin, who pored over early versions ofthese chapters to find errors and to identify rough patches that needed work. We would
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page vii
viii Preface
also like to thank instructor Benson Limketkai for spending many hours performing atechnical proofread of the second edition.
Second, we would like to thank the talented pool of reviewers who guided us inthe process of creating this textbook:
• Greg Anderson, Weber State University
• Delroy A. Brinkerhoff, Weber State University
• Ed Brunjes, Miramar Community College
• Tom Capaul, Eastern Washington University
• Tom Cortina, Carnegie Mellon University
• Charles Dierbach, Towson University
• H.E. Dunsmore, Purdue University
• Michael Eckmann, Skidmore College
• Mary Anne Egan, Siena College
• Leonard J. Garrett, Temple University
• Ahmad Ghafarian, North Georgia College & State University
• Raj Gill, Anne Arundel Community College
• Michael Hostetler, Park University
• David Hovemeyer, York College of Pennsylvania
• Chenglie Hu, Carroll College
• Philip Isenhour, Virginia Polytechnic Institute
• Andree Jacobson, University of New Mexico
• David C. Kamper, Sr., Northeastern Illinois University
• Simon G.M. Koo, University of San Diego
• Evan Korth, New York University
• Joan Krone, Denison University
• John H.E.F. Lasseter, Fairfield University
• Eric Matson, Wright State University
• Kathryn S. McKinley, University of Texas, Austin
• Jerry Mead, Bucknell University
• George Medelinskas, Northern Essex Community College
• John Neitzke, Truman State University
• Dale E. Parson, Kutztown University
• Richard E. Pattis, Carnegie Mellon University
• Frederick Pratter, Eastern Oregon University
• Roger Priebe, University of Texas, Austin
• Dehu Qi, Lamar University
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page viii
Preface ix
• John Rager, Amherst College
• Amala V.S. Rajan, Middlesex University
• Craig Reinhart, California Lutheran University
• Mike Scott, University of Texas, Austin
• Alexa Sharp, Oberlin College
• Tom Stokke, University of North Dakota
• Leigh Ann Sudol, Fox Lane High School
• Ronald F. Taylor, Wright State University
• Andy Ray Terrel, University of Chicago
• Scott Thede, DePauw University
• Megan Thomas, California State University, Stanislaus
• Dwight Tuinstra, SUNY Potsdam
• Jeannie Turner, Sayre School
• Tammy VanDeGrift, University of Portland
• Thomas John VanDrunen, Wheaton College
• Neal R. Wagner, University of Texas, San Antonio
• Jiangping Wang, Webster University
• Yang Wang, Missouri State University
• Stephen Weiss, University of North Carolina at Chapel Hill
• Laurie Werner, Miami University
• Dianna Xu, Bryn Mawr College
• Carol Zander, University of Washington, Bothell
We would also like to thank the dedicated University of Washington teachingassistants who have added many problems to our Practice-It system: Robert Baxter,Whitaker Brand, Leslie Ferguson, Lisa Fiedler, Jason Ganzhorn, Stefanie Hatcher,Roy McElmurry, Jeff Prouty, Stephanie Smallman, Eric Spishak, and Kimberly Todd.
Finally, we would like to thank the great staff at Addison-Wesley who helped pro-duce the book. Michelle Brown, Jeff Holcomb, Maurene Goo, Patty Mahtani, NancyKotary, and Kathleen Kenny did great work preparing the first edition. Our copy edi-tors and the staff of Aptara Corp, including Heather Sisan, Brian Baker, BrendanShort, and Rachel Head, caught many errors and improved the quality of the writing.Marilyn Lloyd and Chelsea Bell served well as project manager and editorial assis-tant respectively. Special thanks go to our editor Matt Goldstein, who has believed inthe concept of our book from day one. We couldn’t have finished this job without allof their support.
Stuart Reges
Marty Stepp
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page ix
LOCATION OF VIDEO NOTES IN THE TEXTwww.pearsonhighered.com/regesstepp
Chapter 1 Pages, 31, 40
Chapter 2 Pages, 63, 72, 87, 95, 108
Chapter 3 Pages, 136, 151, 156, 162
Chapter 3G Pages, 189, 205
Chapter 4 Pages, 231, 239, 266
Chapter 5 Pages, 310, 313, 315, 319, 342
Chapter 6 Pages, 382, 395, 409
Chapter 7 Pages, 440, 447, 464, 481
Chapter 8 Pages, 505, 517, 525, 538
Chapter 9 Pages, 565, 578, 594
Chapter 10 Pages, 638, 643, 652
Chapter 11 Pages, 680, 693, 701
Chapter 12 Pages, 728, 736, 756
Chapter 13 Pages, 776, 779, 785
Chapter 14 Pages, 823, 836, 855
Chapter 15 Pages, 894, 900, 904
Chapter 16 Pages, 936, 943, 956
Chapter 17 Pages, 1001, 1002, 1012
x
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page x
Brief Contents
Preface iii
Chapter 1 Introduction to Java Programming 1
Chapter 2 Primitive Data and Definite Loops 61
Chapter 3 Introduction to Parameters and Objects 132
Supplement 3G Graphics (Optional) 188
Chapter 4 Conditional Execution 226
Chapter 5 Program Logic and Indefinite Loops 301
Chapter 6 File Processing 373
Chapter 7 Arrays 425
Chapter 8 Classes 500
Chapter 9 Inheritance and Interfaces 555
Chapter 10 ArrayLists 628
Chapter 11 Java Collections Framework 679
Chapter 12 Recursion 718
Chapter 13 Searching and Sorting 774
Chapter 14 Graphical User Interfaces 822
Chapter 15 Implementing a Collection Class 886
Chapter 16 Linked Lists 929
Chapter 17 Binary Trees 981
Appendix A Answers to Self-Check Problems 1035
Appendix B Java Summary 1107
Appendix C Javadoc Comments and the Java API Specification 1122
Appendix D Additional Java Syntax 1128
Index 1137
xi
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page xi
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page xii
Contents
Preface iii
Chapter 1 Introduction to Java Programming 1
1.1 Basic Computing Concepts 2Why Programming? 2Hardware and Software 3The Digital Realm 4The Process of Programming 6Why Java? 7The Java Programming Environment 8
1.2 And Now—Java 10String Literals (Strings) 14System.out.println 15Escape Sequences 15print versus println 17Identifiers and Keywords 18A Complex Example: DrawFigures1 20Comments and Readability 21
1.3 Program Errors 24Syntax Errors 24Logic Errors (Bugs) 28
1.4 Procedural Decomposition 28Static Methods 31Flow of Control 34Methods that Call Other Methods 36An Example Runtime Error 39
1.5 Case Study: DrawFigures 40Structured Version 41Final Version without Redundancy 43Analysis of Flow of Execution 44
xiii
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page xiii
Chapter 2 Primitive Data and Definite Loops 61
2.1 Basic Data Concepts 62Primitive Types 62Expressions 63Literals 65Arithmetic Operators 66Precedence 68Mixing Types and Casting 71
2.2 Variables 72Assignment/Declaration Variations 77String Concatenation 80Increment/Decrement Operators 82Variables and Mixing Types 85
2.3 The for Loop 87Tracing for Loops 89for Loop Patterns 93Nested for Loops 95
2.4 Managing Complexity 97Scope 97Pseudocode 103Class Constants 106
2.5 Case Study: Hourglass Figure 108Problem Decomposition and Pseudocode 109Initial Structured Version 111Adding a Class Constant 112Further Variations 115
Chapter 3 Introduction to Parameters
and Objects 132
3.1 Parameters 133The Mechanics of Parameters 136Limitations of Parameters 140Multiple Parameters 143Parameters versus Constants 146Overloading of Methods 146
3.2 Methods That Return Values 147The Math Class 148Defining Methods That Return Values 151
xiv Contents
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page xiv
3.3 Using Objects 155String Objects 156Interactive Programs and Scanner Objects 162Sample Interactive Program 165
3.4 Case Study: Projectile Trajectory 168Unstructured Solution 172Structured Solution 174
Supplement 3G Graphics (Optional) 188
3G.1 Introduction to Graphics 189DrawingPanel 189Drawing Lines and Shapes 190Colors 195Drawing with Loops 198Text and Fonts 202
3G.2 Procedural Decomposition with Graphics 205A Larger Example: DrawDiamonds 206
3G.3 Case Study: Pyramids 209Unstructured Partial Solution 210Generalizing the Drawing of Pyramids 212Complete Structured Solution 213
Chapter 4 Conditional Execution 226
4.1 if/else Statements 227Relational Operators 229Nested if/else Statements 231Object Equality 238Factoring if/else Statements 239Multiple Conditions 241
4.2 Cumulative Algorithms 242Cumulative Sum 242Min/Max Loops 244Cumulative Sum with if 248Roundoff Errors 250
4.3 Text Processing 253The char Type 253char versus int 254
Contents xv
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page xv
Cumulative Text Algorithms 255System.out.printf 257
4.4 Methods with Conditional Execution 262Preconditions and Postconditions 262Throwing Exceptions 262Revisiting Return Values 266Reasoning about Paths 271
4.5 Case Study: Body Mass Index 273One-Person Unstructured Solution 274Two-Person Unstructured Solution 277Two-Person Structured Solution 279Procedural Design Heuristics 283
Chapter 5 Program Logic and Indefinite Loops 301
5.1 The while Loop 302A Loop to Find the Smallest Divisor 303Random Numbers 306Simulations 310do/while Loop 311
5.2 Fencepost Algorithms 313Sentinel Loops 315Fencepost with if 316
5.3 The booleanType 319Logical Operators 321Short-Circuited Evaluation 324boolean Variables and Flags 328Boolean Zen 330Negating Boolean Expressions 333
5.4 User Errors 334Scanner Lookahead 335Handling User Errors 337
5.5 Assertions and Program Logic 339Reasoning about Assertions 341A Detailed Assertions Example 342
5.6 Case Study: NumberGuess 347Initial Version without Hinting 347Randomized Version with Hinting 349Final Robust Version 353
xvi Contents
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page xvi
Chapter 6 File Processing 373
6.1 File-Reading Basics 374Data, Data Everywhere 374Files and File Objects 374Reading a File with a Scanner 377
6.2 Details of Token-Based Processing 382Structure of Files and Consuming Input 384Scanner Parameters 389Paths and Directories 390A More Complex Input File 393
6.3 Line-Based Processing 395String Scanners and Line/Token Combinations 396
6.4 Advanced File Processing 401Output Files with PrintStream 401Guaranteeing That Files Can Be Read 406
6.5 Case Study: Zip Code Lookup 409
Chapter 7 Arrays 425
7.1 Array Basics 426Constructing and Traversing an Array 426Accessing an Array 430A Complete Array Program 433Random Access 437Arrays and Methods 440The For-Each Loop 443Initializing Arrays 445The Arrays Class 446
7.2 Array-Traversal Algorithms 447Printing an Array 448Searching and Replacing 450Testing for Equality 453Reversing an Array 454String Traversal Algorithms 459
7.3 Reference Semantics 460Multiple Objects 462
Contents xvii
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page xvii
7.4 Advanced Array Techniques 464Shifting Values in an Array 464Arrays of Objects 469Command-Line Arguments 470Nested Loop Algorithms 471
7.5 Multidimensional Arrays 473Rectangular Two-Dimensional Arrays 473Jagged Arrays 475
7.6 Case Study: Benford’s Law 479Tallying Values 481Completing the Program 485
Chapter 8 Classes 500
8.1 Object-Oriented Programming 501Classes and Objects 502Point Objects 504
8.2 Object State and Behavior 505Object State: Fields 506Object Behavior: Methods 508The Implicit Parameter 511Mutators and Accessors 513The toString Method 515
8.3 Object Initialization: Constructors 517The Keyword this 522Multiple Constructors 524
8.4 Encapsulation 525Private Fields 526Class Invariants 532Changing Internal Implementations 536
8.5 Case Study: Designing a Stock Class 538Object-Oriented Design Heuristics 539Stock Fields and Method Headers 541Stock Method and Constructor Implementation 543
Chapter 9 Inheritance and Interfaces 555
9.1 Inheritance Basics 556Nonprogramming Hierarchies 557
xviii Contents
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page xviii
Extending a Class 559Overriding Methods 563
9.2 Interacting with the Superclass 565Calling Overridden Methods 565Accessing Inherited Fields 566Calling a Superclass’s Constructor 568DividendStock Behavior 570The Object Class 572The equals Method 573The instanceof Keyword 576
9.3 Polymorphism 578Polymorphism Mechanics 581Interpreting Inheritance Code 583Interpreting Complex Calls 585
9.4 Inheritance and Design 588A Misuse of Inheritance 588Is-a Versus Has-a Relationships 591Graphics2D 592
9.5 Interfaces 594An Interface for Shapes 595Implementing an Interface 597Benefits of Interfaces 600
9.6 Case Study: Financial Class Hierarchy 602Designing the Classes 603Redundant Implementation 607Abstract Classes 610
Chapter 10 ArrayLists 628
10.1 ArrayLists 629Basic ArrayList Operations 630ArrayList Searching Methods 633A Complete ArrayList Program 636Adding to and Removing from an ArrayList 638Using the For-Each Loop with ArrayLists 642Wrapper Classes 643
10.2 The Comparable Interface 646Natural Ordering and compareTo 648Implementing the Comparable Interface 652
Contents xix
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page xix
10.3 Case Study: Vocabulary Comparison 656Some Efficiency Considerations 657Version 1: Compute Vocabulary 659Version 2: Compute Overlap 664Version 3: Complete Program 669
Chapter 11 Java Collections Framework 679
11.1 Lists 680Collections 680LinkedList versus ArrayList 681Iterators 684Abstract Data Types (ADTs) 687LinkedList Case Study: Sieve 690
11.2 Sets 693Set Concepts 694TreeSet versus HashSet 696Set Operations 697Set Case Study: Lottery 699
11.3 Maps 701Basic Map Operations 702Map Views (keySet and values) 704TreeMap versus HashMap 705Map Case Study: WordCount 706Collection Overview 709
Chapter 12 Recursion 718
12.1 Thinking Recursively 719A Nonprogramming Example 719An Iterative Solution Converted to Recursion 722Structure of Recursive Solutions 724
12.2 A Better Example of Recursion 726Mechanics of Recursion 728
12.3 Recursive Functions and Data 736Integer Exponentiation 736Greatest Common Divisor 739Directory Crawler 745Helper Methods 749
12.4 Recursive Graphics (Optional) 752
xx Contents
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page xx
12.5 Case Study: Prefix Evaluator 756Infix, Prefix, and Postfix Notation 757Evaluating Prefix Expressions 757Complete Program 761
Chapter 13 Searching and Sorting 774
13.1 Searching and Sorting in the Java Class Libraries 775Binary Search 776Sorting 779Shuffling 780Custom Ordering with Comparators 781
13.2 Program Complexity 785Empirical Analysis 788Complexity Classes 792
13.3 Implementing Searching and Sorting Algorithms 794Sequential Search 795Binary Search 796Recursive Binary Search 799Searching Objects 802Selection Sort 803
13.4 Case Study: Implementing Merge Sort 806Splitting and Merging Arrays 807Recursive Merge Sort 810Complete Program 813
Chapter 14 Graphical User Interfaces 822
14.1 GUI Basics 823Graphical Input and Output with Option Panes 823Working with Frames 826Buttons, Text Fields, and Labels 831Changing a Frame’s Layout 833Handling an Event 834
14.2 Laying Out Components 836Layout Managers 837Composite Layouts 840
14.3 Interaction Between Components 845Example 1: BMI GUI 845
Contents xxi
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page xxi
Object-Oriented GUIs 846Example 2: Credit Card GUI 850
14.4 Additional Components and Events 855Text Areas, Scrollbars, and Fonts 856Icons 858Mouse Events 860
14.5 Two-Dimensional Graphics 865Drawing onto Panels 865Animation with Timers 867
14.6 Case Study: Implementing DrawingPanel 872Initial Version without Events 872Second Version with Events 874
Chapter 15 Implementing a Collection Class 886
15.1 Simple ArrayIntList 887Adding and Printing 887Thinking about Encapsulation 893Dealing with the Middle of the List 894Another Constructor and a Constant 899Preconditions and Postconditions 900
15.2 A More Complete ArrayIntList 904Throwing Exceptions 904Convenience Methods 907
15.3 Advanced Features 910Resizing When Necessary 910Adding an Iterator 912
15.4 ArrayList<E> 918
Chapter 16 Linked Lists 929
16.1 Working with Nodes 930Constructing a List 931List Basics 933Manipulating Nodes 936Traversing a List 939
16.2 A Linked List Class 943Simple LinkedIntList 943
xxii Contents
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page xxii
Appending add 945The Middle of the List 949
16.3 A Complex List Operation 956Inchworm Approach 961
16.4 An IntList Interface 962
16.5 LinkedList<E> 965Linked List Variations 966Linked List Iterators 969Other Code Details 971
Chapter 17 Binary Trees 981
17.1 Binary Tree Basics 982Node and Tree Classes 985
17.2 Tree Traversals 986Constructing and Viewing a Tree 992
17.3 Common Tree Operations 1001Sum of a Tree 1001Counting Levels 1002Counting Leaves 1004
17.4 Binary Search Trees 1005The Binary Search Tree Property 1006Building a Binary Search Tree 1008The Pattern x = change(x) 1012Searching the Tree 1015Binary Search Tree Complexity 1019
17.5 SearchTree<E> 1020
Appendix A Answers to Self-Check Problems 1035
Appendix B Java Summary 1107
Appendix C Javadoc Comments and the Java API Specification 1122
Appendix D Additional Java Syntax 1128
Index 1137
Contents xxiii
A01_REGE1813_02_SE_FM.qxd 2/10/10 5:49 PM Page xxiii