ebook img

Java Language Features PDF

911 Pages·2018·5.567 MB·
Save to my drive
Quick download
Download
Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.

Preview Java Language Features

Java Language Features With Modules, Streams, Threads, I/O and Lambda Expressions Second Edition Kishori Sharan Java Language Features:With Modules, Streams, Threads, I/O, and Lambda Expressions Kishori Sharan Montgomery, Alabama, USA ISBN-13 (pbk): 978-1-4842-3347-4 ISBN-13 (electronic): 978-1-4842-3348-1 https://doi.org/10.1007/978-1-4842-3348-1 Library of Congress Control Number: 2018932349 Copyright © 2018 by Kishori Sharan Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book’s product page, located at www.apress.com/9781484233474. For more detailed information, please visit http://www.apress.com/source-code. Contents Introduction� ����������������������������������������������������������������������������������������������������������xxv ■ Chapter 1: Annotations ������������������������������������������������������������������������������������������1 What Are Annotations? �����������������������������������������������������������������������������������������������������1 Declaring an Annotation Type �������������������������������������������������������������������������������������������4 Restrictions on Annotation Types �������������������������������������������������������������������������������������7 Restriction #1 �����������������������������������������������������������������������������������������������������������������������������������������7 Restriction #2 �����������������������������������������������������������������������������������������������������������������������������������������8 Restriction #3 �����������������������������������������������������������������������������������������������������������������������������������������8 Restriction #4 �����������������������������������������������������������������������������������������������������������������������������������������9 Restriction #5 �����������������������������������������������������������������������������������������������������������������������������������������9 Restriction #6 �����������������������������������������������������������������������������������������������������������������������������������������9 Default Value of an Annotation Element ���������������������������������������������������������������������������9 Annotation Type and Its Instances ����������������������������������������������������������������������������������10 Using Annotations ����������������������������������������������������������������������������������������������������������11 Primitive Types �������������������������������������������������������������������������������������������������������������������������������������12 String Types ������������������������������������������������������������������������������������������������������������������������������������������12 Class Types �������������������������������������������������������������������������������������������������������������������������������������������13 Enum Type ��������������������������������������������������������������������������������������������������������������������������������������������14 Annotation Type ������������������������������������������������������������������������������������������������������������������������������������16 Array Type Annotation Element �������������������������������������������������������������������������������������������������������������16 No Null Value in an Annotation ���������������������������������������������������������������������������������������17 Shorthand Annotation Syntax �����������������������������������������������������������������������������������������17 Marker Annotation Types ������������������������������������������������������������������������������������������������19 Meta-Annotation Types ���������������������������������������������������������������������������������������������������19 The Target Annotation Type �������������������������������������������������������������������������������������������������������������������20 The Retention Annotation Type �������������������������������������������������������������������������������������������������������������23 The Inherited Annotation Type ��������������������������������������������������������������������������������������������������������������24 The Documented Annotation Type ��������������������������������������������������������������������������������������������������������24 The Repeatable Annotation Type ����������������������������������������������������������������������������������������������������������25 Commonly Used Standard Annotations ��������������������������������������������������������������������������26 Deprecating APIs ����������������������������������������������������������������������������������������������������������������������������������27 Suppressing Named Compile-Time Warnings �������������������������������������������������������������������������������������38 Overriding Methods ������������������������������������������������������������������������������������������������������������������������������39 Declaring Functional Interfaces �����������������������������������������������������������������������������������������������������������40 Annotating Packages ������������������������������������������������������������������������������������������������������41 Annotating Modules �������������������������������������������������������������������������������������������������������41 Accessing Annotations at Runtime ���������������������������������������������������������������������������������42 Evolving Annotation Types ����������������������������������������������������������������������������������������������47 Annotation Processing at Source Code Level �����������������������������������������������������������������47 Summary ������������������������������������������������������������������������������������������������������������������������53 ■ Chapter 2: Inner Classes �������������������������������������������������������������������������������������57 What Is an Inner Class? ��������������������������������������������������������������������������������������������������57 Advantages of Using Inner Classes ��������������������������������������������������������������������������������59 Types of Inner Classes ����������������������������������������������������������������������������������������������������59 Member Inner Class������������������������������������������������������������������������������������������������������������������������������59 Local Inner Class ����������������������������������������������������������������������������������������������������������������������������������61 Anonymous Inner Class ������������������������������������������������������������������������������������������������������������������������65 A static Member Class Is Not an Inner Class ������������������������������������������������������������������68 Creating Objects of Inner Classes ����������������������������������������������������������������������������������70 Accessing Enclosing Class Members ����������������������������������������������������������������������������73 Restrictions on Accessing Local Variables ���������������������������������������������������������������������80 Inner Class and Inheritance ��������������������������������������������������������������������������������������������81 No static Members in an Inner Class �����������������������������������������������������������������������������83 Generated Class Files for Inner Classes �������������������������������������������������������������������������84 Inner Classes and the Compiler Magic ��������������������������������������������������������������������������85 Closures and Callbacks ��������������������������������������������������������������������������������������������������89 Defining Inner Classes in static Contexts �����������������������������������������������������������������������91 Summary ������������������������������������������������������������������������������������������������������������������������91 ■ Chapter 3: Reflection �������������������������������������������������������������������������������������������97 What Is Reflection? ��������������������������������������������������������������������������������������������������������97 Reflection in Java �����������������������������������������������������������������������������������������������������������98 Loading a Class ��������������������������������������������������������������������������������������������������������������99 Using Class Literals ������������������������������������������������������������������������������������������������������������������������������99 Using the Object::getClass() Method �������������������������������������������������������������������������������������������������100 Using the Class::forName() Method ���������������������������������������������������������������������������������������������������100 Class Loaders ���������������������������������������������������������������������������������������������������������������103 Class Loaders in JDK8 ������������������������������������������������������������������������������������������������������������������������103 Class Loaders in JDK9 ������������������������������������������������������������������������������������������������������������������������104 Reflecting on Classes ���������������������������������������������������������������������������������������������������107 Reflecting on Fields ������������������������������������������������������������������������������������������������������112 Reflecting on Executables ��������������������������������������������������������������������������������������������114 Reflecting on Methods ������������������������������������������������������������������������������������������������������������������������116 Reflecting on Constructors �����������������������������������������������������������������������������������������������������������������118 Creating Objects �����������������������������������������������������������������������������������������������������������120 Invoking Methods ���������������������������������������������������������������������������������������������������������121 Accessing Fields ����������������������������������������������������������������������������������������������������������122 Deep Reflection ������������������������������������������������������������������������������������������������������������124 Deep Reflection Within a Module ��������������������������������������������������������������������������������������������������������125 Deep Reflection Across Modules ��������������������������������������������������������������������������������������������������������129 Deep Reflection and Unnamed Modules ���������������������������������������������������������������������������������������������134 Deep Reflection on JDK Modules �������������������������������������������������������������������������������������������������������134 Reflecting on Arrays �����������������������������������������������������������������������������������������������������136 Expanding an Array ������������������������������������������������������������������������������������������������������138 Who Should Use Reflection? ����������������������������������������������������������������������������������������140 Summary ����������������������������������������������������������������������������������������������������������������������140 ■ Chapter 4: Generics �������������������������������������������������������������������������������������������143 What Are Generics? ������������������������������������������������������������������������������������������������������143 Supertype-Subtype Relationship ����������������������������������������������������������������������������������147 Raw Types ��������������������������������������������������������������������������������������������������������������������148 Unbounded Wildcards ��������������������������������������������������������������������������������������������������149 Upper-Bounded Wildcards ��������������������������������������������������������������������������������������������152 Lower-Bounded Wildcards �������������������������������������������������������������������������������������������153 Generic Methods and Constructors ������������������������������������������������������������������������������155 Type Inference in Generic Object Creation �������������������������������������������������������������������157 No Generic Exception Classes ��������������������������������������������������������������������������������������160 No Generic Anonymous Classes �����������������������������������������������������������������������������������160 Generics and Arrays �����������������������������������������������������������������������������������������������������160 Runtime Class Type of Generic Objects ������������������������������������������������������������������������161 Heap Pollution ��������������������������������������������������������������������������������������������������������������162 Varargs Methods and Heap Pollution Warnings �����������������������������������������������������������163 Summary ����������������������������������������������������������������������������������������������������������������������165 ■ Chapter 5: Lambda Expressions ������������������������������������������������������������������������169 What Is a Lambda Expression? ������������������������������������������������������������������������������������169 Why Do We Need Lambda Expressions? ����������������������������������������������������������������������171 Syntax for Lambda Expressions �����������������������������������������������������������������������������������173 Omitting Parameter Types ������������������������������������������������������������������������������������������������������������������174 Declaring a Single Parameter �������������������������������������������������������������������������������������������������������������175 Declaring No Parameters ��������������������������������������������������������������������������������������������������������������������175 Parameters with Modifiers �����������������������������������������������������������������������������������������������������������������175 Declaring Body of Lambda Expressions ���������������������������������������������������������������������������������������������176 Target Typing ����������������������������������������������������������������������������������������������������������������176 Functional Interfaces ����������������������������������������������������������������������������������������������������184 Using the @FunctionalInterface Annotation ���������������������������������������������������������������������������������������184 Generic Functional Interface ��������������������������������������������������������������������������������������������������������������185 Intersection Type and Lambda Expressions ����������������������������������������������������������������������������������������187 Commonly Used Functional Interfaces �����������������������������������������������������������������������������������������������188 Using the Function<T,R> Interface �����������������������������������������������������������������������������������������������������188 Using the Predicate<T> Interface ������������������������������������������������������������������������������������������������������190 Using Functional Interfaces ����������������������������������������������������������������������������������������������������������������191 Method References ������������������������������������������������������������������������������������������������������196 static Method References �������������������������������������������������������������������������������������������������������������������197 Instance Method References ��������������������������������������������������������������������������������������������������������������200 Supertype Instance Method References ���������������������������������������������������������������������������������������������203 Constructor References ����������������������������������������������������������������������������������������������������������������������205 Generic Method References ���������������������������������������������������������������������������������������������������������������208 Lexical Scoping ������������������������������������������������������������������������������������������������������������209 Variable Capture �����������������������������������������������������������������������������������������������������������211 Jumps and Exits �����������������������������������������������������������������������������������������������������������214 Recursive Lambda Expressions������������������������������������������������������������������������������������215 Comparing Objects �������������������������������������������������������������������������������������������������������216 Summary ����������������������������������������������������������������������������������������������������������������������218 ■ Chapter 6: Threads ��������������������������������������������������������������������������������������������223 What Is a Thread? ���������������������������������������������������������������������������������������������������������223 Creating Threads in Java ����������������������������������������������������������������������������������������������226 Specifying Your Code for a Thread �������������������������������������������������������������������������������228 Inheriting Your Class from the Thread Class ���������������������������������������������������������������������������������������229 Implementing the Runnable Interface ������������������������������������������������������������������������������������������������229 Using a Method Reference �����������������������������������������������������������������������������������������������������������������230 A Quick Example ���������������������������������������������������������������������������������������������������������������������������������230 Using Multiple Threads in a Program ���������������������������������������������������������������������������231 Issues in Using Multiple Threads ����������������������������������������������������������������������������������232 Java Memory Model �����������������������������������������������������������������������������������������������������235 Atomicity ���������������������������������������������������������������������������������������������������������������������������������������������236 Visibility ����������������������������������������������������������������������������������������������������������������������������������������������236 Ordering ����������������������������������������������������������������������������������������������������������������������������������������������236 Object’s Monitor and Threads Synchronization ������������������������������������������������������������237 Rule #1 �����������������������������������������������������������������������������������������������������������������������������������������������244 Rule #2 �����������������������������������������������������������������������������������������������������������������������������������������������245 The Producer/Consumer Synchronization Problem ������������������������������������������������������250 Which Thread Is Executing? �����������������������������������������������������������������������������������������254 Letting a Thread Sleep �������������������������������������������������������������������������������������������������255 I Will Join You in Heaven �����������������������������������������������������������������������������������������������256 Be Considerate to Others and Yield ������������������������������������������������������������������������������259 Lifecycle of a Thread ����������������������������������������������������������������������������������������������������259 Priority of a Thread �������������������������������������������������������������������������������������������������������263 Is It a Demon or a Daemon? �����������������������������������������������������������������������������������������264 Am I Interrupted? ���������������������������������������������������������������������������������������������������������266 Threads Work in a Group ����������������������������������������������������������������������������������������������270 Volatile Variables ����������������������������������������������������������������������������������������������������������271 Stopping, Suspending, and Resuming Threads �����������������������������������������������������������273 Spin-Wait Hints ������������������������������������������������������������������������������������������������������������277 Handling an Uncaught Exception in a Thread ���������������������������������������������������������������278 Thread Concurrency Packages �������������������������������������������������������������������������������������280 Atomic Variables �����������������������������������������������������������������������������������������������������������280 Scalar Atomic Variable Classes ����������������������������������������������������������������������������������������������������������281 Atomic Arrays Classes ������������������������������������������������������������������������������������������������������������������������281 Atomic Field Updater Classes �������������������������������������������������������������������������������������������������������������282 Atomic Compound Variable Classes ���������������������������������������������������������������������������������������������������282 Explicit Locks ���������������������������������������������������������������������������������������������������������������283 Synchronizers ���������������������������������������������������������������������������������������������������������������288 Semaphores����������������������������������������������������������������������������������������������������������������������������������������289 Barriers �����������������������������������������������������������������������������������������������������������������������������������������������292 Phasers �����������������������������������������������������������������������������������������������������������������������������������������������295 Latches �����������������������������������������������������������������������������������������������������������������������������������������������304 Exchangers �����������������������������������������������������������������������������������������������������������������������������������������306 The Executor Framework ���������������������������������������������������������������������������������������������310 Result-Bearing Tasks ��������������������������������������������������������������������������������������������������������������������������315 Scheduling a Task �������������������������������������������������������������������������������������������������������������������������������318 Handling Uncaught Exceptions in a Task Execution ���������������������������������������������������������������������������321 Executor’s Completion Service �����������������������������������������������������������������������������������������������������������322 The Fork/Join Framework ��������������������������������������������������������������������������������������������325 Steps in Using the Fork/Join Framework �������������������������������������������������������������������������������������������326 A Fork/Join Example ���������������������������������������������������������������������������������������������������������������������������328 Thread-Local Variables �������������������������������������������������������������������������������������������������330 Setting Stack Size of a Thread �������������������������������������������������������������������������������������333 Summary ����������������������������������������������������������������������������������������������������������������������334 ■ Chapter 7: Input/Output �������������������������������������������������������������������������������������337 What Is Input/Output? ��������������������������������������������������������������������������������������������������337 Working with Files ��������������������������������������������������������������������������������������������������������338 Creating a File Object �������������������������������������������������������������������������������������������������������������������������338 Knowing the Current Working Directory ���������������������������������������������������������������������������������������������339 Checking for a File’s Existence �����������������������������������������������������������������������������������������������������������340 Which Path Do You Want to Go? ����������������������������������������������������������������������������������������������������������340 Creating, Deleting, and Renaming Files ����������������������������������������������������������������������������������������������342 Working with File Attributes ���������������������������������������������������������������������������������������������������������������346 Copying a File �������������������������������������������������������������������������������������������������������������������������������������346 Knowing the Size of a File ������������������������������������������������������������������������������������������������������������������346 Listing Directories and Files ���������������������������������������������������������������������������������������������������������������347 The Decorator Pattern ��������������������������������������������������������������������������������������������������350 Input/Output Streams ���������������������������������������������������������������������������������������������������358 Reading from a File Using an Input Stream ����������������������������������������������������������������������������������������359 Writing Data to a File Using an Output Stream �����������������������������������������������������������������������������������363 Input Stream Meets the Decorator Pattern ������������������������������������������������������������������366 BufferedInputStream ��������������������������������������������������������������������������������������������������������������������������369 PushbackInputStream ������������������������������������������������������������������������������������������������������������������������370 Output Stream Meets the Decorator Pattern ����������������������������������������������������������������371 PrintStream�����������������������������������������������������������������������������������������������������������������������������������������373 Using Pipes �������������������������������������������������������������������������������������������������������������������375 Reading and Writing Primitive Data Types ��������������������������������������������������������������������378 Object Serialization ������������������������������������������������������������������������������������������������������380 Serializing Objects ������������������������������������������������������������������������������������������������������������������������������381 Deserializing Objects ��������������������������������������������������������������������������������������������������������������������������383 Externalizable Object Serialization �����������������������������������������������������������������������������������������������������385 Serializing transient Fields �������������������������������������������������������������������������������������������389 Advanced Object Serialization ��������������������������������������������������������������������������������������389 Writing an Object Multiple Times to a Stream ������������������������������������������������������������������������������������389 Class Evolution and Object Serialization ��������������������������������������������������������������������������������������������393 Stopping Serialization �������������������������������������������������������������������������������������������������������������������������394 Readers and Writers �����������������������������������������������������������������������������������������������������395 Custom Input/Output Streams ��������������������������������������������������������������������������������������399 Random Access Files ���������������������������������������������������������������������������������������������������402 Copying the Contents of a File��������������������������������������������������������������������������������������404 Standard Input/Output/Error Streams ��������������������������������������������������������������������������405

See more

The list of books you might like

Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.