1. Review of Java Fundamentals

   1. The Java Architecture
   2. Forms for Java Software
   3. Three Platforms
   4. The Java Language
   5. Numeric Types
   6. Characters and Booleans
   7. Enumerations
   8. Object References
   9. Strings and Arrays
   10. Conditional Constructs
   11. Looping Constructs
   12. Varargs.

2. Object-Oriented Software

   1. Complex Systems
   2. Abstraction
   3. Classes and Objects
   4. Responsibilities and Collaborators
   5. UML
   6. Relationships
   7. Visibility

3. Classes and Objects

   1. Java Classes
   2. Constructors and Garbage Collection
   3. Naming Conventions and JavaBeans
   4. Relationships Between Classes
   5. Using this
   6. Visibility
   7. Packages and Imports
   8. Overloading Methods and Constructors
   9. JARs

4. Inheritance and Polymorphism in Java

   1. UML Specialization
   2. Extending Classes
   3. Using Derived Classes
   4. Type Identification
   5. Compile-Time and Run-Time Type
   6. Polymorphism
   7. Overriding Methods
   8. The @Override Annotation
   9. Superclass Reference

5. Using Classes Effectively

   1. Class Loading
   2. Static Members
   3. Statics and Non-Statics
   4. Static Initializers
   5. Static Imports
   6. Prohibiting Inheritance
   7. Costs of Object Creation
   8. Strings and StringBuffers
   9. Controlling Object Creation
   10. Understanding Enumerated Types
   11. Stateful and Behavioral Enumerations

6. Interfaces and Abstract Classes

   1. Separating Interface and Implementation
   2. UML Interfaces and Realization
   3. Defining Interfaces
   4. Implementing and Extending Interfaces
   5. Abstract Classes

7. Collections

   1. Dynamic Collections vs. Arrays
   2. UML Parameterized Type
   3. Generics
   4. Using Generics
   5. The Collections API
   6. The Collection and List Interfaces
   7. The ArrayList and LinkedList Classes
   8. Looping Over Collections: Iterable
   9. Collecting Primitive Values: Auto-Boxing
   10. Using Wildcards with Generic Types
   11. Iterators and the Iterator Interface
   12. Maps and the Map Interface
   13. Sorted Collections
   14. The SortedSet and SortedMap Interfaces
   15. The Collections Class Utility
   16. Algorithms
   17. Conversion Utilities

8. Exception Handling and Logging

   1. Reporting and Trapping Errors
   2. Exception Handling
   3. Throwing Exceptions
   4. Declaring Exceptions per Method
   5. Catching Exceptions
   6. The finally Block
   7. Catch-and-Release
   8. Chaining Exceptions
   9. try-with-resources
   10. Logging
   11. The Java SE Logging API
   12. Loggers
   13. Logging Levels
   14. Handlers
   15. Configuration
   16. Best Practices

9. Nested Classes

   1. Nested Classes
   2. Static Classes
   3. Inner Classes
   4. Relationship with the Outer Object
   5. Local Classes
   6. Enclosing Scope
   7. Anonymous Classes

10. Functional Programming

    1. Passing Behavior as a Parameter
    2. Inner Classes
    3. Functional Interfaces
    4. Built-In Functional Interfaces
    5. Lambda Expressions
    6. Scope and Visibility
    7. Deferred Execution
    8. Method References
    9. Creational Methods
    10. Designing for Functional Programming
    11. Default Methods

11. Streams

    1. The Stream Processing Model
    2. Streams
    3. Relationship to Collections
    4. Advantages and Disadvantages
    5. Iterating, Filtering, and Mapping
    6. Primitive-Type Streams
    7. Aggregate Functions and Statistics
    8. Sorting
    9. Generating, Limiting, and Reducing
    10. Finding and Matching
    11. Grouping
    12. Flattening and Traversing
    13. Sequential vs. Parallel Processing