An Accessible Guide to the Java Language and Libraries

Modern Java introduces major enhancements that impact the core Java technologies and APIs at the heart of the Java platform. Many old Java idioms are no longer needed and new features such as modularization make you far more effective. However, navigating these changes can be challenging.

Core Java® SE 9 for the Impatient, Second Edition, is a complete yet concise guide that includes all the latest changes up to Java SE 9. Written by Cay S. Horstmann–author of the classic two-volume Core Java–this indispensable tutorial offers a faster, easier pathway for learning modern Java. Given Java SE 9’s size and the scope of its enhancements, there’s plenty to cover, but it’s presented in small chunks organized for quick access and easy understanding.

Horstmann’s practical insights and sample code help you quickly take advantage of all that’s new, from Java SE 9’s long-awaited “Project Jigsaw” module system to the improvements first introduced in Java SE 8, including lambda expressions and streams.

• Use modules to simplify the development of well-performing complex systems
• Migrate applications to work with the modularized Java API and third-party modules
• Test code as you create it with the new JShell Read-Eval-Print Loop (REPL)
• Use lambda expressions to express actions more concisely
• Streamline and optimize data management with today’s Streams API
• Leverage modern concurrent programming based on cooperating tasks
• Take advantage of a multitude of API improvements for working with collections, input/output, regular expressions, and processes
  

Whether you’re just getting started with modern Java or you’re an experienced developer, this guide will help you write tomorrow’s most robust, efficient, and secure Java code.

Register your product at informit.com/register for convenient access to downloads, updates, and/or corrections as they become available.

Table of Contents

Chapter 1: Fundamental Programming Structures
1.1 Our First Program
1.2 Primitive Types
1.3 Variables
1.4 Arithmetic Operations
1.5 Strings
1.6 Input and Output
1.7 Control Flow
1.8 Arrays and Array Lists
1.9 Functional Decomposition
Exercises
Chapter 2: Object-Oriented Programming
2.1 Working with Objects
2.2 Implementing Classes
2.3 Object Construction
2.4 Static Variables and Methods
2.5 Packages
2.6 Nested Classes
2.7 Documentation Comments
Exercises
Chapter 3: Interfaces and Lambda Expressions
3.1 Interfaces
3.2 Static and Default Methods

3.3 Examples of Interfaces
3.4 Lambda Expressions
3.5 Method and Constructor References
3.6 Processing Lambda Expressions
3.7 Lambda Expressions and Variable Scope
3.8 Higher-Order Functions
3.9 Local Inner Classes
Exercises
Chapter 4: Inheritance and Reflection
4.1 Extending a Class
4.2 Object: The Cosmic Superclass
4.3 Enumerations
4.4 Runtime Type Information and Resources
4.5 Reflection
Exercises
Chapter 5: Exceptions, Assertions, and Logging
5.1 Exception Handling
5.2 Assertions
5.3 Logging
Exercises
Chapter 6: Generic Programming
6.1 Generic Classes
6.2 Generic Methods
6.3 Type Bounds
6.4 Type Variance and Wildcards
6.5 Generics in the Java Virtual Machine
6.6 Restrictions on Generics
6.7 Reflection and Generics
Exercises
Chapter 7: Collections
7.1 An Overview of the Collections Framework
7.2 Iterators
7.3 Sets
7.4 Maps
7.5 Other Collections
7.6 Views
Chapter 8: Streams
8.1 From Iterating to Stream Operations
8.2 Stream Creation
8.3 The filter, map, and flatMap Methods
8.4 Extracting Substreams and Combining Streams
8.5 Other Stream Transformations
8.6 Simple Reductions
8.7 The Optional Type
8.8 Collecting Results
8.9 Collecting into Maps
8.10 Grouping and Partitioning
8.11 Downstream Collectors
8.12 Reduction Operations
8.13 Primitive Type Streams
8.14 Parallel Streams
Exercises
Chapter 9: Processing Input and Output
9.1 Input/Output Streams, Readers, and Writers
9.2 Paths, Files, and Directories
9.3 URL Connections
9.4 Regular Expressions
9.5 Serialization
Exercises
Chapter 10: Concurrent Programming
10.1 Concurrent Tasks
10.2 Thread Safety
10.3 Parallel Algorithms
10.4 Threadsafe Data Structures
10.5 Atomic Values
10.6 Locks
10.7 Threads
10.8 Asynchronous Computations
10.9 Processes
Exercises
Chapter 11: Annotations
11.1 Using Annotations
11.2 Defining Annotations
11.3 Standard Annotations
11.4 Processing Annotations at Runtime
11.5 Source-Level Annotation Processing
Exercises
Chapter 12: The Date and Time API
12.1 The Time Line
12.2 Local Dates
12.3 Date Adjusters
12.4 Local Time
12.5 Zoned Time
12.6 Formatting and Parsing
12.7 Interoperating with Legacy Code
Exercises
Chapter 13: Internationalization
13.1 Locales
13.2 Number Formats
13.3 Currencies
13.4 Date and Time Formatting
13.5 Collation and Normalization
13.6 Message Formatting
13.7 Resource Bundles
13.8 Character Encodings
13.9 Preferences
Exercises
Chapter 14: Compiling and Scripting
14.1 The Compiler API
14.2 The Scripting API
14.3 The Nashorn Scripting Engine
14.4 Shell Scripting with Nashorn
Exercises