Java Notes for Professionals (Goal Kicker) (Z-Library)

📄 File Format: PDF

💾 File Size: 7.0 MB

📖 Read Online ⬇️ Download

Registered users can read the full content for free

Register as a Gaohf Library member to read the complete e-book online for free and enjoy a better reading experience.

📄 Page 1

Java Notes for ProfessionalsJava® Notes for Professionals GoalKicker.com Free Programming Books Disclaimer This is an unocial free book created for educational purposes and is not aliated with ocial Java® group(s) or company(s). All trademarks and registered trademarks are the property of their respective owners 900+ pages of professional hints and tricks

📄 Page 2

Contents About 1 ................................................................................................................................................................................... Chapter 1: Getting started with Java Language 2 .......................................................................................... Section 1.1: Creating Your First Java Program 2 ........................................................................................................... Chapter 2: Type Conversion 8 .................................................................................................................................... Section 2.1: Numeric primitive casting 8 ......................................................................................................................... Section 2.2: Basic Numeric Promotion 8 ........................................................................................................................ Section 2.3: Non-numeric primitive casting 8 ................................................................................................................ Section 2.4: Object casting 9 ........................................................................................................................................... Section 2.5: Testing if an object can be cast using instanceof 9 ................................................................................. Chapter 3: Getters and Setters 10 ........................................................................................................................... Section 3.1: Using a setter or getter to implement a constraint 10 ............................................................................. Section 3.2: Why Use Getters and Setters? 10 .............................................................................................................. Section 3.3: Adding Getters and Setters 11 ................................................................................................................... Chapter 4: Reference Data Types 13 .................................................................................................................... Section 4.1: Dereferencing 13 .......................................................................................................................................... Section 4.2: Instantiating a reference type 13 ............................................................................................................... Chapter 5: Java Compiler - 'javac' 14 .................................................................................................................... Section 5.1: The 'javac' command - getting started 14 ................................................................................................ Section 5.2: Compiling for a dierent version of Java 16 ............................................................................................ Chapter 6: Documenting Java Code 18 ................................................................................................................. Section 6.1: Building Javadocs From the Command Line 18 ....................................................................................... Section 6.2: Class Documentation 18 ............................................................................................................................. Section 6.3: Method Documentation 19 ......................................................................................................................... Section 6.4: Package Documentation 20 ....................................................................................................................... Section 6.5: Links 20 ......................................................................................................................................................... Section 6.6: Code snippets inside documentation 21 ................................................................................................... Section 6.7: Field Documentation 22 .............................................................................................................................. Section 6.8: Inline Code Documentation 22 ................................................................................................................... Chapter 7: Command line Argument Processing 24 ....................................................................................... Section 7.1: Argument processing using GWT ToolBase 24 ......................................................................................... Section 7.2: Processing arguments by hand 24 ............................................................................................................ Chapter 8: The Java Command - 'java' and 'javaw' 27 ................................................................................. Section 8.1: Entry point classes 27 .................................................................................................................................. Section 8.2: Troubleshooting the 'java' command 27 .................................................................................................. Section 8.3: Running a Java application with library dependencies 29 ..................................................................... Section 8.4: Java Options 30 ........................................................................................................................................... Section 8.5: Spaces and other special characters in arguments 31 ........................................................................... Section 8.6: Running an executable JAR file 33 ............................................................................................................ Section 8.7: Running a Java applications via a "main" class 33 ................................................................................. Chapter 9: Literals 35 ...................................................................................................................................................... Section 9.1: Using underscore to improve readability 35 ............................................................................................. Section 9.2: Hexadecimal, Octal and Binary literals 35 ................................................................................................ Section 9.3: Boolean literals 36 ....................................................................................................................................... Section 9.4: String literals 36 ........................................................................................................................................... Section 9.5: The Null literal 37 ......................................................................................................................................... Section 9.6: Escape sequences in literals 37 ..................................................................................................................

📄 Page 3

Section 9.7: Character literals 38 .................................................................................................................................... Section 9.8: Decimal Integer literals 38 .......................................................................................................................... Section 9.9: Floating-point literals 39 ............................................................................................................................. Chapter 10: Primitive Data Types 42 ....................................................................................................................... Section 10.1: The char primitive 42 .................................................................................................................................. Section 10.2: Primitive Types Cheatsheet 42 ................................................................................................................. Section 10.3: The float primitive 43 ................................................................................................................................. Section 10.4: The int primitive 44 ..................................................................................................................................... Section 10.5: Converting Primitives 45 ............................................................................................................................ Section 10.6: Memory consumption of primitives vs. boxed primitives 45 .................................................................. Section 10.7: The double primitive 46 ............................................................................................................................. Section 10.8: The long primitive 47 ................................................................................................................................. Section 10.9: The boolean primitive 48 ........................................................................................................................... Section 10.10: The byte primitive 48 ................................................................................................................................ Section 10.11: Negative value representation 49 ............................................................................................................ Section 10.12: The short primitive 50 ............................................................................................................................... Chapter 11: Strings 51 ...................................................................................................................................................... Section 11.1: Comparing Strings 51 .................................................................................................................................. Section 11.2: Changing the case of characters within a String 53 ............................................................................... Section 11.3: Finding a String Within Another String 55 ................................................................................................. Section 11.4: String pool and heap storage 56 ............................................................................................................... Section 11.5: Splitting Strings 57 ....................................................................................................................................... Section 11.6: Joining Strings with a delimiter 59 ............................................................................................................ Section 11.7: String concatenation and StringBuilders 60 ............................................................................................. Section 11.8: Substrings 61 ............................................................................................................................................... Section 11.9: Platform independent new line separator 62 ........................................................................................... Section 11.10: Reversing Strings 62 .................................................................................................................................. Section 11.11: Adding toString() method for custom objects 63 .................................................................................... Section 11.12: Remove Whitespace from the Beginning and End of a String 64 ........................................................ Section 11.13: Case insensitive switch 64 ......................................................................................................................... Section 11.14: Replacing parts of Strings 65 ................................................................................................................... Section 11.15: Getting the length of a String 66 .............................................................................................................. Section 11.16: Getting the nth character in a String 66 .................................................................................................. Section 11.17: Counting occurrences of a substring or character in a string 66 ......................................................... Chapter 12: StringBuer 68 ......................................................................................................................................... Section 12.1: String Buer class 68 .................................................................................................................................. Chapter 13: StringBuilder 69 ........................................................................................................................................ Section 13.1: Comparing StringBuer, StringBuilder, Formatter and StringJoiner 69 ............................................... Section 13.2: Repeat a String n times 70 ........................................................................................................................ Chapter 14: String Tokenizer 71 ................................................................................................................................ Section 14.1: StringTokenizer Split by space 71 ............................................................................................................. Section 14.2: StringTokenizer Split by comma ',' 71 ...................................................................................................... Chapter 15: Splitting a string into fixed length parts 72 ............................................................................... Section 15.1: Break a string up into substrings all of a known length 72 .................................................................... Section 15.2: Break a string up into substrings all of variable length 72 .................................................................... Chapter 16: Date Class 73 ............................................................................................................................................. Section 16.1: Convert java.util.Date to java.sql.Date 73 ................................................................................................. Section 16.2: A basic date output 73 ............................................................................................................................... Section 16.3: Java 8 LocalDate and LocalDateTime objects 74 ..................................................................................

📄 Page 4

Section 16.4: Creating a Specific Date 75 ....................................................................................................................... Section 16.5: Converting Date to a certain String format 75 ....................................................................................... Section 16.6: LocalTime 76 ............................................................................................................................................... Section 16.7: Convert formatted string representation of date to Date object 76 .................................................... Section 16.8: Creating Date objects 77 ........................................................................................................................... Section 16.9: Comparing Date objects 77 ...................................................................................................................... Section 16.10: Converting String into Date 80 ................................................................................................................ Section 16.11: Time Zones and java.util.Date 80 ............................................................................................................. Chapter 17: Dates and Time (java.time.*) 82 ....................................................................................................... Section 17.1: Calculate Dierence between 2 LocalDates 82 ....................................................................................... Section 17.2: Date and time 82 ........................................................................................................................................ Section 17.3: Operations on dates and times 82 ........................................................................................................... Section 17.4: Instant 82 ..................................................................................................................................................... Section 17.5: Usage of various classes of Date Time API 83 ........................................................................................ Section 17.6: Date Time Formatting 85 ........................................................................................................................... Section 17.7: Simple Date Manipulations 85 ................................................................................................................... Chapter 18: LocalTime 87 .............................................................................................................................................. Section 18.1: Amount of time between two LocalTime 87 ............................................................................................ Section 18.2: Intro 88 ........................................................................................................................................................ Section 18.3: Time Modification 88 .................................................................................................................................. Section 18.4: Time Zones and their time dierence 88 ................................................................................................. Chapter 19: BigDecimal 90 ............................................................................................................................................ Section 19.1: Comparing BigDecimals 90 ........................................................................................................................ Section 19.2: Using BigDecimal instead of float 90 ....................................................................................................... Section 19.3: BigDecimal.valueOf() 91 ............................................................................................................................ Section 19.4: Mathematical operations with BigDecimal 91 ......................................................................................... Section 19.5: Initialization of BigDecimals with value zero, one or ten 94 ................................................................... Section 19.6: BigDecimal objects are immutable 94 ..................................................................................................... Chapter 20: BigInteger 96 ............................................................................................................................................ Section 20.1: Initialization 96 ............................................................................................................................................ Section 20.2: BigInteger Mathematical Operations Examples 97 ............................................................................... Section 20.3: Comparing BigIntegers 99 ........................................................................................................................ Section 20.4: Binary Logic Operations on BigInteger 100 ........................................................................................... Section 20.5: Generating random BigIntegers 101 ....................................................................................................... Chapter 21: NumberFormat 103 ................................................................................................................................. Section 21.1: NumberFormat 103 .................................................................................................................................... Chapter 22: Bit Manipulation 104 .............................................................................................................................. Section 22.1: Checking, setting, clearing, and toggling individual bits. Using long as bit mask 104 ........................ Section 22.2: java.util.BitSet class 104 ............................................................................................................................ Section 22.3: Checking if a number is a power of 2 105 .............................................................................................. Section 22.4: Signed vs unsigned shift 107 .................................................................................................................... Section 22.5: Expressing the power of 2 107 ................................................................................................................. Section 22.6: Packing / unpacking values as bit fragments 108 ................................................................................ Chapter 23: Arrays 109 ................................................................................................................................................... Section 23.1: Creating and Initializing Arrays 109 ......................................................................................................... Section 23.2: Creating a List from an Array 115 ........................................................................................................... Section 23.3: Creating an Array from a Collection 117 ................................................................................................ Section 23.4: Multidimensional and Jagged Arrays 117 .............................................................................................. Section 23.5: ArrayIndexOutOfBoundsException 119 ..................................................................................................

📄 Page 5

Section 23.6: Array Covariance 120 ............................................................................................................................... Section 23.7: Arrays to Stream 121 ................................................................................................................................ Section 23.8: Iterating over arrays 121 .......................................................................................................................... Section 23.9: Arrays to a String 123 ............................................................................................................................... Section 23.10: Sorting arrays 124 .................................................................................................................................... Section 23.11: Getting the Length of an Array 126 ........................................................................................................ Section 23.12: Finding an element in an array 126 ....................................................................................................... Section 23.13: How do you change the size of an array? 127 ..................................................................................... Section 23.14: Converting arrays between primitives and boxed types 128 .............................................................. Section 23.15: Remove an element from an array 129 ................................................................................................ Section 23.16: Comparing arrays for equality 130 ........................................................................................................ Section 23.17: Copying arrays 130 .................................................................................................................................. Section 23.18: Casting Arrays 131 ................................................................................................................................... Chapter 24: Collections 133 ......................................................................................................................................... Section 24.1: Removing items from a List within a loop 133 ........................................................................................ Section 24.2: Constructing collections from existing data 135 .................................................................................... Section 24.3: Declaring an ArrayList and adding objects 137 ..................................................................................... Section 24.4: Iterating over Collections 137 .................................................................................................................. Section 24.5: Immutable Empty Collections 139 ........................................................................................................... Section 24.6: Sub Collections 139 ................................................................................................................................... Section 24.7: Unmodifiable Collection 140 ..................................................................................................................... Section 24.8: Pitfall: concurrent modification exceptions 141 ..................................................................................... Section 24.9: Removing matching items from Lists using Iterator 141 ...................................................................... Section 24.10: Join lists 142 ............................................................................................................................................. Section 24.11: Creating your own Iterable structure for use with Iterator or for-each loop 142 .............................. Section 24.12: Collections and Primitive Values 144 ..................................................................................................... Chapter 25: Lists 146 ....................................................................................................................................................... Section 25.1: Sorting a generic list 146 ........................................................................................................................... Section 25.2: Convert a list of integers to a list of strings 147 ..................................................................................... Section 25.3: Classes implementing List - Pros and Cons 147 ..................................................................................... Section 25.4: Finding common elements between 2 lists 150 ..................................................................................... Section 25.5: In-place replacement of a List element 150 ........................................................................................... Section 25.6: Making a list unmodifiable 151 ................................................................................................................ Section 25.7: Moving objects around in the list 151 ...................................................................................................... Section 25.8: Creating, Adding and Removing element from an ArrayList 152 ........................................................ Section 25.9: Creating a List 152 ..................................................................................................................................... Section 25.10: Positional Access Operations 153 .......................................................................................................... Section 25.11: Iterating over elements in a list 155 ........................................................................................................ Section 25.12: Removing elements from list B that are present in the list A 155 ....................................................... Chapter 26: Sets 157 ........................................................................................................................................................ Section 26.1: Initialization 157 .......................................................................................................................................... Section 26.2: Basics of Set 157 ........................................................................................................................................ Section 26.3: Types and Usage of Sets 158 ................................................................................................................... Section 26.4: Create a list from an existing Set 159 ...................................................................................................... Section 26.5: Eliminating duplicates using Set 159 ....................................................................................................... Section 26.6: Declaring a HashSet with values 160 ...................................................................................................... Chapter 27: List vs Set 161 ........................................................................................................................................... Section 27.1: List vs Set 161 ............................................................................................................................................. Chapter 28: Maps 162 ...................................................................................................................................................... Section 28.1: Iterating Map Entries Eciently 162 .........................................................................................................

📄 Page 6

Section 28.2: Usage of HashMap 164 ............................................................................................................................ Section 28.3: Using Default Methods of Map from Java 8 165 ................................................................................... Section 28.4: Iterating through the contents of a Map 167 ......................................................................................... Section 28.5: Merging, combine and composing Maps 168 ........................................................................................ Section 28.6: Add multiple items 169 .............................................................................................................................. Section 28.7: Creating and Initializing Maps 171 ........................................................................................................... Section 28.8: Check if key exists 172 .............................................................................................................................. Section 28.9: Add an element 172 .................................................................................................................................. Section 28.10: Clear the map 173 .................................................................................................................................... Section 28.11: Use custom object as key 173 ................................................................................................................. Chapter 29: LinkedHashMap 175 ............................................................................................................................... Section 29.1: Java LinkedHashMap class 175 ............................................................................................................... Chapter 30: WeakHashMap 176 ................................................................................................................................. Section 30.1: Concepts of WeakHashmap 176 .............................................................................................................. Chapter 31: SortedMap 177 .......................................................................................................................................... Section 31.1: Introduction to sorted Map 177 ................................................................................................................. Chapter 32: TreeMap and TreeSet 178 .................................................................................................................. Section 32.1: TreeMap of a simple Java type 178 ........................................................................................................ Section 32.2: TreeSet of a simple Java Type 178 ......................................................................................................... Section 32.3: TreeMap/TreeSet of a custom Java type 179 ....................................................................................... Section 32.4: TreeMap and TreeSet Thread Safety 180 .............................................................................................. Chapter 33: Queues and Deques 182 ...................................................................................................................... Section 33.1: The usage of the PriorityQueue 182 ......................................................................................................... Section 33.2: Deque 182 ................................................................................................................................................... Section 33.3: Stacks 183 ................................................................................................................................................... Section 33.4: BlockingQueue 184 .................................................................................................................................... Section 33.5: LinkedList as a FIFO Queue 185 ............................................................................................................... Section 33.6: Queue Interface 186 .................................................................................................................................. Chapter 34: Dequeue Interface 187 ........................................................................................................................ Section 34.1: Adding Elements to Deque 187 ................................................................................................................. Section 34.2: Removing Elements from Deque 187 ...................................................................................................... Section 34.3: Retrieving Element without Removing 187 ............................................................................................. Section 34.4: Iterating through Deque 187 .................................................................................................................... Chapter 35: Enums 189 ................................................................................................................................................... Section 35.1: Declaring and using a basic enum 189 .................................................................................................... Section 35.2: Enums with constructors 192 ................................................................................................................... Section 35.3: Enums with Abstract Methods 193 ........................................................................................................... Section 35.4: Implements Interface 194 ......................................................................................................................... Section 35.5: Implement Singleton pattern with a single-element enum 195 ............................................................ Section 35.6: Using methods and static blocks 196 ...................................................................................................... Section 35.7: Zero instance enum 196 ........................................................................................................................... Section 35.8: Enum as a bounded type parameter 197 ............................................................................................... Section 35.9: Documenting enums 197 .......................................................................................................................... Section 35.10: Enum constant specific body 198 ........................................................................................................... Section 35.11: Getting the values of an enum 199 ......................................................................................................... Section 35.12: Enum Polymorphism Pattern 200 ........................................................................................................... Section 35.13: Compare and Contains for Enum values 201 ........................................................................................ Section 35.14: Get enum constant by name 201 ........................................................................................................... Section 35.15: Enum with properties (fields) 202 ...........................................................................................................

📄 Page 7

Section 35.16: Convert enum to String 203 .................................................................................................................... Section 35.17: Enums with static fields 203 ..................................................................................................................... Chapter 36: Enum Map 205 ........................................................................................................................................... Section 36.1: Enum Map Book Example 205 .................................................................................................................. Chapter 37: EnumSet class 206 .................................................................................................................................. Section 37.1: Enum Set Example 206 .............................................................................................................................. Chapter 38: Enum starting with number 207 ...................................................................................................... Section 38.1: Enum with name at beginning 207 ........................................................................................................... Chapter 39: Hashtable 208 ........................................................................................................................................... Section 39.1: Hashtable 208 ............................................................................................................................................. Chapter 40: Operators 209 .......................................................................................................................................... Section 40.1: The Increment/Decrement Operators (++/--) 209 ................................................................................ Section 40.2: The Conditional Operator (? :) 209 .......................................................................................................... Section 40.3: The Bitwise and Logical Operators (~, &, |, ^) 211 .................................................................................. Section 40.4: The String Concatenation Operator (+) 212 ........................................................................................... Section 40.5: The Arithmetic Operators (+, -, *, /, %) 214 ............................................................................................. Section 40.6: The Shift Operators (<<, >> and >>>) 216 ............................................................................................... Section 40.7: The Instanceof Operator 217 ................................................................................................................... Section 40.8: The Assignment Operators (=, +=, -=, *=, /=, %=, <<=, >>= , >>>=, &=, |= and ^=) 218 ............................. Section 40.9: The conditional-and and conditional-or Operators ( && and || ) 220 .................................................. Section 40.10: The Relational Operators (<, <=, >, >=) 221 ............................................................................................ Section 40.11: The Equality Operators (==, !=) 222 ......................................................................................................... Section 40.12: The Lambda operator ( -> ) 224 ............................................................................................................. Chapter 41: Constructors 225 ..................................................................................................................................... Section 41.1: Default Constructor 225 ............................................................................................................................. Section 41.2: Call parent constructor 226 ....................................................................................................................... Section 41.3: Constructor with Arguments 227 .............................................................................................................. Chapter 42: Object Class Methods and Constructor 229 ............................................................................. Section 42.1: hashCode() method 229 ............................................................................................................................ Section 42.2: toString() method 231 ............................................................................................................................... Section 42.3: equals() method 232 ................................................................................................................................. Section 42.4: wait() and notify() methods 234 .............................................................................................................. Section 42.5: getClass() method 236 .............................................................................................................................. Section 42.6: clone() method 237 ................................................................................................................................... Section 42.7: Object constructor 238 .............................................................................................................................. Section 42.8: finalize() method 239 ................................................................................................................................ Chapter 43: Annotations 241 ...................................................................................................................................... Section 43.1: The idea behind Annotations 241 ............................................................................................................. Section 43.2: Defining annotation types 241 ................................................................................................................. Section 43.3: Runtime annotation checks via reflection 243 ....................................................................................... Section 43.4: Built-in annotations 243 ............................................................................................................................ Section 43.5: Compile time processing using annotation processor 246 ................................................................... Section 43.6: Repeating Annotations 250 ...................................................................................................................... Section 43.7: Inherited Annotations 251 ......................................................................................................................... Section 43.8: Getting Annotation values at run-time 252 ............................................................................................. Section 43.9: Annotations for 'this' and receiver parameters 253 .............................................................................. Section 43.10: Add multiple annotation values 254 ....................................................................................................... Chapter 44: Immutable Class 255 ............................................................................................................................ Section 44.1: Example without mutable refs 255 ...........................................................................................................

📄 Page 8

Section 44.2: What is the advantage of immutability? 255 ......................................................................................... Section 44.3: Rules to define immutable classes 255 ................................................................................................... Section 44.4: Example with mutable refs 256 ................................................................................................................ Chapter 45: Immutable Objects 257 ....................................................................................................................... Section 45.1: Creating an immutable version of a type using defensive copying 257 .............................................. Section 45.2: The recipe for an immutable class 257 ................................................................................................... Section 45.3: Typical design flaws which prevent a class from being immutable 258 ............................................. Chapter 46: Visibility (controlling access to members of a class) 262 ................................................. Section 46.1: Private Visibility 262 ................................................................................................................................... Section 46.2: Public Visibility 262 .................................................................................................................................... Section 46.3: Package Visibility 263 ................................................................................................................................ Section 46.4: Protected Visibility 263 .............................................................................................................................. Section 46.5: Summary of Class Member Access Modifiers 264 ................................................................................. Section 46.6: Interface members 264 ............................................................................................................................. Chapter 47: Generics 265 .............................................................................................................................................. Section 47.1: Creating a Generic Class 265 .................................................................................................................... Section 47.2: Deciding between `T`, `? super T`, and `? extends T` 267 ........................................................................ Section 47.3: The Diamond 269 ....................................................................................................................................... Section 47.4: Declaring a Generic Method 269 .............................................................................................................. Section 47.5: Requiring multiple upper bounds ("extends A & B") 270 ....................................................................... Section 47.6: Obtain class that satisfies generic parameter at runtime 270 ............................................................. Section 47.7: Benefits of Generic class and interface 271 ........................................................................................... Section 47.8: Instantiating a generic type 272 .............................................................................................................. Section 47.9: Creating a Bounded Generic Class 272 ................................................................................................... Section 47.10: Referring to the declared generic type within its own declaration 274 ............................................. Section 47.11: Binding generic parameter to more than 1 type 275 ............................................................................ Section 47.12: Using Generics to auto-cast 276 ............................................................................................................. Section 47.13: Use of instanceof with Generics 276 ...................................................................................................... Section 47.14: Dierent ways for implementing a Generic Interface (or extending a Generic Class) 278 ............. Chapter 48: Classes and Objects 280 ..................................................................................................................... Section 48.1: Overloading Methods 280 ......................................................................................................................... Section 48.2: Explaining what is method overloading and overriding 281 ................................................................ Section 48.3: Constructors 283 ........................................................................................................................................ Section 48.4: Initializing static final fields using a static initializer 284 ........................................................................ Section 48.5: Basic Object Construction and Use 285 .................................................................................................. Section 48.6: Simplest Possible Class 287 ...................................................................................................................... Section 48.7: Object Member vs Static Member 287 .................................................................................................... Chapter 49: Local Inner Class 289 ............................................................................................................................ Section 49.1: Local Inner Class 289 ................................................................................................................................. Chapter 50: Nested and Inner Classes 290 .......................................................................................................... Section 50.1: A Simple Stack Using a Nested Class 290 ............................................................................................... Section 50.2: Static vs Non Static Nested Classes 290 ................................................................................................. Section 50.3: Access Modifiers for Inner Classes 292 ................................................................................................... Section 50.4: Anonymous Inner Classes 293 ................................................................................................................. Section 50.5: Create instance of non-static inner class from outside 294 ................................................................. Section 50.6: Method Local Inner Classes 295 .............................................................................................................. Section 50.7: Accessing the outer class from a non-static inner class 295 ................................................................ Chapter 51: The java.util.Objects Class 297 ......................................................................................................... Section 51.1: Basic use for object null check 297 ...........................................................................................................

📄 Page 9

Section 51.2: Objects.nonNull() method reference use in stream api 297 .................................................................. Chapter 52: Default Methods 298 ............................................................................................................................. Section 52.1: Basic usage of default methods 298 ........................................................................................................ Section 52.2: Accessing overridden default methods from implementing class 298 ............................................... Section 52.3: Why use Default Methods? 299 ............................................................................................................... Section 52.4: Accessing other interface methods within default method 299 ........................................................... Section 52.5: Default method multiple inheritance collision 300 ................................................................................. Section 52.6: Class, Abstract class and Interface method precedence 301 .............................................................. Chapter 53: Packages 303 ............................................................................................................................................ Section 53.1: Using Packages to create classes with the same name 303 ................................................................. Section 53.2: Using Package Protected Scope 303 ...................................................................................................... Chapter 54: Inheritance 305 ........................................................................................................................................ Section 54.1: Inheritance 305 ........................................................................................................................................... Section 54.2: Abstract Classes 306 ................................................................................................................................. Section 54.3: Using 'final' to restrict inheritance and overriding 308 .......................................................................... Section 54.4: The Liskov Substitution Principle 309 ...................................................................................................... Section 54.5: Abstract class and Interface usage: "Is-a" relation vs "Has-a" capability 310 ................................... Section 54.6: Static Inheritance 313 ................................................................................................................................ Section 54.7: Programming to an interface 314 ........................................................................................................... Section 54.8: Overriding in Inheritance 316 ................................................................................................................... Section 54.9: Variable shadowing 317 ........................................................................................................................... Section 54.10: Narrowing and Widening of object references 317 ............................................................................. Section 54.11: Inheritance and Static Methods 318 ........................................................................................................ Chapter 55: Reference Types 320 ............................................................................................................................ Section 55.1: Dierent Reference Types 320 ................................................................................................................. Chapter 56: Console I/O 322 ........................................................................................................................................ Section 56.1: Reading user input from the console 322 ................................................................................................ Section 56.2: Aligning strings in console 323 ................................................................................................................. Section 56.3: Implementing Basic Command-Line Behavior 324 ................................................................................ Chapter 57: Streams 326 ............................................................................................................................................... Section 57.1: Using Streams 326 ..................................................................................................................................... Section 57.2: Consuming Streams 328 ........................................................................................................................... Section 57.3: Creating a Frequency Map 330 ................................................................................................................ Section 57.4: Infinite Streams 330 ................................................................................................................................... Section 57.5: Collect Elements of a Stream into a Collection 331 ............................................................................... Section 57.6: Using Streams to Implement Mathematical Functions 334 .................................................................. Section 57.7: Flatten Streams with flatMap() 334 ......................................................................................................... Section 57.8: Parallel Stream 335 ................................................................................................................................... Section 57.9: Creating a Stream 336 .............................................................................................................................. Section 57.10: Finding Statistics about Numerical Streams 337 .................................................................................. Section 57.11: Converting an iterator to a stream 337 .................................................................................................. Section 57.12: Using IntStream to iterate over indexes 337 ......................................................................................... Section 57.13: Concatenate Streams 338 ....................................................................................................................... Section 57.14: Reduction with Streams 338 .................................................................................................................... Section 57.15: Using Streams of Map.Entry to Preserve Initial Values after Mapping 341 ....................................... Section 57.16: IntStream to String 341 ............................................................................................................................ Section 57.17: Finding the First Element that Matches a Predicate 341 ...................................................................... Section 57.18: Using Streams and Method References to Write Self-Documenting Processes 342 ........................ Section 57.19: Converting a Stream of Optional to a Stream of Values 343 .............................................................. Section 57.20: Get a Slice of a Stream 343 ....................................................................................................................

📄 Page 10

Section 57.21: Create a Map based on a Stream 343 ................................................................................................... Section 57.22: Joining a stream to a single String 344 ................................................................................................ Section 57.23: Sort Using Stream 345 ............................................................................................................................ Section 57.24: Streams of Primitives 346 ....................................................................................................................... Section 57.25: Stream operations categories 346 ........................................................................................................ Section 57.26: Collect Results of a Stream into an Array 347 ..................................................................................... Section 57.27: Generating random Strings using Streams 347 ................................................................................... Chapter 58: InputStreams and OutputStreams 349 ....................................................................................... Section 58.1: Closing Streams 349 .................................................................................................................................. Section 58.2: Reading InputStream into a String 349 ................................................................................................... Section 58.3: Wrapping Input/Output Streams 350 ..................................................................................................... Section 58.4: DataInputStream Example 351 ................................................................................................................ Section 58.5: Writing bytes to an OutputStream 351 ................................................................................................... Section 58.6: Copying Input Stream to Output Stream 351 ......................................................................................... Chapter 59: Readers and Writers 353 .................................................................................................................... Section 59.1: BueredReader 353 ................................................................................................................................... Section 59.2: StringWriter Example 354 ......................................................................................................................... Chapter 60: Preferences 355 ....................................................................................................................................... Section 60.1: Using preferences 355 ............................................................................................................................... Section 60.2: Adding event listeners 355 ....................................................................................................................... Section 60.3: Getting sub-nodes of Preferences 356 .................................................................................................... Section 60.4: Coordinating preferences access across multiple application instances 357 .................................... Section 60.5: Exporting preferences 357 ....................................................................................................................... Section 60.6: Importing preferences 358 ....................................................................................................................... Section 60.7: Removing event listeners 359 .................................................................................................................. Section 60.8: Getting preferences values 360 ............................................................................................................... Section 60.9: Setting preferences values 360 ................................................................................................................ Chapter 61: Collection Factory Methods 361 ....................................................................................................... Section 61.1: List<E> Factory Method Examples 361 ..................................................................................................... Section 61.2: Set<E> Factory Method Examples 361 ..................................................................................................... Section 61.3: Map<K, V> Factory Method Examples 361 .............................................................................................. Chapter 62: Alternative Collections 362 ................................................................................................................ Section 62.1: Multimap in Guava, Apache and Eclipse Collections 362 ....................................................................... Section 62.2: Apache HashBag, Guava HashMultiset and Eclipse HashBag 364 ...................................................... Section 62.3: Compare operation with collections - Create collections 366 .............................................................. Chapter 63: Concurrent Collections 371 ................................................................................................................ Section 63.1: Thread-safe Collections 371 ...................................................................................................................... Section 63.2: Insertion into ConcurrentHashMap 371 .................................................................................................. Section 63.3: Concurrent Collections 372 ....................................................................................................................... Chapter 64: Choosing Collections 374 .................................................................................................................... Section 64.1: Java Collections Flowchart 374 ................................................................................................................ Chapter 65: super keyword 375 ................................................................................................................................. Section 65.1: Super keyword use with examples 375 .................................................................................................... Chapter 66: Serialization 378 ...................................................................................................................................... Section 66.1: Basic Serialization in Java 378 .................................................................................................................. Section 66.2: Custom Serialization 379 .......................................................................................................................... Section 66.3: Versioning and serialVersionUID 382 ...................................................................................................... Section 66.4: Serialization with Gson 383 ....................................................................................................................... Section 66.5: Custom JSON Deserialization with Jackson 384 ....................................................................................

📄 Page 11

Chapter 67: Optional 387 ............................................................................................................................................... Section 67.1: Map 387 ....................................................................................................................................................... Section 67.2: Return default value if Optional is empty 388 ........................................................................................ Section 67.3: Throw an exception, if there is no value 388 ........................................................................................... Section 67.4: Lazily provide a default value using a Supplier 388 .............................................................................. Section 67.5: Filter 389 ..................................................................................................................................................... Section 67.6: Using Optional containers for primitive number types 389 .................................................................. Section 67.7: Run code only if there is a value present 390 ......................................................................................... Section 67.8: FlatMap 390 ................................................................................................................................................ Chapter 68: Object References 391 ......................................................................................................................... Section 68.1: Object References as method parameters 391 ...................................................................................... Chapter 69: Exceptions and exception handling 394 ...................................................................................... Section 69.1: Catching an exception with try-catch 394 ............................................................................................... Section 69.2: The try-with-resources statement 395 .................................................................................................... Section 69.3: Custom Exceptions 398 ............................................................................................................................. Section 69.4: Handling InterruptedException 400 ......................................................................................................... Section 69.5: Return statements in try catch block 401 ............................................................................................... Section 69.6: Introduction 402 ......................................................................................................................................... Section 69.7: The Java Exception Hierarchy - Unchecked and Checked Exceptions 403 ........................................ Section 69.8: Creating and reading stacktraces 406 .................................................................................................... Section 69.9: Throwing an exception 409 ...................................................................................................................... Section 69.10: Advanced features of Exceptions 411 ................................................................................................... Section 69.11: The try-finally and try-catch-finally statements 412 ............................................................................ Section 69.12: The 'throws' clause in a method declaration 414 ................................................................................. Chapter 70: Calendar and its Subclasses 416 .................................................................................................... Section 70.1: Creating Calendar objects 416 ................................................................................................................. Section 70.2: Increasing / Decreasing calendar fields 416 .......................................................................................... Section 70.3: Subtracting calendars 416 ........................................................................................................................ Section 70.4: Finding AM/PM 416 ................................................................................................................................... Chapter 71: Using the static keyword 418 ............................................................................................................ Section 71.1: Reference to non-static member from static context 418 ..................................................................... Section 71.2: Using static to declare constants 418 ...................................................................................................... Chapter 72: Properties Class 420 .............................................................................................................................. Section 72.1: Loading properties 420 .............................................................................................................................. Section 72.2: Saving Properties as XML 420 .................................................................................................................. Section 72.3: Property files caveat: trailing whitespace 421 ........................................................................................ Chapter 73: Lambda Expressions 424 ..................................................................................................................... Section 73.1: Introduction to Java lambdas 424 ........................................................................................................... Section 73.2: Using Lambda Expressions to Sort a Collection 427 ............................................................................. Section 73.3: Method References 428 ............................................................................................................................ Section 73.4: Implementing multiple interfaces 430 ..................................................................................................... Section 73.5: Lambda - Listener Example 430 .............................................................................................................. Section 73.6: Java Closures with lambda expressions 431 .......................................................................................... Section 73.7: Lambdas and memory utilization 432 ..................................................................................................... Section 73.8: Using lambda expression with your own functional interface 433 ...................................................... Section 73.9: Traditional style to Lambda style 433 ..................................................................................................... Section 73.10: `return` only returns from the lambda, not the outer method 434 ..................................................... Section 73.11: Lambdas and Execute-around Pattern 436 ........................................................................................... Section 73.12: Using lambda expressions & predicates to get a certain value(s) from a list 436 ...........................

📄 Page 12

Chapter 74: Basic Control Structures 438 ............................................................................................................ Section 74.1: Switch statement 438 ................................................................................................................................. Section 74.2: do...while Loop 439 ..................................................................................................................................... Section 74.3: For Each 440 ............................................................................................................................................... Section 74.4: Continue Statement in Java 441 .............................................................................................................. Section 74.5: If / Else If / Else Control 441 ..................................................................................................................... Section 74.6: For Loops 441 ............................................................................................................................................. Section 74.7: Ternary Operator 442 ............................................................................................................................... Section 74.8: Try ... Catch ... Finally 443 .......................................................................................................................... Section 74.9: Break 443 .................................................................................................................................................... Section 74.10: While Loops 444 ....................................................................................................................................... Section 74.11: If / Else 444 ................................................................................................................................................ Section 74.12: Nested break / continue 444 .................................................................................................................. Chapter 75: BueredWriter 446 ................................................................................................................................ Section 75.1: Write a line of text to File 446 .................................................................................................................... Chapter 76: New File I/O 447 ....................................................................................................................................... Section 76.1: Creating paths 447 ..................................................................................................................................... Section 76.2: Manipulating paths 447 ............................................................................................................................. Section 76.3: Retrieving information about a path 447 ................................................................................................ Section 76.4: Retrieving information using the filesystem 448 .................................................................................... Section 76.5: Reading files 449 ........................................................................................................................................ Section 76.6: Writing files 449 .......................................................................................................................................... Chapter 77: File I/O 450 ................................................................................................................................................. Section 77.1: Migrating from java.io.File to Java 7 NIO (java.nio.file.Path) 450 .......................................................... Section 77.2: Reading an image from a file 452 ........................................................................................................... Section 77.3: File Read/Write Using FileInputStream/FileOutputStream 452 ........................................................... Section 77.4: Reading all bytes to a byte[] 453 ............................................................................................................ Section 77.5: Copying a file using Channel 454 ............................................................................................................. Section 77.6: Writing a byte[] to a file 454 ..................................................................................................................... Section 77.7: Stream vs Writer/Reader API 455 ............................................................................................................ Section 77.8: Reading a file with a Scanner 456 ........................................................................................................... Section 77.9: Copying a file using InputStream and OutputStream 457 .................................................................... Section 77.10: Reading from a binary file 457 ............................................................................................................... Section 77.11: Reading a file using Channel and Buer 457 ......................................................................................... Section 77.12: Adding Directories 458 ............................................................................................................................. Section 77.13: Blocking or redirecting standard output / error 459 ............................................................................ Section 77.14: Reading a whole file at once 460 ............................................................................................................ Section 77.15: Locking 460 ............................................................................................................................................... Section 77.16: Reading a file using BueredInputStream 460 ..................................................................................... Section 77.17: Iterate over a directory printing subdirectories in it 461 ...................................................................... Section 77.18: Writing a file using Channel and Buer 461 .......................................................................................... Section 77.19: Writing a file using PrintStream 462 ....................................................................................................... Section 77.20: Iterating over a directory and filter by file extension 462 ................................................................... Section 77.21: Accessing the contents of a ZIP file 463 ................................................................................................ Chapter 78: Scanner 464 ............................................................................................................................................... Section 78.1: General Pattern that does most commonly asked about tasks 464 .................................................... Section 78.2: Using custom delimiters 466 .................................................................................................................... Section 78.3: Reading system input using Scanner 466 ............................................................................................... Section 78.4: Reading file input using Scanner 466 ...................................................................................................... Section 78.5: Read the entire input as a String using Scanner 467 .............................................................................

📄 Page 13

Section 78.6: Carefully Closing a Scanner 467 .............................................................................................................. Section 78.7: Read an int from the command line 468 ................................................................................................ Chapter 79: Interfaces 469 ........................................................................................................................................... Section 79.1: Implementing multiple interfaces 469 ...................................................................................................... Section 79.2: Declaring and Implementing an Interface 470 ....................................................................................... Section 79.3: Extending an interface 470 ....................................................................................................................... Section 79.4: Usefulness of interfaces 471 .................................................................................................................... Section 79.5: Default methods 473 ................................................................................................................................. Section 79.6: Modifiers in Interfaces 475 ........................................................................................................................ Section 79.7: Using Interfaces with Generics 475 .......................................................................................................... Section 79.8: Strengthen bounded type parameters 478 ............................................................................................ Section 79.9: Implementing interfaces in an abstract class 478 ................................................................................. Chapter 80: Regular Expressions 480 ..................................................................................................................... Section 80.1: Using capture groups 480 ......................................................................................................................... Section 80.2: Using regex with custom behaviour by compiling the Pattern with flags 481 ................................... Section 80.3: Escape Characters 481 ............................................................................................................................. Section 80.4: Not matching a given string 482 ............................................................................................................. Section 80.5: Matching with a regex literal 482 ............................................................................................................. Section 80.6: Matching a backslash 482 ........................................................................................................................ Chapter 81: Comparable and Comparator 484 .................................................................................................. Section 81.1: Sorting a List using Comparable<T> or a Comparator<T> 484 ............................................................. Section 81.2: The compareTo and compare Methods 487 .......................................................................................... Section 81.3: Natural (comparable) vs explicit (comparator) sorting 488 ................................................................. Section 81.4: Creating a Comparator using comparing method 489 ......................................................................... Section 81.5: Sorting Map entries 489 ............................................................................................................................. Chapter 82: Java Floating Point Operations 491 .............................................................................................. Section 82.1: Comparing floating point values 491 ....................................................................................................... Section 82.2: OverFlow and UnderFlow 493 .................................................................................................................. Section 82.3: Formatting the floating point values 494 ................................................................................................ Section 82.4: Strict Adherence to the IEEE Specification 494 ....................................................................................... Chapter 83: Currency and Money 496 .................................................................................................................... Section 83.1: Add custom currency 496 ......................................................................................................................... Chapter 84: Object Cloning 497 ................................................................................................................................. Section 84.1: Cloning performing a deep copy 497 ...................................................................................................... Section 84.2: Cloning using a copy factory 498 ............................................................................................................ Section 84.3: Cloning using a copy constructor 498 ..................................................................................................... Section 84.4: Cloning by implementing Clonable interface 498 .................................................................................. Section 84.5: Cloning performing a shallow copy 499 ................................................................................................. Chapter 85: Recursion 501 ............................................................................................................................................ Section 85.1: The basic idea of recursion 501 ................................................................................................................ Section 85.2: Deep recursion is problematic in Java 501 ............................................................................................ Section 85.3: Types of Recursion 503 ............................................................................................................................. Section 85.4: Computing the Nth Fibonacci Number 503 ............................................................................................ Section 85.5: StackOverflowError & recursion to loop 504 .......................................................................................... Section 85.6: Computing the Nth power of a number 506 ........................................................................................... Section 85.7: Traversing a Tree data structure with recursion 506 ............................................................................ Section 85.8: Reverse a string using Recursion 507 ..................................................................................................... Section 85.9: Computing the sum of integers from 1 to N 507 .................................................................................... Chapter 86: Converting to and from Strings 508 .............................................................................................

📄 Page 14

Section 86.1: Converting String to other datatypes 508 ............................................................................................... Section 86.2: Conversion to / from bytes 509 ............................................................................................................... Section 86.3: Base64 Encoding / Decoding 509 ............................................................................................................ Section 86.4: Converting other datatypes to String 510 .............................................................................................. Section 86.5: Getting a `String` from an `InputStream` 511 .......................................................................................... Chapter 87: Random Number Generation 512 .................................................................................................. Section 87.1: Pseudo Random Numbers 512 ................................................................................................................. Section 87.2: Pseudo Random Numbers in Specific Range 512 ................................................................................. Section 87.3: Generating cryptographically secure pseudorandom numbers 513 ................................................... Section 87.4: Generating Random Numbers with a Specified Seed 513 .................................................................... Section 87.5: Select random numbers without duplicates 514 .................................................................................... Section 87.6: Generating Random number using apache-common lang3 515 ........................................................ Chapter 88: Singletons 516 .......................................................................................................................................... Section 88.1: Enum Singleton 516 ................................................................................................................................... Section 88.2: Singleton without use of Enum (eager initialization) 516 ...................................................................... Section 88.3: Thread-safe lazy initialization using holder class | Bill Pugh Singleton implementation 517 ............ Section 88.4: Thread safe Singleton with double checked locking 517 ...................................................................... Section 88.5: Extending singleton (singleton inheritance) 518 .................................................................................... Chapter 89: Autoboxing 521 ......................................................................................................................................... Section 89.1: Using int and Integer interchangeably 521 ............................................................................................. Section 89.2: Auto-unboxing may lead to NullPointerException 522 .......................................................................... Section 89.3: Using Boolean in if statement 522 ........................................................................................................... Section 89.4: Dierent Cases When Integer and int can be used interchangeably 522 .......................................... Section 89.5: Memory and Computational Overhead of Autoboxing 524 ................................................................. Chapter 90: 2D Graphics in Java 525 ...................................................................................................................... Section 90.1: Example 1: Draw and Fill a Rectangle Using Java 525 .......................................................................... Section 90.2: Example 2: Drawing and Filling Oval 527 ............................................................................................... Chapter 91: JAXB 528 ....................................................................................................................................................... Section 91.1: Reading an XML file (unmarshalling) 528 ................................................................................................ Section 91.2: Writing an XML file (marshalling an object) 528 ..................................................................................... Section 91.3: Manual field/property XML mapping configuration 529 ....................................................................... Section 91.4: Binding an XML namespace to a serializable Java class 530 ............................................................... Section 91.5: Using XmlAdapter to generate desired xml format 530 ........................................................................ Section 91.6: Using XmlAdapter to trim string 532 ........................................................................................................ Section 91.7: Automatic field/property XML mapping configuration (@XmlAccessorType) 532 ............................ Section 91.8: Specifying a XmlAdapter instance to (re)use existing data 534 ........................................................... Chapter 92: Class - Java Reflection 537 ................................................................................................................ Section 92.1: getClass() method of Object class 537 .................................................................................................... Chapter 93: Networking 538 ........................................................................................................................................ Section 93.1: Basic Client and Server Communication using a Socket 538 ................................................................ Section 93.2: Basic Client/Server Communication using UDP (Datagram) 540 ........................................................ Section 93.3: Loading TrustStore and KeyStore from InputStream 541 .................................................................... Section 93.4: Socket example - reading a web page using a simple socket 542 ...................................................... Section 93.5: Temporarily disable SSL verification (for testing purposes) 543 ......................................................... Section 93.6: Downloading a file using Channel 543 .................................................................................................... Section 93.7: Multicasting 544 ......................................................................................................................................... Chapter 94: NIO - Networking 547 ........................................................................................................................... Section 94.1: Using Selector to wait for events (example with OP_CONNECT) 547 ................................................. Chapter 95: HttpURLConnection 549 ......................................................................................................................

📄 Page 15

Section 95.1: Get response body from a URL as a String 549 ..................................................................................... Section 95.2: POST data 550 ........................................................................................................................................... Section 95.3: Delete resource 550 ................................................................................................................................... Section 95.4: Check if resource exists 551 ..................................................................................................................... Chapter 96: JAX-WS 553 ................................................................................................................................................ Section 96.1: Basic Authentication 553 ........................................................................................................................... Chapter 97: Nashorn JavaScript engine 554 ...................................................................................................... Section 97.1: Execute JavaScript file 554 ........................................................................................................................ Section 97.2: Intercept script output 554 ....................................................................................................................... Section 97.3: Hello Nashorn 555 ..................................................................................................................................... Section 97.4: Evaluate Arithmetic Strings 555 ............................................................................................................... Section 97.5: Set global variables 555 ............................................................................................................................ Section 97.6: Set and get global variables 556 ............................................................................................................. Section 97.7: Usage of Java objects in JavaScript in Nashorn 556 ............................................................................ Section 97.8: Implementing an interface from script 557 ............................................................................................ Chapter 98: Java Native Interface 558 .................................................................................................................. Section 98.1: Calling C++ methods from Java 558 ........................................................................................................ Section 98.2: Calling Java methods from C++ (callback) 559 ..................................................................................... Section 98.3: Loading native libraries 561 ..................................................................................................................... Chapter 99: Functional Interfaces 563 ................................................................................................................... Section 99.1: List of standard Java Runtime Library functional interfaces by signature 563 .................................. Chapter 100: Fluent Interface 565 ............................................................................................................................ Section 100.1: Fluent programming style 565 ................................................................................................................ Section 100.2: Truth - Fluent Testing Framework 566 .................................................................................................. Chapter 101: Remote Method Invocation (RMI) 567 ......................................................................................... Section 101.1: Callback: invoking methods on a "client" 567 ......................................................................................... Section 101.2: Simple RMI example with Client and Server implementation 571 ....................................................... Section 101.3: Client-Server: invoking methods in one JVM from another 573 .......................................................... Chapter 102: Iterator and Iterable 576 .................................................................................................................. Section 102.1: Removing elements using an iterator 576 ............................................................................................. Section 102.2: Creating your own Iterable 576 .............................................................................................................. Section 102.3: Using Iterable in for loop 577 .................................................................................................................. Section 102.4: Using the raw iterator 578 ...................................................................................................................... Chapter 103: Reflection API 579 ................................................................................................................................. Section 103.1: Dynamic Proxies 579 ................................................................................................................................ Section 103.2: Introduction 580 ....................................................................................................................................... Section 103.3: Evil Java hacks with Reflection 581 ....................................................................................................... Section 103.4: Misuse of Reflection API to change private and final variables 583 ................................................... Section 103.5: Getting and Setting fields 584 ................................................................................................................. Section 103.6: Call constructor 585 ................................................................................................................................. Section 103.7: Call constructor of nested class 586 ...................................................................................................... Section 103.8: Invoking a method 586 ............................................................................................................................ Section 103.9: Get Class given its (fully qualified) name 587 ....................................................................................... Section 103.10: Getting the Constants of an Enumeration 587 .................................................................................... Section 103.11: Call overloaded constructors using reflection 588 ............................................................................... Chapter 104: ByteBuer 590 ....................................................................................................................................... Section 104.1: Basic Usage - Using DirectByteBuer 590 ............................................................................................ Section 104.2: Basic Usage - Creating a ByteBuer 590 ............................................................................................. Section 104.3: Basic Usage - Write Data to the Buer 591 ..........................................................................................

📄 Page 16

Chapter 105: Applets 592 ............................................................................................................................................... Section 105.1: Minimal Applet 592 ................................................................................................................................... Section 105.2: Creating a GUI 593 ................................................................................................................................... Section 105.3: Open links from within the applet 593 ................................................................................................... Section 105.4: Loading images, audio and other resources 594 ................................................................................. Chapter 106: Expressions 596 ...................................................................................................................................... Section 106.1: Operator Precedence 596 ........................................................................................................................ Section 106.2: Expression Basics 597 .............................................................................................................................. Section 106.3: Expression evaluation order 598 ............................................................................................................ Section 106.4: Constant Expressions 599 ....................................................................................................................... Chapter 107: JSON in Java 601 .................................................................................................................................. Section 107.1: Using Jackson Object Mapper 601 ......................................................................................................... Section 107.2: JSON To Object (Gson Library) 602 ....................................................................................................... Section 107.3: JSONObject.NULL 602 ............................................................................................................................. Section 107.4: JSON Builder - chaining methods 603 ................................................................................................... Section 107.5: Object To JSON (Gson Library) 603 ....................................................................................................... Section 107.6: JSON Iteration 603 ................................................................................................................................... Section 107.7: optXXX vs getXXX methods 604 ............................................................................................................. Section 107.8: Extract single element from JSON 604 .................................................................................................. Section 107.9: JsonArray to Java List (Gson Library) 604 ........................................................................................... Section 107.10: Encoding data as JSON 605 .................................................................................................................. Section 107.11: Decoding JSON data 605 ....................................................................................................................... Chapter 108: XML Parsing using the JAXP APIs 607 ......................................................................................... Section 108.1: Parsing a document using the StAX API 607 .......................................................................................... Section 108.2: Parsing and navigating a document using the DOM API 608 ............................................................. Chapter 109: XML XPath Evaluation 610 ................................................................................................................ Section 109.1: Parsing multiple XPath Expressions in a single XML 610 ...................................................................... Section 109.2: Parsing single XPath Expression multiple times in an XML 610 .......................................................... Section 109.3: Evaluating a NodeList in an XML document 611 .................................................................................. Chapter 110: XOM - XML Object Model 612 ........................................................................................................... Section 110.1: Reading a XML file 612 .............................................................................................................................. Section 110.2: Writing to a XML File 614 ......................................................................................................................... Chapter 111: Polymorphism 617 .................................................................................................................................. Section 111.1: Method Overriding 617 ............................................................................................................................... Section 111.2: Method Overloading 618 ........................................................................................................................... Section 111.3: Polymorphism and dierent types of overriding 619 ............................................................................ Section 111.4: Virtual functions 622 .................................................................................................................................. Section 111.5: Adding behaviour by adding classes without touching existing code 623 .......................................... Chapter 112: Encapsulation 625 .................................................................................................................................. Section 112.1: Encapsulation to maintain invariants 625 ............................................................................................... Section 112.2: Encapsulation to reduce coupling 626 .................................................................................................... Chapter 113: Java Agents 627 ...................................................................................................................................... Section 113.1: Modifying classes with agents 627 ........................................................................................................... Section 113.2: Adding an agent at runtime 627 ............................................................................................................. Section 113.3: Setting up a basic agent 628 .................................................................................................................... Chapter 114: Varargs (Variable Argument) 629 ................................................................................................ Section 114.1: Working with Varargs parameters 629 ................................................................................................... Section 114.2: Specifying a varargs parameter 629 ...................................................................................................... Chapter 115: Logging (java.util.logging) 630 .......................................................................................................

📄 Page 17

Section 115.1: Logging complex messages (eciently) 630 ......................................................................................... Section 115.2: Using the default logger 631 ................................................................................................................... Section 115.3: Logging levels 632 .................................................................................................................................... Chapter 116: log4j / log4j2 634 .................................................................................................................................. Section 116.1: Properties-File to log to DB 634 ............................................................................................................... Section 116.2: How to get Log4j 634 ................................................................................................................................ Section 116.3: Setting up property file 635 ...................................................................................................................... Section 116.4: Basic log4j2.xml configuration file 636 ................................................................................................... Section 116.5: How to use Log4j in Java code 636 ........................................................................................................ Section 116.6: Migrating from log4j 1.x to 2.x 637 ........................................................................................................... Section 116.7: Filter Logoutput by level (log4j 1.x) 638 ................................................................................................... Chapter 117: Oracle Ocial Code Standard 639 ............................................................................................... Section 117.1: Naming Conventions 639 .......................................................................................................................... Section 117.2: Class Structure 640 ................................................................................................................................... Section 117.3: Annotations 641 ......................................................................................................................................... Section 117.4: Import statements 641 ............................................................................................................................. Section 117.5: Braces 642 ................................................................................................................................................. Section 117.6: Redundant Parentheses 643 .................................................................................................................... Section 117.7: Modifiers 643 .............................................................................................................................................. Section 117.8: Indentation 644 .......................................................................................................................................... Section 117.9: Literals 644 ................................................................................................................................................. Section 117.10: Package declaration 644 ........................................................................................................................ Section 117.11: Lambda Expressions 644 ......................................................................................................................... Section 117.12: Java Source Files 645 .............................................................................................................................. Section 117.13: Wrapping statements 645 ....................................................................................................................... Section 117.14: Wrapping Method Declarations 646 ...................................................................................................... Section 117.15: Wrapping Expressions 646 ...................................................................................................................... Section 117.16: Whitespace 647 ........................................................................................................................................ Section 117.17: Special Characters 647 ............................................................................................................................ Section 117.18: Variable Declarations 648 ....................................................................................................................... Chapter 118: Character encoding 649 ..................................................................................................................... Section 118.1: Reading text from a file encoded in UTF-8 649 ..................................................................................... Section 118.2: Writing text to a file in UTF-8 649 ............................................................................................................ Section 118.3: Getting byte representation of a string in UTF-8 650 ........................................................................... Chapter 119: Apache Commons Lang 651 ............................................................................................................. Section 119.1: Implement equals() method 651 .............................................................................................................. Section 119.2: Implement hashCode() method 651 ....................................................................................................... Section 119.3: Implement toString() method 652 ........................................................................................................... Chapter 120: Localization and Internationalization 654 ................................................................................ Section 120.1: Locale 654 .................................................................................................................................................. Section 120.2: Automatically formatted Dates using "locale" 655 .............................................................................. Section 120.3: String Comparison 655 ............................................................................................................................ Chapter 121: Parallel programming with Fork/Join framework 656 ...................................................... Section 121.1: Fork/Join Tasks in Java 656 .................................................................................................................... Chapter 122: Non-Access Modifiers 658 ................................................................................................................. Section 122.1: final 658 ...................................................................................................................................................... Section 122.2: static 659 ................................................................................................................................................... Section 122.3: abstract 660 .............................................................................................................................................. Section 122.4: strictfp 661 ................................................................................................................................................

📄 Page 18

Section 122.5: volatile 661 ................................................................................................................................................ Section 122.6: synchronized 662 ..................................................................................................................................... Section 122.7: transient 663 ............................................................................................................................................. Chapter 123: Process 664 ............................................................................................................................................... Section 123.1: Pitfall: Runtime.exec, Process and ProcessBuilder don't understand shell syntax 664 ...................... Section 123.2: Simple example (Java version < 1.5) 666 ............................................................................................... Chapter 124: Java Native Access 667 ..................................................................................................................... Section 124.1: Introduction to JNA 667 ........................................................................................................................... Chapter 125: Modules 668 .............................................................................................................................................. Section 125.1: Defining a basic module 668 ................................................................................................................... Chapter 126: Concurrent Programming (Threads) 669 .................................................................................. Section 126.1: Callable and Future 669 ........................................................................................................................... Section 126.2: CountDownLatch 670 ............................................................................................................................... Section 126.3: Basic Multithreading 672 ......................................................................................................................... Section 126.4: Locks as Synchronisation aids 673 ......................................................................................................... Section 126.5: Semaphore 674 ........................................................................................................................................ Section 126.6: Synchronization 675 ................................................................................................................................. Section 126.7: Runnable Object 676 ................................................................................................................................ Section 126.8: Creating basic deadlocked system 677 ................................................................................................. Section 126.9: Creating a java.lang.Thread instance 679 ............................................................................................. Section 126.10: Atomic operations 680 ........................................................................................................................... Section 126.11: Exclusive write / Concurrent read access 681 ...................................................................................... Section 126.12: Producer-Consumer 682 ........................................................................................................................ Section 126.13: Visualizing read/write barriers while using synchronized / volatile 684 ........................................... Section 126.14: Get status of all threads started by your program excluding system threads 685 ........................ Section 126.15: Using ThreadLocal 686 ........................................................................................................................... Section 126.16: Multiple producer/consumer example with shared global queue 687 ............................................. Section 126.17: Add two `int` arrays using a Threadpool 688 ....................................................................................... Section 126.18: Pausing Execution 689 ............................................................................................................................ Section 126.19: Thread Interruption / Stopping Threads 690 ....................................................................................... Chapter 127: Executor, ExecutorService and Thread pools 693 ................................................................ Section 127.1: ThreadPoolExecutor 693 .......................................................................................................................... Section 127.2: Retrieving value from computation - Callable 694 ............................................................................... Section 127.3: submit() vs execute() exception handling dierences 695 .................................................................. Section 127.4: Handle Rejected Execution 697 .............................................................................................................. Section 127.5: Fire and Forget - Runnable Tasks 697 ................................................................................................... Section 127.6: Use cases for dierent types of concurrency constructs 698 ............................................................. Section 127.7: Wait for completion of all tasks in ExecutorService 699 ...................................................................... Section 127.8: Use cases for dierent types of ExecutorService 701 .......................................................................... Section 127.9: Scheduling tasks to run at a fixed time, after a delay or repeatedly 703 .......................................... Section 127.10: Using Thread Pools 704 ......................................................................................................................... Chapter 128: ThreadLocal 705 .................................................................................................................................... Section 128.1: Basic ThreadLocal usage 705 .................................................................................................................. Section 128.2: ThreadLocal Java 8 functional initialization 706 .................................................................................. Section 128.3: Multiple threads with one shared object 707 ........................................................................................ Chapter 129: Using ThreadPoolExecutor in MultiThreaded applications. 709 .................................... Section 129.1: Performing Asynchronous Tasks Where No Return Value Is Needed Using a Runnable Class Instance 709 .............................................................................................................................................................. Section 129.2: Performing Asynchronous Tasks Where a Return Value Is Needed Using a Callable Class Instance 710 ..............................................................................................................................................................

📄 Page 19

Section 129.3: Defining Asynchronous Tasks Inline using Lambdas 713 .................................................................... Chapter 130: Common Java Pitfalls 715 ................................................................................................................ Section 130.1: Pitfall: using == to compare primitive wrappers objects such as Integer 715 ..................................... Section 130.2: Pitfall: using == to compare strings 715 ................................................................................................. Section 130.3: Pitfall: forgetting to free resources 717 ................................................................................................. Section 130.4: Pitfall: testing a file before attempting to open it 718 .......................................................................... Section 130.5: Pitfall: thinking of variables as objects 719 ........................................................................................... Section 130.6: Pitfall: memory leaks 722 ........................................................................................................................ Section 130.7: Pitfall: Not understanding that String is an immutable class 723 ....................................................... Section 130.8: Pitfall: combining assignment and side-eects 724 ............................................................................. Chapter 131: Java Pitfalls - Exception usage 725 .............................................................................................. Section 131.1: Pitfall - Catching Throwable, Exception, Error or RuntimeException 725 ............................................ Section 131.2: Pitfall - Ignoring or squashing exceptions 726 ....................................................................................... Section 131.3: Pitfall - Throwing Throwable, Exception, Error or RuntimeException 727 ........................................... Section 131.4: Pitfall - Using exceptions for normal flowcontrol 728 ........................................................................... Section 131.5: Pitfall - Directly subclassing `Throwable` 729 ......................................................................................... Section 131.6: Pitfall - Catching InterruptedException 729 ............................................................................................ Section 131.7: Pitfall - Excessive or inappropriate stacktraces 731 .............................................................................. Chapter 132: Java Pitfalls - Language syntax 732 ........................................................................................... Section 132.1: Pitfall - Missing a ‘break’ in a 'switch' case 732 ...................................................................................... Section 132.2: Pitfall - Declaring classes with the same names as standard classes 732 ........................................ Section 132.3: Pitfall - Leaving out braces: the "dangling if" and "dangling else" problems 733 ............................. Section 132.4: Pitfall - Octal literals 735 .......................................................................................................................... Section 132.5: Pitfall - Using '==' to test a boolean 735 ................................................................................................. Section 132.6: Pitfall - Ignoring method visibility 736 .................................................................................................... Section 132.7: Pitfall: Using 'assert' for argument or user input validation 736 ......................................................... Section 132.8: Pitfall - Wildcard imports can make your code fragile 737 ................................................................. Section 132.9: Pitfall - Misplaced semicolons and missing braces 738 ....................................................................... Section 132.10: Pitfall - Overloading instead of overriding 739 .................................................................................... Section 132.11: Pitfall of Auto-Unboxing Null Objects into Primitives 740 .................................................................... Chapter 133: Java Pitfalls - Threads and Concurrency 741 ......................................................................... Section 133.1: Pitfall - Extending 'java.lang.Thread' 741 ................................................................................................ Section 133.2: Pitfall - Too many threads makes an application slower 742 ............................................................. Section 133.3: Pitfall: incorrect use of wait() / notify() 743 ........................................................................................... Section 133.4: Pitfall: Shared variables require proper synchronization 743 .............................................................. Section 133.5: Pitfall - Thread creation is relatively expensive 746 ............................................................................. Chapter 134: Java Pitfalls - Nulls and NullPointerException 749 ............................................................. Section 134.1: Pitfall - "Making good" unexpected nulls 749 ......................................................................................... Section 134.2: Pitfall - Using null to represent an empty array or collection 750 ...................................................... Section 134.3: Pitfall - Not checking if an I/O stream isn't even initialized when closing it 751 ............................... Section 134.4: Pitfall - Returning null instead of throwing an exception 751 .............................................................. Section 134.5: Pitfall - Unnecessary use of Primitive Wrappers can lead to NullPointerExceptions 752 ................ Section 134.6: Pitfall - Using "Yoda notation" to avoid NullPointerException 753 ...................................................... Chapter 135: Java Pitfalls - Performance Issues 754 ...................................................................................... Section 135.1: Pitfall - String concatenation in a loop does not scale 754 .................................................................. Section 135.2: Pitfall - Using size() to test if a collection is empty is inecient 755 .................................................. Section 135.3: Pitfall - Interning strings so that you can use == is a bad idea 755 ..................................................... Section 135.4: Pitfall - Using 'new' to create primitive wrapper instances is inecient 757 ..................................... Section 135.5: Pitfall - Eciency concerns with regular expressions 757 ................................................................... Section 135.6: Pitfall - Small reads / writes on unbuered streams are inecient 760 ...........................................

📄 Page 20

Section 135.7: Pitfall - Over-use of primitive wrapper types is inecient 762 ............................................................ Section 135.8: Pitfall - The overheads of creating log messages 763 ......................................................................... Section 135.9: Pitfall - Iterating a Map's keys can be inecient 764 ........................................................................... Section 135.10: Pitfall - Calling System.gc() is inecient 764 ....................................................................................... Section 135.11: Pitfall - Calling 'new String(String)' is inecient 765 ............................................................................ Chapter 136: ServiceLoader 766 ................................................................................................................................ Section 136.1: Simple ServiceLoader Example 766 ........................................................................................................ Section 136.2: Logger Service 767 ................................................................................................................................... Chapter 137: Classloaders 769 .................................................................................................................................... Section 137.1: Implementing a custom classLoader 769 ............................................................................................... Section 137.2: Loading an external .class file 769 .......................................................................................................... Section 137.3: Instantiating and using a classloader 770 ............................................................................................. Chapter 138: Creating Images Programmatically 772 ................................................................................... Section 138.1: Creating a simple image programmatically and displaying it 772 ..................................................... Section 138.2: Save an Image to disk 773 ...................................................................................................................... Section 138.3: Setting individual pixel's color in BueredImage 773 ........................................................................... Section 138.4: Specifying image rendering quality 774 ................................................................................................ Section 138.5: Creating an image with BueredImage class 776 ............................................................................... Section 138.6: Editing and re-using image with BueredImage 777 ........................................................................... Section 138.7: How to scale a BueredImage 778 ........................................................................................................ Chapter 139: Atomic Types 779 .................................................................................................................................. Section 139.1: Creating Atomic Types 779 ...................................................................................................................... Section 139.2: Motivation for Atomic Types 779 ............................................................................................................ Chapter 140: RSA Encryption 783 ............................................................................................................................. Section 140.1: An example using a hybrid cryptosystem consisting of OAEP and GCM 783 .................................... Chapter 141: Secure objects 788 ................................................................................................................................ Section 141.1: SealedObject (javax.crypto.SealedObject) 788 ...................................................................................... Section 141.2: SignedObject (java.security.SignedObject) 788 ..................................................................................... Chapter 142: Security & Cryptography 790 ......................................................................................................... Section 142.1: Compute Cryptographic Hashes 790 ...................................................................................................... Section 142.2: Encrypt and Decrypt Data with Public / Private Keys 790 .................................................................. Section 142.3: Generate Cryptographically Random Data 791 ................................................................................... Section 142.4: Generate Public / Private Key Pairs 791 ................................................................................................ Section 142.5: Compute and Verify Digital Signatures 792 .......................................................................................... Chapter 143: Security & Cryptography 793 ......................................................................................................... Section 143.1: The JCE 793 ............................................................................................................................................... Section 143.2: Keys and Key Management 793 ............................................................................................................ Section 143.3: Common Java vulnerabilities 793 .......................................................................................................... Section 143.4: Networking Concerns 793 ....................................................................................................................... Section 143.5: Randomness and You 793 ....................................................................................................................... Section 143.6: Hashing and Validation 793 .................................................................................................................... Chapter 144: SecurityManager 795 ......................................................................................................................... Section 144.1: Sandboxing classes loaded by a ClassLoader 795 ............................................................................... Section 144.2: Enabling the SecurityManager 796 ........................................................................................................ Section 144.3: Implementing policy deny rules 796 ...................................................................................................... Chapter 145: JNDI 804 .................................................................................................................................................... Section 145.1: RMI through JNDI 804 .............................................................................................................................. Chapter 146: sun.misc.Unsafe 808 ............................................................................................................................ Section 146.1: Instantiating sun.misc.Unsafe via reflection 808 ....................................................................................