Building Java Programs: A Back to Basics Approach 9780134322766, 129216168X, 9781292161686, 0134322762

Table of contents :
Cover......Page 1
Title Page......Page 2
Copyright Page......Page 3
Preface......Page 4
Brief Contents......Page 14
Contents......Page 16
Chapter 1: Introduction to Java Programming......Page 28
Why Programming?......Page 29
Hardware and Software......Page 30
The Digital Realm......Page 31
The Process of Programming......Page 33
Why Java?......Page 34
The Java Programming Environment......Page 35
1.2. And Now—Java......Page 37
String Literals (Strings)......Page 41
Escape Sequences......Page 42
print versus println......Page 44
Identifiers and Keywords......Page 45
A Complex Example: DrawFigures1......Page 47
Comments and Readability......Page 48
Syntax Errors......Page 51
1.4. Procedural Decomposition......Page 55
Static Methods......Page 58
Flow of Control......Page 61
Methods That Call Other Methods......Page 63
An Example Runtime Error......Page 66
1.5. Case Study: DrawFigures......Page 67
Structured Version......Page 68
Final Version without Redundancy......Page 70
Analysis of Flow of Execution......Page 71
Chapter 2: Primitive Data and Definite Loops......Page 90
Primitive Types......Page 91
Expressions......Page 92
Literals......Page 94
Arithmetic Operators......Page 95
Precedence......Page 97
Mixing Types and Casting......Page 100
2.2. Variables......Page 101
Assignment/Declaration Variations......Page 106
String Concatenation......Page 109
Increment/Decrement Operators......Page 111
Variables and Mixing Types......Page 114
2.3. The for Loop......Page 116
Tracing for Loops......Page 118
for Loop Patterns......Page 122
Nested for Loops......Page 124
Scope......Page 126
Pseudocode......Page 132
Class Constants......Page 135
2.5. Case Study: Hourglass Figure......Page 137
Problem Decomposition and Pseudocode......Page 138
Initial Structured Version......Page 140
Adding a Class Constant......Page 141
Further Variations......Page 144
Chapter 3: Introduction to Parameters and Objects......Page 164
3.1. Parameters......Page 165
The Mechanics of Parameters......Page 168
Limitations of Parameters......Page 172
Multiple Parameters......Page 175
Overloading of Methods......Page 178
3.2. Methods That Return Values......Page 179
The Math Class......Page 180
Defining Methods That Return Values......Page 183
3.3. Using Objects......Page 187
String Objects......Page 188
Interactive Programs and Scanner Objects......Page 194
Sample Interactive Program......Page 197
3.4. Case Study: Projectile Trajectory......Page 200
Unstructured Solution......Page 204
Structured Solution......Page 206
Supplement 3G: Graphics (Optional)......Page 223
DrawingPanel......Page 224
Drawing Lines and Shapes......Page 225
Colors......Page 230
Drawing with Loops......Page 233
Text and Fonts......Page 237
Images......Page 240
3G.2. Procedural Decomposition with Graphics......Page 242
A Larger Example: DrawDiamonds......Page 243
3G.3. Case Study: Pyramids......Page 246
Unstructured Partial Solution......Page 247
Generalizing the Drawing of Pyramids......Page 249
Complete Structured Solution......Page 250
Chapter 4: Conditional Execution......Page 265
4.1. if/else Statements......Page 266
Relational Operators......Page 268
Nested if/else Statements......Page 270
Object Equality......Page 277
Factoring if/else Statements......Page 278
Testing Multiple Conditions......Page 280
Cumulative Sum......Page 281
Min/Max Loops......Page 283
Cumulative Sum with if......Page 287
Roundoff Errors......Page 289
The char Type......Page 292
char versus int......Page 293
Cumulative Text Algorithms......Page 294
System.out.printf......Page 296
Throwing Exceptions......Page 301
Revisiting Return Values......Page 305
Reasoning about Paths......Page 310
4.5. Case Study: Body Mass Index......Page 312
One-Person Unstructured Solution......Page 313
Two-Person Unstructured Solution......Page 316
Two-Person Structured Solution......Page 318
Procedural Design Heuristics......Page 322
Chapter 5: Program Logic and Indefinite Loops......Page 342
5.1. The while Loop......Page 343
A Loop to Find the Smallest Divisor......Page 344
Random Numbers......Page 347
Simulations......Page 351
do/while Loop......Page 352
5.2. Fencepost Algorithms......Page 354
Sentinel Loops......Page 356
Fencepost with if......Page 357
5.3. The boolean Type......Page 360
Logical Operators......Page 362
Short-Circuited Evaluation......Page 365
boolean Variables and Flags......Page 369
Boolean Zen......Page 371
Negating Boolean Expressions......Page 374
5.4. User Errors......Page 375
Scanner Lookahead......Page 376
Handling User Errors......Page 378
5.5. Assertions and Program Logic......Page 380
Reasoning about Assertions......Page 382
A Detailed Assertions Example......Page 383
Initial Version without Hinting......Page 388
Randomized Version with Hinting......Page 390
Final Robust Version......Page 394
Chapter 6: File Processing......Page 414
Files and File Objects......Page 415
Reading a File with a Scanner......Page 418
6.2. Details of Token-Based Processing......Page 423
Structure of Files and Consuming Input......Page 425
Scanner Parameters......Page 430
Paths and Directories......Page 431
A More Complex Input File......Page 434
6.3. Line-Based Processing......Page 436
String Scanners and Line/Token Combinations......Page 437
Output Files with PrintStream......Page 442
Guaranteeing That Files Can Be Read......Page 447
6.5. Case Study: Zip Code Lookup......Page 450
Chapter 7: Arrays......Page 470
Constructing and Traversing an Array......Page 471
Accessing an Array......Page 475
A Complete Array Program......Page 478
Random Access......Page 482
Arrays and Methods......Page 485
The For-Each Loop......Page 488
Initializing Arrays......Page 490
The Arrays Class......Page 491
7.2. Array-Traversal Algorithms......Page 492
Printing an Array......Page 493
Searching and Replacing......Page 495
Testing for Equality......Page 498
Reversing an Array......Page 499
String Traversal Algorithms......Page 504
Functional Approach......Page 505
7.3. Reference Semantics......Page 506
Multiple Objects......Page 508
Shifting Values in an Array......Page 511
Arrays of Objects......Page 515
Nested Loop Algorithms......Page 517
Rectangular Two-Dimensional Arrays......Page 519
Jagged Arrays......Page 521
7.6. Arrays of Pixels......Page 526
7.7. Case Study: Benford’s Law......Page 531
Tallying Values......Page 532
Completing the Program......Page 536
Chapter 8: Classes......Page 557
8.1. Object-Oriented Programming......Page 558
Classes and Objects......Page 559
Point Objects......Page 561
8.2. Object State and Behavior......Page 562
Object State: Fields......Page 563
Object Behavior: Methods......Page 565
The Implicit Parameter......Page 568
Mutators and Accessors......Page 570
The toString Method......Page 572
8.3. Object Initialization: Constructors......Page 574
The Keyword this......Page 579
Multiple Constructors......Page 581
8.4. Encapsulation......Page 582
Private Fields......Page 583
Class Invariants......Page 589
Changing Internal Implementations......Page 593
8.5. Case Study: Designing a Stock Class......Page 595
Object-Oriented Design Heuristics......Page 596
Stock Fields and Method Headers......Page 598
Stock Method and Constructor Implementation......Page 600
Chapter 9: Inheritance and Interfaces......Page 614
9.1. Inheritance Basics......Page 615
Nonprogramming Hierarchies......Page 616
Extending a Class......Page 618
Overriding Methods......Page 622
Calling Overridden Methods......Page 624
Accessing Inherited Fields......Page 625
Calling a Superclass’s Constructor......Page 627
DividendStock Behavior......Page 629
The Object Class......Page 631
The equals Method......Page 632
The instanceof Keyword......Page 635
9.3. Polymorphism......Page 637
Polymorphism Mechanics......Page 640
Interpreting Inheritance Code......Page 642
Interpreting Complex Calls......Page 644
A Misuse of Inheritance......Page 647
Is-a Versus Has-a Relationships......Page 650
Graphics2D......Page 651
9.5. Interfaces......Page 653
An Interface for Shapes......Page 654
Implementing an Interface......Page 656
Benefits of Interfaces......Page 659
9.6. Case Study: Financial Class Hierarchy......Page 661
Designing the Classes......Page 662
Redundant Implementation......Page 666
Abstract Classes......Page 669
Chapter 10: ArrayLists......Page 689
10.1. ArrayLists......Page 690
Basic ArrayList Operations......Page 691
ArrayList Searching Methods......Page 694
A Complete ArrayList Program......Page 697
Adding to and Removing from an ArrayList......Page 699
Using the For-Each Loop with ArrayLists......Page 703
Wrapper Classes......Page 704
10.2. The Comparable Interface......Page 707
Natural Ordering and compareTo......Page 709
Implementing the Comparable Interface......Page 713
Some Efficiency Considerations......Page 719
Version 1: Compute Vocabulary......Page 722
Version 2: Compute Overlap......Page 725
Version 3: Complete Program......Page 730
Chapter 11: Java Collections Framework......Page 742
Collections......Page 743
LinkedList versus ArrayList......Page 744
Iterators......Page 747
Abstract Data Types (ADTs)......Page 751
LinkedList Case Study: Sieve......Page 753
11.2. Sets......Page 756
Set Concepts......Page 757
TreeSet versus HashSet......Page 759
Set Operations......Page 760
Set Case Study: Lottery......Page 762
11.3. Maps......Page 764
Basic Map Operations......Page 765
Map Views (keySet and values)......Page 767
TreeMap versus HashMap......Page 768
Map Case Study: WordCount......Page 769
Collection Overview......Page 772
Chapter 12: Recursion......Page 781
A Nonprogramming Example......Page 782
An Iterative Solution Converted to Recursion......Page 785
Structure of Recursive Solutions......Page 787
12.2. A Better Example of Recursion......Page 789
Mechanics of Recursion......Page 791
Integer Exponentiation......Page 799
Greatest Common Divisor......Page 802
Directory Crawler......Page 808
Helper Methods......Page 812
12.4. Recursive Graphics......Page 815
12.5. Recursive Backtracking......Page 819
A Simple Example: Traveling North/East......Page 820
8 Queens Puzzle......Page 825
Solving Sudoku Puzzles......Page 832
Infix, Prefix, and Postfix Notation......Page 836
Evaluating Prefix Expressions......Page 837
Complete Program......Page 840
Chapter 13: Searching and Sorting......Page 859
13.1. Searching and Sorting in the Java Class Libraries......Page 860
Binary Search......Page 861
Sorting......Page 864
Shuffling......Page 865
Custom Ordering with Comparators......Page 866
13.2. Program Complexity......Page 870
Empirical Analysis......Page 873
Complexity Classes......Page 877
13.3. Implementing Searching and Sorting Algorithms......Page 879
Sequential Search......Page 880
Binary Search......Page 881
Recursive Binary Search......Page 884
Searching Objects......Page 887
Selection Sort......Page 888
13.4. Case Study: Implementing Merge Sort......Page 891
Splitting and Merging Arrays......Page 892
Recursive Merge Sort......Page 895
Complete Program......Page 898
Chapter 14: Stacks and Queues......Page 911
Stack Concepts......Page 912
Queue Concepts......Page 915
14.2. Common Stack/Queue Operations......Page 916
Transferring Between Stacks and Queues......Page 918
Sum of a Queue......Page 919
Sum of a Stack......Page 920
Removing Values from a Queue......Page 923
Comparing Two Stacks for Similarity......Page 925
14.4. Case Study: Expression Evaluator......Page 927
Splitting into Tokens......Page 928
The Evaluator......Page 933
Chapter 15: Implementing a Collection Class......Page 949
Adding and Printing......Page 950
Thinking about Encapsulation......Page 956
Dealing with the Middle of the List......Page 957
Another Constructor and a Constant......Page 962
Preconditions and Postconditions......Page 963
Throwing Exceptions......Page 967
Convenience Methods......Page 970
Resizing When Necessary......Page 973
Adding an Iterator......Page 975
15.4. ArrayList......Page 981
Chapter 16: Linked Lists......Page 992
16.1. Working with Nodes......Page 993
Constructing a List......Page 994
List Basics......Page 996
Manipulating Nodes......Page 999
Traversing a List......Page 1002
Simple LinkedIntList......Page 1006
Appending add......Page 1008
The Middle of the List......Page 1012
16.3. A Complex List Operation......Page 1019
Inchworm Approach......Page 1024
16.4. An IntList Interface......Page 1025
16.5. LinkedList......Page 1028
Linked List Variations......Page 1029
Linked List Iterators......Page 1032
Other Code Details......Page 1034
Chapter 17: Binary Trees......Page 1044
17.1. Binary Tree Basics......Page 1045
Node and Tree Classes......Page 1048
17.2. Tree Traversals......Page 1049
Constructing and Viewing a Tree......Page 1055
Sum of a Tree......Page 1064
Counting Levels......Page 1065
Counting Leaves......Page 1067
17.4. Binary Search Trees......Page 1068
The Binary Search Tree Property......Page 1069
Building a Binary Search Tree......Page 1071
The Pattern x = change(x)......Page 1075
Searching the Tree......Page 1078
Binary Search Tree Complexity......Page 1082
17.5. SearchTree......Page 1083
Chapter 18: Advanced Data Structures......Page 1098
Array Set Implementations......Page 1099
Hash Functions and Hash Tables......Page 1100
Collisions......Page 1102
Rehashing......Page 1107
Hashing Non-Integer Data......Page 1110
Hash Map Implementation......Page 1113
Priority Queues......Page 1114
Introduction to Heaps......Page 1116
Removing from a Heap......Page 1118
Adding to a Heap......Page 1119
Array Heap Implementation......Page 1121
Heap Sort......Page 1125
Chapter 19: Functional Programming with Java 8......Page 1134
19.1. Effect-Free Programming......Page 1135
19.2. First-Class Functions......Page 1138
Lambda Expressions......Page 1141
Basic Idea......Page 1144
Using Map......Page 1146
Using Filter......Page 1147
Using Reduce......Page 1149
Optional Results......Page 1150
19.4. Function Closures......Page 1151
19.5. Higher-Order Operations on Collections......Page 1154
Working with Arrays......Page 1155
Working with Lists......Page 1156
Working with Files......Page 1160
19.6. Case Study: Perfect Numbers......Page 1161
Computing Sums......Page 1162
Incorporating Square Root......Page 1165
Just Five and Leveraging Concurrency......Page 1168
Appendix A: Java Summary......Page 1176
Appendix B: The Java API Specification and Javadoc Comments......Page 1191
Appendix C: Additional Java Syntax......Page 1197
Index......Page 1206
Credits......Page 1220
Back Cover......Page 1226