Publication information:   Programming Abstractions in Java   Pearson, 2017   ISBN: 978-0134421186 Links:   The Pearson book site   The Amazon book site

Contents:
 
  Chapter 1. Overview of Java
    1.1 Your first Java program
    1.2 The history of Java
    1.3 The structure of a Java program
    1.4 Variables
    1.5 Constants
    1.6 Data types
    1.7 Expressions
    1.8 Statements
    1.9 Classes, objects, and methods
 
  Chapter 2. Methods
    2.1 Methods in Java
    2.2 Methods and program structure
    2.3 The mechanics of method calls
    2.4 A simple recursive function
    2.5 The Fibonacci function 3 Strings
    3.1 Using strings as abstract values
    3.2 String operations
    3.3 Writing string applications Contents
 
  Chapter 4. Files
    4.1 Text files
    4.2 Reading text files
    4.3 Writing text files
    4.4 Formatted output
    4.5 Formatted input
    4.6 Using file dialogs
 
  Chapter 5. Arrays
    5.1 Introduction to arrays
    5.2 Data representation and memory
    5.3 Using arrays for tabulation
    5.4 Initialization of arrays
    5.5 Multidimensional arrays
    5.6 Variadic parameter lists
 
  Chapter 6. Collections
    6.1 The ArrayList class
    6.2 Wrapper classes
    6.3 The stack abstraction
    6.4 The queue abstraction
    6.5 The map abstraction
    6.6 The set abstraction
    6.7 Iterating over a collection
 
  Chapter 7. Classes and Objects
    7.1 Classes and object-oriented design
    7.2 Designing a simple Point class
    7.3 Rational numbers
    7.4 Designing a token scanner class
    7.5 Linking objects together
    7.6 Enumerated types
    7.7 Unit testing
 
  Chapter 8. Inheritance
    8.1 Simple examples of inheritance
    8.2 Defining an Employee class
    8.3 A brief overview of Java graphics
    8.4 A hierarchy of graphical objects
    8.5 Defining a Console interface
 
  Chapter 9. Recursive Strategies
    9.1 Thinking recursively
    9.2 The Towers of Hanoi
    9.3 The subset-sum problem
    9.4 Generating permutations
    9.5 Graphical recursion
 
  Chapter 10. Backtracking Algorithms
    10.1 Recursive backtracking in a maze
    10.2 Backtracking and games
    10.3 The minimax algorithm
 
  Chapter 11. Algorithmic Analysis
    11.1 The sorting problem
    11.2 Computational complexity
    11.3 Recursion to the rescue
    11.4 Standard complexity classes
    11.5 The Quicksort algorithm
    11.6 Mathematical induction
 
  Chapter 12. Efficiency and Representation
    12.1 Software patterns for editing text
    12.2 Designing a simple text editor
    12.3 An array-based implementation
    12.4 A stack-based implementation
    12.5 A list-based implementation
 
  Chapter 13. Linear Structures
    13.1 Generic types
    13.2 Implementing stacks
    13.3 Implementing queues
    13.4 Implementing lists
    13.5 Analysis of the doubling strategy
 
  Chapter 14. Maps
    14.1 Implementing maps using arrays
    14.2 Lookup tables
    14.3 Hashing
    14.4 Implementing the HashMap class
 
  Chapter 15. Trees
    15.1 Family trees
    15.2 Binary search trees
    15.3 Balanced trees
    15.4 Implementing maps using BSTs
    15.5 Partially ordered trees
 
  Chapter 16. Sets
    16.1 Sets as a mathematical abstraction
    16.2 Implementation strategies for sets
    16.3 Expanding the set model
    16.4 Optimizing sets of small integers
 
  Chapter 17. Graphs
    17.1 The structure of a graph
    17.2 Representation strategies
    17.3 A set-based graph abstraction
    17.4 Graph traversals
    17.5 Finding minimum-cost paths
    17.6 Generalizing the Graph class
    17.7 Algorithms for searching the web
 
  Chapter 18. Expression Trees
    18.1 Overview of the interpreter
    18.2 The structure of expressions
    18.3 Parsing an expression
 
  Chapter 19. Using Functions as Data
    19.1 Interactive programs
    19.2 Command dispatch tables
    19.3 Lambda expressions
    19.4 Plotting a function
    19.5 Mapping functions