Core Java for the Impatient

Auteur

Cay S. Horstmann is author of Core Java, Volumes I and II, Thirteenth Edition (Pearson, 2025), Modern JavaScript for the Impatient (Addison-Wesley, 2020), and Scala for the Impatient, Third Edition (Addison-Wesley, 2023). He has written more than a dozen other books for professional programmers and computer science students. He is an emeritus professor of computer science at San Jose State University and a Java Champion.

Texte du rabat

An Essential Guide to the Core Language and Libraries--Updated for Java 21 Modern Java introduces major enhancements that impact the core language and APIs at the heart of the Java platform. Many old Java idioms are no longer needed, and new features and programming paradigms can make you far more effective. However, navigating these changes can be challenging. Core Java for the Impatient, Fourth Edition, is a complete guide that reflects all changes through Java SE 21, Oracle's latest Long-Term Support (LTS) release. Written by Cay S. Horstmann--author of the classic two-volume Core Java--this concise tutorial offers a faster, easier pathway for learning modern Java. Horstmann covers everything working developers need to know, including the powerful concepts of lambda expressions and streams, modern constructs such as records and sealed classes, and sophisticated concurrent programming techniques. Given the size and scope of Java 21, there's plenty to cover. As in previous editions, everything is presented in small chunks organized for quick access and easy understanding, with plenty of practical insights and sample code to help you quickly apply all that's new. Test code as you create it with JShellImprove your object-oriented design with records and sealed classesEffectively use text blocks, switch expressions, and pattern matchingUnderstand functional programming with lambda expressionsStreamline and optimize data management with the Streams APIUse structured techniques, threadsafe data structures, and virtual threads for effective concurrent programmingWork with the modularized Java API and third-party modulesTake advantage of API improvements for working with collections, input/output, regular expressions, and processes Whether you're an experienced developer just getting started with modern Java or have been programming with Java for years, this guide will help you write more robust, efficient, and secure Java code. Core Java for the Impatient provides accessible coverage of Java features that will enable readers to Master foundational techniques, idioms, and best practices for writing superior Java codeLeverage the power of input/outputImprove performance and efficiencyFully utilize multicore processors with Java's improved concurrency Register your book for convenient access to downloads, updates, and/or corrections as they become available. See inside book for details.

Contenu

Preface xv
Acknowledgments xvii

Chapter 1: Fundamental Programming Structures 1
1.1 Our First Program 1
1.2 Primitive Types 12
1.3 Variables 15
1.4 Arithmetic Operations 18
1.5 Strings 25
1.6 Input and Output 36
1.7 Control Flow 40
1.8 Arrays and Array Lists 48
1.9 Functional Decomposition 58
1.10 Exercises 60

Chapter 2: Object-Oriented Programming 63
2.1 Working with Objects 63
2.2 Implementing Classes 68
2.3 Object Construction 73
2.4 Records 78
2.5 Static Variables and Methods 81
2.6 Packages 85
2.7 Nested Classes 92
2.8 Documentation Comments 97
2.9 Exercises 102

Chapter 3: Interfaces and Lambda Expressions 105
3.1 Interfaces 106
3.2 Static, Default, and Private Methods 113
3.3 Examples of Interfaces 117
3.4 Lambda Expressions 121
3.5 Method and Constructor References 124
3.6 Processing Lambda Expressions 126
3.7 Lambda Expressions and Variable Scope 131
3.8 Higher-Order Functions 135
3.9 Local and Anonymous Classes 137
3.10 Exercises 139

Chapter 4: Inheritance and Reflection 141
4.1 Extending a Class 142
4.2 Inheritance Hierarchies 148
4.3 Object: The Cosmic Superclass 155
4.4 Enumerations 164
4.5 Pattern Matching 168
4.6 Runtime Type Information and Resources 174
4.7 Reflection 183
4.8 Exercises 192

Chapter 5: Exceptions, Assertions, and Logging 195
5.1 Exception Handling 195
5.2 Assertions 208
5.3 Logging 210
5.4 Exercises 219

Chapter 6: Generic Programming 221
6.1 Generic Classes 222
6.2 Generic Methods 222
6.3 Type Bounds 223
6.4 Type Variance and Wildcards 224
6.5 Generics in the Java Virtual Machine 230
6.6 Restrictions on Generics 233
6.7 Reflection and Generics 240
6.8 Exercises 243

Chapter 7: Collections 247
7.1 An Overview of the Collections Framework 247
7.2 Iterators 253
7.3 Sets 254
7.4 Maps 256
7.5 Other Collections 262
7.6 Views 269
7.7 Exercises 271

Chapter 8: Streams 275
8.1 From Iterating to Stream Operations 275
8.2 Stream Creation 277
8.3 The filter, map, and flatMap Methods 280
8.4 Extracting Substreams and Combining Streams 282
8.5 Other Stream Transformations 283
8.6 Simple Reductions 284
8.7 The Optional Type 285
8.8 Collecting Results 290
8.9 Collecting into Maps 291
8.10 Grouping and Partitioning 293
8.11 Downstream Collectors 294
8.12 Reduction Operations 296
8.13 Primitive Type Streams 298
8.14 Parallel Streams 299
8.15 Exercises 302

Chapter 9: Processing Input and Output 305
9.1 Input/Output Streams, Readers, and Writers 305
9.2 Paths, Files, and Directories 317
9.3 HTTP Connections 325
9.4 Regular Expressions 328
9.5 Serialization 340
9.6 Exercises 350

Chapter 10: Concurrent Programming 353
10.1 Concurrent Tasks 354
10.2 Thread Safety 361
10.3 Threadsafe Data Structures 367
10.4 Parallel Algorithms 371
10.5 Asynchronous Computations 373
10.6 Atomic Counters and Accumulators 380
10.7 Locks and Conditions 383
10.8 Threads 388
10.9 Processes 392
10.10 Exercises 397

Chapter 11: Annotations 403
11.1 Using Annotations 404
11.2 Defining Annotations 409
11.3 Annotations in the Java API 412
11.4 Processing Annotations at Runtime 416
11.5 Source-Level Annotation Processing 419
11.6 Exercises 423

Chapter 12: The Java Platform Module System 425
12.1 The Module Concept 426
12.2 Naming Modules 427
12.3 The Modular "Hello, World!" Program 428
12.4 Requiring Modules 429
12.5 Exporting Packages 431
12.6 Modules and Reflective Access 435
12.7 Modular JARs 438
12.8 Automatic Modules 439
12.9 The Unnamed Module 441
12.10 Command-Line Flags for Migration 441
12.11 Transitive and Static Requirements 443
12.12 Qualified Exporting and Opening 444
12.13 Service Loading 445
12.14 Tools for Working with Modules 446
12.15 Exercises 449

Index 451