Java

Java
Notes for Professionals
®

Notes for Professionals

900+ pages
of professional hints and tricks

Disclaimer
GoalKicker.com 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).
Free Programming Books All trademarks and registered trademarks are
the property of their respective owners
Contents
About ................................................................................................................................................................................... 1
Chapter 1: Getting started with Java Language .......................................................................................... 2
Section 1.1: Creating Your First Java Program ........................................................................................................... 2
Chapter 2: Type Conversion .................................................................................................................................... 7
Section 2.1: Numeric primitive casting ......................................................................................................................... 7
Section 2.2: Basic Numeric Promotion ........................................................................................................................ 7
Section 2.3: Non-numeric primitive casting ................................................................................................................ 7
Section 2.4: Object casting ........................................................................................................................................... 8
Section 2.5: Testing if an object can be cast using instanceof ................................................................................. 8
Chapter 3: Getters and Setters ............................................................................................................................. 9
Section 3.1: Using a setter or getter to implement a constraint ............................................................................... 9
Section 3.2: Why Use Getters and Setters? ................................................................................................................ 9
Section 3.3: Adding Getters and Setters ................................................................................................................... 10
Chapter 4: Reference Data Types .................................................................................................................... 12
Section 4.1: Dereferencing .......................................................................................................................................... 12
Section 4.2: Instantiating a reference type ............................................................................................................... 12
Chapter 5: Java Compiler - 'javac' .................................................................................................................... 13
Section 5.1: The 'javac' command - getting started ................................................................................................ 13
Section 5.2: Compiling for a dierent version of Java ............................................................................................ 15
Chapter 6: Documenting Java Code ................................................................................................................. 17
Section 6.1: Building Javadocs From the Command Line ....................................................................................... 17
Section 6.2: Class Documentation ............................................................................................................................. 17
Section 6.3: Method Documentation ......................................................................................................................... 18
Section 6.4: Package Documentation ....................................................................................................................... 19
Section 6.5: Links ......................................................................................................................................................... 19
Section 6.6: Code snippets inside documentation ................................................................................................... 20
Section 6.7: Field Documentation .............................................................................................................................. 21
Section 6.8: Inline Code Documentation ................................................................................................................... 21
Chapter 7: Command line Argument Processing ....................................................................................... 23
Section 7.1: Argument processing using GWT ToolBase ......................................................................................... 23
Section 7.2: Processing arguments by hand ............................................................................................................ 23
Chapter 8: The Java Command - 'java' and 'javaw' ................................................................................. 26
Section 8.1: Entry point classes .................................................................................................................................. 26
Section 8.2: Troubleshooting the 'java' command .................................................................................................. 26
Section 8.3: Running a Java application with library dependencies ..................................................................... 28
Section 8.4: Java Options ........................................................................................................................................... 29
Section 8.5: Spaces and other special characters in arguments ........................................................................... 30
Section 8.6: Running an executable JAR file ............................................................................................................ 32
Section 8.7: Running a Java applications via a "main" class ................................................................................. 32
Chapter 9: Date Class ............................................................................................................................................... 34
Section 9.1: Convert java.util.Date to java.sql.Date .................................................................................................. 34
Section 9.2: A basic date output ................................................................................................................................ 34
Section 9.3: Java 8 LocalDate and LocalDateTime objects ................................................................................... 35
Section 9.4: Creating a Specific Date ........................................................................................................................ 36
Section 9.5: Converting Date to a certain String format ......................................................................................... 36
Section 9.6: LocalTime ................................................................................................................................................ 37
 Section 9.7: Convert formatted string representation of date to Date object ..................................................... 37
Section 9.8: Creating Date objects ............................................................................................................................ 38
Section 9.9: Comparing Date objects ........................................................................................................................ 38
Section 9.10: Converting String into Date ................................................................................................................. 41
Section 9.11: Time Zones and java.util.Date .............................................................................................................. 41
Chapter 10: Dates and Time (java.time.*) ...................................................................................................... 43
Section 10.1: Calculate Dierence between 2 LocalDates ....................................................................................... 43
Section 10.2: Date and time ........................................................................................................................................ 43
Section 10.3: Operations on dates and times ........................................................................................................... 43
Section 10.4: Instant ..................................................................................................................................................... 43
Section 10.5: Usage of various classes of Date Time API ....................................................................................... 44
Section 10.6: Date Time Formatting .......................................................................................................................... 46
Section 10.7: Simple Date Manipulations ................................................................................................................... 46
Chapter 11: LocalTime ............................................................................................................................................... 48
Section 11.1: Amount of time between two LocalTime ............................................................................................. 48
Section 11.2: Intro ......................................................................................................................................................... 49
Section 11.3: Time Modification ................................................................................................................................... 49
Section 11.4: Time Zones and their time dierence ................................................................................................. 49
Chapter 12: Literals .................................................................................................................................................... 51
Section 12.1: Using underscore to improve readability ............................................................................................ 51
Section 12.2: Hexadecimal, Octal and Binary literals ............................................................................................... 51
Section 12.3: Boolean literals ...................................................................................................................................... 52
Section 12.4: String literals .......................................................................................................................................... 52
Section 12.5: The Null literal ........................................................................................................................................ 53
Section 12.6: Escape sequences in literals ................................................................................................................ 53
Section 12.7: Character literals ................................................................................................................................... 54
Section 12.8: Decimal Integer literals ......................................................................................................................... 54
Section 12.9: Floating-point literals ............................................................................................................................ 55
Chapter 13: Operators .............................................................................................................................................. 58
Section 13.1: The Increment/Decrement Operators (++/--) .................................................................................... 58
Section 13.2: The Conditional Operator (? :) ............................................................................................................. 59
Section 13.3: The Bitwise and Logical Operators (~, &, |, ^) ..................................................................................... 60
Section 13.4: The String Concatenation Operator (+) .............................................................................................. 61
Section 13.5: The Arithmetic Operators (+, -, *, /, %) ................................................................................................ 63
Section 13.6: The Shift Operators (<<, >> and >>>) ................................................................................................... 66
Section 13.7: The Instanceof Operator ...................................................................................................................... 67
Section 13.8: The Assignment Operators (=, +=, -=, *=, /=, %=, <<=, >>= , >>>=, &=, |= and ^=) ................................. 67
Section 13.9: The conditional-and and conditional-or Operators ( && and || ) ..................................................... 69
Section 13.10: The Relational Operators (<, <=, >, >=) ............................................................................................... 71
Section 13.11: The Equality Operators (==, !=) ............................................................................................................. 71
Section 13.12: The Lambda operator ( -> ) ................................................................................................................ 74
Chapter 14: Primitive Data Types ...................................................................................................................... 75
Section 14.1: The char primitive .................................................................................................................................. 75
Section 14.2: Primitive Types Cheatsheet .................................................................................................................. 75
Section 14.3: The float primitive ................................................................................................................................. 76
Section 14.4: The int primitive ..................................................................................................................................... 77
Section 14.5: Converting Primitives ............................................................................................................................ 78
Section 14.6: Memory consumption of primitives vs. boxed primitives .................................................................. 78
Section 14.7: The double primitive ............................................................................................................................. 79
Section 14.8: The long primitive .................................................................................................................................. 80
 Section 14.9: The boolean primitive ........................................................................................................................... 81
Section 14.10: The byte primitive ................................................................................................................................ 81
Section 14.11: Negative value representation ............................................................................................................ 82
Section 14.12: The short primitive ............................................................................................................................... 83
Chapter 15: Constructors ........................................................................................................................................ 84
Section 15.1: Default Constructor ............................................................................................................................... 84
Section 15.2: Call parent constructor ......................................................................................................................... 85
Section 15.3: Constructor with Arguments ................................................................................................................ 86
Chapter 16: Object Class Methods and Constructor ................................................................................. 88
Section 16.1: hashCode() method ............................................................................................................................... 88
Section 16.2: toString() method .................................................................................................................................. 90
Section 16.3: equals() method .................................................................................................................................... 91
Section 16.4: wait() and notify() methods ................................................................................................................. 94
Section 16.5: getClass() method ................................................................................................................................. 95
Section 16.6: clone() method ...................................................................................................................................... 96
Section 16.7: Object constructor ................................................................................................................................. 97
Section 16.8: finalize() method ................................................................................................................................... 99
Chapter 17: Annotations ........................................................................................................................................ 100
Section 17.1: The idea behind Annotations .............................................................................................................. 100
Section 17.2: Defining annotation types .................................................................................................................. 100
Section 17.3: Runtime annotation checks via reflection ........................................................................................ 102
Section 17.4: Built-in annotations ............................................................................................................................. 102
Section 17.5: Compile time processing using annotation processor .................................................................... 105
Section 17.6: Repeating Annotations ....................................................................................................................... 109
Section 17.7: Inherited Annotations .......................................................................................................................... 110
Section 17.8: Getting Annotation values at run-time ............................................................................................. 111
Section 17.9: Annotations for 'this' and receiver parameters ............................................................................... 112
Section 17.10: Add multiple annotation values ....................................................................................................... 113
Chapter 18: Immutable Class .............................................................................................................................. 114
Section 18.1: Example without mutable refs ............................................................................................................ 114
Section 18.2: What is the advantage of immutability? .......................................................................................... 114
Section 18.3: Rules to define immutable classes .................................................................................................... 114
Section 18.4: Example with mutable refs ................................................................................................................. 115
Chapter 19: Immutable Objects ......................................................................................................................... 116
Section 19.1: Creating an immutable version of a type using defensive copying .............................................. 116
Section 19.2: The recipe for an immutable class .................................................................................................... 116
Section 19.3: Typical design flaws which prevent a class from being immutable .............................................. 117
Chapter 20: Visibility (controlling access to members of a class) .................................................. 121
Section 20.1: Private Visibility ................................................................................................................................... 121
Section 20.2: Public Visibility .................................................................................................................................... 121
Section 20.3: Package Visibility ............................................................................................................................... 122
Section 20.4: Protected Visibility .............................................................................................................................. 122
Section 20.5: Summary of Class Member Access Modifiers ................................................................................. 123
Section 20.6: Interface members ............................................................................................................................ 123
Chapter 21: Generics ................................................................................................................................................ 124
Section 21.1: Creating a Generic Class ..................................................................................................................... 124
Section 21.2: Deciding between `T`, `? super T`, and `? extends T` ........................................................................ 126
Section 21.3: The Diamond ....................................................................................................................................... 128
Section 21.4: Declaring a Generic Method .............................................................................................................. 128
 Section 21.5: Requiring multiple upper bounds ("extends A & B") ....................................................................... 129
Section 21.6: Obtain class that satisfies generic parameter at runtime .............................................................. 129
Section 21.7: Benefits of Generic class and interface ............................................................................................ 130
Section 21.8: Instantiating a generic type ............................................................................................................... 131
Section 21.9: Creating a Bounded Generic Class ................................................................................................... 131
Section 21.10: Referring to the declared generic type within its own declaration .............................................. 133
Section 21.11: Binding generic parameter to more than 1 type ............................................................................. 134
Section 21.12: Using Generics to auto-cast ............................................................................................................. 135
Section 21.13: Use of instanceof with Generics ....................................................................................................... 135
Section 21.14: Dierent ways for implementing a Generic Interface (or extending a Generic Class) .............. 137
Chapter 22: Classes and Objects ...................................................................................................................... 139
Section 22.1: Overloading Methods ......................................................................................................................... 139
Section 22.2: Explaining what is method overloading and overriding ................................................................ 140
Section 22.3: Constructors ........................................................................................................................................ 142
Section 22.4: Initializing static final fields using a static initializer ........................................................................ 143
Section 22.5: Basic Object Construction and Use .................................................................................................. 144
Section 22.6: Simplest Possible Class ...................................................................................................................... 146
Section 22.7: Object Member vs Static Member .................................................................................................... 146
Chapter 23: Local Inner Class ............................................................................................................................. 148
Section 23.1: Local Inner Class ................................................................................................................................. 148
Chapter 24: Nested and Inner Classes .......................................................................................................... 149
Section 24.1: A Simple Stack Using a Nested Class ............................................................................................... 149
Section 24.2: Static vs Non Static Nested Classes ................................................................................................. 149
Section 24.3: Access Modifiers for Inner Classes ................................................................................................... 151
Section 24.4: Anonymous Inner Classes ................................................................................................................. 152
Section 24.5: Create instance of non-static inner class from outside ................................................................. 153
Section 24.6: Method Local Inner Classes .............................................................................................................. 154
Section 24.7: Accessing the outer class from a non-static inner class ................................................................ 154
Chapter 25: The java.util.Objects Class ......................................................................................................... 156
Section 25.1: Basic use for object null check .......................................................................................................... 156
Section 25.2: Objects.nonNull() method reference use in stream api ................................................................. 156
Chapter 26: Default Methods ............................................................................................................................. 157
Section 26.1: Basic usage of default methods ........................................................................................................ 157
Section 26.2: Accessing overridden default methods from implementing class ............................................... 157
Section 26.3: Why use Default Methods? ............................................................................................................... 158
Section 26.4: Accessing other interface methods within default method ........................................................... 158
Section 26.5: Default method multiple inheritance collision ................................................................................. 159
Section 26.6: Class, Abstract class and Interface method precedence .............................................................. 160
Chapter 27: Packages ............................................................................................................................................ 162
Section 27.1: Using Packages to create classes with the same name ................................................................. 162
Section 27.2: Using Package Protected Scope ...................................................................................................... 162
Chapter 28: Inheritance ......................................................................................................................................... 164
Section 28.1: Inheritance ........................................................................................................................................... 164
Section 28.2: Abstract Classes ................................................................................................................................. 165
Section 28.3: Using 'final' to restrict inheritance and overriding .......................................................................... 167
Section 28.4: The Liskov Substitution Principle ...................................................................................................... 168
Section 28.5: Abstract class and Interface usage: "Is-a" relation vs "Has-a" capability ................................... 168
Section 28.6: Static Inheritance ................................................................................................................................ 172
Section 28.7: Programming to an interface ........................................................................................................... 173
 Section 28.8: Overriding in Inheritance ................................................................................................................... 175
Section 28.9: Variable shadowing ........................................................................................................................... 176
Section 28.10: Narrowing and Widening of object references ............................................................................. 176
Section 28.11: Inheritance and Static Methods ........................................................................................................ 177
Chapter 29: Reference Types ............................................................................................................................. 179
Section 29.1: Dierent Reference Types ................................................................................................................. 179
Chapter 30: Strings .................................................................................................................................................. 181
Section 30.1: Comparing Strings .............................................................................................................................. 181
Section 30.2: Changing the case of characters within a String ............................................................................ 183
Section 30.3: Finding a String Within Another String ............................................................................................. 185
Section 30.4: String pool and heap storage ........................................................................................................... 186
Section 30.5: Splitting Strings ................................................................................................................................... 187
Section 30.6: Joining Strings with a delimiter ......................................................................................................... 189
Section 30.7: String concatenation and StringBuilders ......................................................................................... 190
Section 30.8: Substrings ............................................................................................................................................ 191
Section 30.9: Platform independent new line separator ....................................................................................... 192
Section 30.10: Reversing Strings .............................................................................................................................. 192
Section 30.11: Adding toString() method for custom objects ................................................................................ 193
Section 30.12: Remove Whitespace from the Beginning and End of a String .................................................... 194
Section 30.13: Case insensitive switch ..................................................................................................................... 194
Section 30.14: Replacing parts of Strings ................................................................................................................ 195
Section 30.15: Getting the length of a String .......................................................................................................... 196
Section 30.16: Getting the nth character in a String .............................................................................................. 196
Section 30.17: Counting occurrences of a substring or character in a string ..................................................... 196
Chapter 31: StringBuer ....................................................................................................................................... 198
Section 31.1: String Buer class ................................................................................................................................ 198
Chapter 32: StringBuilder ..................................................................................................................................... 199
Section 32.1: Comparing StringBuer, StringBuilder, Formatter and StringJoiner ............................................ 199
Section 32.2: Repeat a String n times ..................................................................................................................... 200
Chapter 33: String Tokenizer .............................................................................................................................. 201
Section 33.1: StringTokenizer Split by space ........................................................................................................... 201
Section 33.2: StringTokenizer Split by comma ',' .................................................................................................... 201
Chapter 34: Splitting a string into fixed length parts ........................................................................... 202
Section 34.1: Break a string up into substrings all of a known length ................................................................. 202
Section 34.2: Break a string up into substrings all of variable length ................................................................. 202
Chapter 35: BigInteger ........................................................................................................................................... 203
Section 35.1: Initialization .......................................................................................................................................... 203
Section 35.2: BigInteger Mathematical Operations Examples ............................................................................. 204
Section 35.3: Comparing BigIntegers ...................................................................................................................... 206
Section 35.4: Binary Logic Operations on BigInteger ............................................................................................ 207
Section 35.5: Generating random BigIntegers ....................................................................................................... 208
Chapter 36: Console I/O ........................................................................................................................................ 210
Section 36.1: Reading user input from the console ................................................................................................ 210
Section 36.2: Aligning strings in console ................................................................................................................. 211
Section 36.3: Implementing Basic Command-Line Behavior ................................................................................ 212
Chapter 37: BigDecimal ......................................................................................................................................... 214
Section 37.1: Comparing BigDecimals ..................................................................................................................... 214
Section 37.2: Using BigDecimal instead of float .................................................................................................... 214
Section 37.3: BigDecimal.valueOf() ......................................................................................................................... 215
 Section 37.4: Mathematical operations with BigDecimal ...................................................................................... 215
Section 37.5: Initialization of BigDecimals with value zero, one or ten ................................................................ 218
Section 37.6: BigDecimal objects are immutable .................................................................................................. 218
Chapter 38: NumberFormat ................................................................................................................................ 220
Section 38.1: NumberFormat .................................................................................................................................... 220
Chapter 39: Bit Manipulation .............................................................................................................................. 221
Section 39.1: Checking, setting, clearing, and toggling individual bits. Using long as bit mask ........................ 221
Section 39.2: java.util.BitSet class ............................................................................................................................ 221
Section 39.3: Checking if a number is a power of 2 .............................................................................................. 222
Section 39.4: Signed vs unsigned shift .................................................................................................................... 224
Section 39.5: Expressing the power of 2 ................................................................................................................. 224
Section 39.6: Packing / unpacking values as bit fragments ................................................................................ 225
Chapter 40: Arrays .................................................................................................................................................. 226
Section 40.1: Creating and Initializing Arrays ......................................................................................................... 226
Section 40.2: Creating a List from an Array ........................................................................................................... 232
Section 40.3: Creating an Array from a Collection ................................................................................................ 234
Section 40.4: Multidimensional and Jagged Arrays .............................................................................................. 234
Section 40.5: ArrayIndexOutOfBoundsException .................................................................................................. 236
Section 40.6: Array Covariance ............................................................................................................................... 237
Section 40.7: Arrays to Stream ................................................................................................................................ 238
Section 40.8: Iterating over arrays .......................................................................................................................... 238
Section 40.9: Arrays to a String ............................................................................................................................... 240
Section 40.10: Sorting arrays ................................................................................................................................... 241
Section 40.11: Getting the Length of an Array ........................................................................................................ 243
Section 40.12: Finding an element in an array ....................................................................................................... 243
Section 40.13: How do you change the size of an array? ..................................................................................... 244
Section 40.14: Converting arrays between primitives and boxed types ............................................................. 245
Section 40.15: Remove an element from an array ................................................................................................ 246
Section 40.16: Comparing arrays for equality ........................................................................................................ 247
Section 40.17: Copying arrays .................................................................................................................................. 247
Section 40.18: Casting Arrays ................................................................................................................................... 248
Chapter 41: Streams ............................................................................................................................................... 250
Section 41.1: Using Streams ...................................................................................................................................... 250
Section 41.2: Consuming Streams ............................................................................................................................ 252
Section 41.3: Creating a Frequency Map ................................................................................................................ 254
Section 41.4: Infinite Streams ................................................................................................................................... 254
Section 41.5: Collect Elements of a Stream into a Collection ................................................................................ 255
Section 41.6: Using Streams to Implement Mathematical Functions ................................................................... 257
Section 41.7: Flatten Streams with flatMap() .......................................................................................................... 258
Section 41.8: Parallel Stream .................................................................................................................................... 259
Section 41.9: Creating a Stream ............................................................................................................................... 259
Section 41.10: Finding Statistics about Numerical Streams ................................................................................... 261
Section 41.11: Converting an iterator to a stream ................................................................................................... 261
Section 41.12: Using IntStream to iterate over indexes .......................................................................................... 261
Section 41.13: Concatenate Streams ........................................................................................................................ 262
Section 41.14: Reduction with Streams .................................................................................................................... 262
Section 41.15: Using Streams of Map.Entry to Preserve Initial Values after Mapping ........................................ 265
Section 41.16: IntStream to String ............................................................................................................................. 265
Section 41.17: Finding the First Element that Matches a Predicate ...................................................................... 265
Section 41.18: Using Streams and Method References to Write Self-Documenting Processes ........................ 266
 Section 41.19: Converting a Stream of Optional to a Stream of Values .............................................................. 267
Section 41.20: Get a Slice of a Stream ..................................................................................................................... 267
Section 41.21: Create a Map based on a Stream .................................................................................................... 267
Section 41.22: Joining a stream to a single String ................................................................................................. 268
Section 41.23: Sort Using Stream ............................................................................................................................. 269
Section 41.24: Streams of Primitives ........................................................................................................................ 270
Section 41.25: Stream operations categories ......................................................................................................... 270
Section 41.26: Collect Results of a Stream into an Array ...................................................................................... 271
Section 41.27: Generating random Strings using Streams .................................................................................... 271
Chapter 42: InputStreams and OutputStreams ....................................................................................... 272
Section 42.1: Closing Streams .................................................................................................................................. 272
Section 42.2: Reading InputStream into a String ................................................................................................... 272
Section 42.3: Wrapping Input/Output Streams ..................................................................................................... 273
Section 42.4: DataInputStream Example ................................................................................................................ 274
Section 42.5: Writing bytes to an OutputStream ................................................................................................... 274
Section 42.6: Copying Input Stream to Output Stream ......................................................................................... 274
Chapter 43: Readers and Writers .................................................................................................................... 276
Section 43.1: BueredReader ................................................................................................................................... 276
Section 43.2: StringWriter Example ......................................................................................................................... 277
Chapter 44: Preferences ...................................................................................................................................... 278
Section 44.1: Using preferences ............................................................................................................................... 278
Section 44.2: Adding event listeners ....................................................................................................................... 278
Section 44.3: Getting sub-nodes of Preferences .................................................................................................... 279
Section 44.4: Coordinating preferences access across multiple application instances .................................... 280
Section 44.5: Exporting preferences ....................................................................................................................... 280
Section 44.6: Importing preferences ....................................................................................................................... 281
Section 44.7: Removing event listeners .................................................................................................................. 282
Section 44.8: Getting preferences values ............................................................................................................... 283
Section 44.9: Setting preferences values ................................................................................................................ 283
Chapter 45: Collections ......................................................................................................................................... 284
Section 45.1: Removing items from a List within a loop ........................................................................................ 284
Section 45.2: Constructing collections from existing data .................................................................................... 286
Section 45.3: Declaring an ArrayList and adding objects ..................................................................................... 288
Section 45.4: Iterating over Collections ................................................................................................................... 288
Section 45.5: Immutable Empty Collections ........................................................................................................... 290
Section 45.6: Sub Collections ................................................................................................................................... 290
Section 45.7: Unmodifiable Collection ..................................................................................................................... 291
Section 45.8: Pitfall: concurrent modification exceptions ..................................................................................... 292
Section 45.9: Removing matching items from Lists using Iterator ...................................................................... 292
Section 45.10: Join lists ............................................................................................................................................. 293
Section 45.11: Creating your own Iterable structure for use with Iterator or for-each loop .............................. 293
Section 45.12: Collections and Primitive Values ..................................................................................................... 295
Chapter 46: Queues and Deques ...................................................................................................................... 296
Section 46.1: The usage of the PriorityQueue ......................................................................................................... 296
Section 46.2: Deque .................................................................................................................................................. 296
Section 46.3: Stacks .................................................................................................................................................. 297
Section 46.4: BlockingQueue .................................................................................................................................... 298
Section 46.5: LinkedList as a FIFO Queue ............................................................................................................... 299
Section 46.6: Queue Interface .................................................................................................................................. 300
Chapter 47: Collection Factory Methods ..................................................................................................... 301
 Section 47.1: List<E> Factory Method Examples .................................................................................................... 301
Section 47.2: Set<E> Factory Method Examples .................................................................................................... 301
Section 47.3: Map<K, V> Factory Method Examples ............................................................................................. 301
Chapter 48: Alternative Collections ................................................................................................................ 302
Section 48.1: Multimap in Guava, Apache and Eclipse Collections ....................................................................... 302
Section 48.2: Apache HashBag, Guava HashMultiset and Eclipse HashBag ...................................................... 304
Section 48.3: Compare operation with collections - Create collections .............................................................. 306
Chapter 49: Concurrent Collections ............................................................................................................... 311
Section 49.1: Thread-safe Collections ..................................................................................................................... 311
Section 49.2: Insertion into ConcurrentHashMap .................................................................................................. 311
Section 49.3: Concurrent Collections ....................................................................................................................... 312
Chapter 50: Choosing Collections .................................................................................................................... 314
Section 50.1: Java Collections Flowchart ................................................................................................................ 314
Chapter 51: super keyword .................................................................................................................................. 315
Section 51.1: Super keyword use with examples ..................................................................................................... 315
Chapter 52: Serialization ...................................................................................................................................... 318
Section 52.1: Basic Serialization in Java .................................................................................................................. 318
Section 52.2: Custom Serialization .......................................................................................................................... 319
Section 52.3: Versioning and serialVersionUID ...................................................................................................... 322
Section 52.4: Serialization with Gson ....................................................................................................................... 323
Section 52.5: Custom JSON Deserialization with Jackson ................................................................................... 324
Chapter 53: Enums ................................................................................................................................................... 327
Section 53.1: Declaring and using a basic enum .................................................................................................... 327
Section 53.2: Enums with constructors ................................................................................................................... 330
Section 53.3: Enums with Abstract Methods ........................................................................................................... 331
Section 53.4: Implements Interface ......................................................................................................................... 332
Section 53.5: Implement Singleton pattern with a single-element enum ............................................................ 333
Section 53.6: Using methods and static blocks ...................................................................................................... 334
Section 53.7: Zero instance enum ........................................................................................................................... 335
Section 53.8: Enum as a bounded type parameter ............................................................................................... 335
Section 53.9: Documenting enums .......................................................................................................................... 335
Section 53.10: Enum constant specific body ........................................................................................................... 336
Section 53.11: Getting the values of an enum ......................................................................................................... 338
Section 53.12: Enum Polymorphism Pattern ........................................................................................................... 338
Section 53.13: Compare and Contains for Enum values ........................................................................................ 339
Section 53.14: Get enum constant by name ........................................................................................................... 340
Section 53.15: Enum with properties (fields) ........................................................................................................... 340
Section 53.16: Convert enum to String .................................................................................................................... 341
Section 53.17: Enums with static fields ..................................................................................................................... 341
Chapter 54: Enum Map .......................................................................................................................................... 343
Section 54.1: Enum Map Book Example .................................................................................................................. 343
Chapter 55: EnumSet class .................................................................................................................................. 344
Section 55.1: Enum Set Example .............................................................................................................................. 344
Chapter 56: Enum starting with number ...................................................................................................... 345
Section 56.1: Enum with name at begining ............................................................................................................. 345
Chapter 57: Lists ....................................................................................................................................................... 346
Section 57.1: Sorting a generic list ........................................................................................................................... 346
Section 57.2: Convert a list of integers to a list of strings ..................................................................................... 347
Section 57.3: Classes implementing List - Pros and Cons ..................................................................................... 347
 Section 57.4: Finding common elements between 2 lists ..................................................................................... 349
Section 57.5: In-place replacement of a List element ........................................................................................... 350
Section 57.6: Making a list unmodifiable ................................................................................................................ 351
Section 57.7: Moving objects around in the list ...................................................................................................... 351
Section 57.8: Creating, Adding and Removing element from an ArrayList ........................................................ 351
Section 57.9: Creating a List ..................................................................................................................................... 352
Section 57.10: Positional Access Operations ........................................................................................................... 353
Section 57.11: Iterating over elements in a list ........................................................................................................ 355
Section 57.12: Removing elements from list B that are present in the list A ....................................................... 355
Chapter 58: Sets ........................................................................................................................................................ 357
Section 58.1: Initialization .......................................................................................................................................... 357
Section 58.2: Basics of Set ........................................................................................................................................ 357
Section 58.3: Types and Usage of Sets ................................................................................................................... 358
Section 58.4: Create a list from an existing Set ..................................................................................................... 359
Section 58.5: Eliminating duplicates using Set ....................................................................................................... 359
Section 58.6: Declaring a HashSet with values ...................................................................................................... 360
Chapter 59: List vs Set ........................................................................................................................................... 361
Section 59.1: List vs Set ............................................................................................................................................. 361
Chapter 60: Maps ..................................................................................................................................................... 362
Section 60.1: Iterating Map Entries Eciently ......................................................................................................... 362
Section 60.2: Usage of HashMap ............................................................................................................................ 364
Section 60.3: Using Default Methods of Map from Java 8 ................................................................................... 365
Section 60.4: Iterating through the contents of a Map ......................................................................................... 367
Section 60.5: Merging, combine and composing Maps ........................................................................................ 368
Section 60.6: Add multiple items .............................................................................................................................. 369
Section 60.7: Creating and Initializing Maps ........................................................................................................... 370
Section 60.8: Check if key exists .............................................................................................................................. 372
Section 60.9: Add an element .................................................................................................................................. 372
Section 60.10: Clear the map .................................................................................................................................... 373
Section 60.11: Use custom object as key ................................................................................................................. 373
Chapter 61: LinkedHashMap ................................................................................................................................ 374
Section 61.1: Java LinkedHashMap class ................................................................................................................ 374
Chapter 62: TreeMap and TreeSet .................................................................................................................. 375
Section 62.1: TreeMap of a simple Java type ........................................................................................................ 375
Section 62.2: TreeSet of a simple Java Type ......................................................................................................... 375
Section 62.3: TreeMap/TreeSet of a custom Java type ....................................................................................... 376
Section 62.4: TreeMap and TreeSet Thread Safety .............................................................................................. 377
Chapter 63: SortedMap ......................................................................................................................................... 379
Section 63.1: Introduction to sorted Map ................................................................................................................ 379
Chapter 64: WeakHashMap ................................................................................................................................ 380
Section 64.1: Concepts of WeakHashmap .............................................................................................................. 380
Chapter 65: Hashtable ........................................................................................................................................... 381
Section 65.1: Hashtable ............................................................................................................................................. 381
Chapter 66: Optional ............................................................................................................................................... 382
Section 66.1: Map ....................................................................................................................................................... 382
Section 66.2: Return default value if Optional is empty ........................................................................................ 383
Section 66.3: Throw an exception, if there is no value .......................................................................................... 383
Section 66.4: Lazily provide a default value using a Supplier .............................................................................. 383
Section 66.5: Filter ..................................................................................................................................................... 384
 Section 66.6: Using Optional containers for primitive number types .................................................................. 384
Section 66.7: Run code only if there is a value present ......................................................................................... 385
Section 66.8: FlatMap ................................................................................................................................................ 385
Chapter 67: Object References ......................................................................................................................... 386
Section 67.1: Object References as method parameters ...................................................................................... 386
Chapter 68: Exceptions and exception handling ...................................................................................... 389
Section 68.1: Catching an exception with try-catch ............................................................................................... 389
Section 68.2: The try-with-resources statement .................................................................................................... 390
Section 68.3: Custom Exceptions ............................................................................................................................. 393
Section 68.4: Handling InterruptedException ......................................................................................................... 395
Section 68.5: Return statements in try catch block ............................................................................................... 396
Section 68.6: Introduction ......................................................................................................................................... 397
Section 68.7: The Java Exception Hierarchy - Unchecked and Checked Exceptions ........................................ 398
Section 68.8: Creating and reading stacktraces .................................................................................................... 401
Section 68.9: Throwing an exception ...................................................................................................................... 404
Section 68.10: Advanced features of Exceptions ................................................................................................... 406
Section 68.11: The try-finally and try-catch-finally statements ............................................................................ 407
Section 68.12: The 'throws' clause in a method declaration ................................................................................. 409
Chapter 69: Calendar and its Subclasses ..................................................................................................... 411
Section 69.1: Creating Calendar objects ................................................................................................................. 411
Section 69.2: Increasing / Decreasing calendar fields .......................................................................................... 411
Section 69.3: Subtracting calendars ........................................................................................................................ 411
Section 69.4: Finding AM/PM ................................................................................................................................... 411
Chapter 70: Using the static keyword ........................................................................................................... 413
Section 70.1: Reference to non-static member from static context .................................................................... 413
Section 70.2: Using static to declare constants ..................................................................................................... 413
Chapter 71: Properties Class ............................................................................................................................... 415
Section 71.1: Loading properties ............................................................................................................................... 415
Section 71.2: Saving Properties as XML ................................................................................................................... 415
Section 71.3: Property files caveat: trailing whitespace ......................................................................................... 416
Chapter 72: Lambda Expressions ..................................................................................................................... 419
Section 72.1: Introduction to Java lambdas ........................................................................................................... 419
Section 72.2: Using Lambda Expressions to Sort a Collection ............................................................................. 422
Section 72.3: Method References ............................................................................................................................ 423
Section 72.4: Implementing multiple interfaces ..................................................................................................... 425
Section 72.5: Lambda - Listener Example .............................................................................................................. 425
Section 72.6: Java Closures with lambda expressions .......................................................................................... 426
Section 72.7: Lambdas and memory utilization ..................................................................................................... 427
Section 72.8: Using lambda expression with your own functional interface ...................................................... 427
Section 72.9: Traditional style to Lambda style ..................................................................................................... 428
Section 72.10: `return` only returns from the lambda, not the outer method ..................................................... 429
Section 72.11: Lambdas and Execute-around Pattern ........................................................................................... 431
Section 72.12: Using lambda expressions & predicates to get a certain value(s) from a list ........................... 431
Chapter 73: Basic Control Structures ............................................................................................................. 433
Section 73.1: Switch statement ................................................................................................................................. 433
Section 73.2: do...while Loop ..................................................................................................................................... 434
Section 73.3: For Each ............................................................................................................................................... 435
Section 73.4: Continue Statement in Java .............................................................................................................. 436
Section 73.5: If / Else If / Else Control ..................................................................................................................... 436
 Section 73.6: For Loops ............................................................................................................................................. 436
Section 73.7: Ternary Operator ............................................................................................................................... 437
Section 73.8: Try ... Catch ... Finally ........................................................................................................................... 438
Section 73.9: Break .................................................................................................................................................... 438
Section 73.10: While Loops ....................................................................................................................................... 439
Section 73.11: If / Else ................................................................................................................................................ 439
Section 73.12: Nested break / continue .................................................................................................................. 439
Chapter 74: BueredWriter ............................................................................................................................... 441
Section 74.1: Write a line of text to File .................................................................................................................... 441
Chapter 75: New File I/O ...................................................................................................................................... 442
Section 75.1: Creating paths ..................................................................................................................................... 442
Section 75.2: Manipulating paths ............................................................................................................................. 442
Section 75.3: Retrieving information about a path ................................................................................................ 442
Section 75.4: Retrieving information using the filesystem .................................................................................... 443
Section 75.5: Reading files ........................................................................................................................................ 444
Section 75.6: Writing files .......................................................................................................................................... 444
Chapter 76: File I/O ................................................................................................................................................. 445
Section 76.1: Migrating from java.io.File to Java 7 NIO (java.nio.file.Path) .......................................................... 445
Section 76.2: Reading an image from a file ........................................................................................................... 447
Section 76.3: File Read/Write Using FileInputStream/FileOutputStream ........................................................... 447
Section 76.4: Reading all bytes to a byte[] ............................................................................................................ 448
Section 76.5: Copying a file using Channel ............................................................................................................. 449
Section 76.6: Writing a byte[] to a file .................................................................................................................... 449
Section 76.7: Stream vs Writer/Reader API ............................................................................................................ 450
Section 76.8: Reading a file with a Scanner ........................................................................................................... 451
Section 76.9: Copying a file using InputStream and OutputStream .................................................................... 452
Section 76.10: Reading from a binary file ............................................................................................................... 452
Section 76.11: Reading a file using Channel and Buer ......................................................................................... 452
Section 76.12: Adding Directories ............................................................................................................................. 453
Section 76.13: Blocking or redirecting standard output / error ............................................................................ 454
Section 76.14: Reading a whole file at once ............................................................................................................ 455
Section 76.15: Locking ............................................................................................................................................... 455
Section 76.16: Reading a file using BueredInputStream ..................................................................................... 455
Section 76.17: Iterate over a directory printing subdirectories in it ...................................................................... 456
Section 76.18: Writing a file using Channel and Buer .......................................................................................... 456
Section 76.19: Writing a file using PrintStream ....................................................................................................... 457
Section 76.20: Iterating over a directory and filter by file extension ................................................................... 457
Section 76.21: Accessing the contents of a ZIP file ................................................................................................ 458
Chapter 77: Scanner ............................................................................................................................................... 459
Section 77.1: General Pattern that does most commonly asked about tasks .................................................... 459
Section 77.2: Using custom delimiters .................................................................................................................... 461
Section 77.3: Reading system input using Scanner ............................................................................................... 461
Section 77.4: Reading file input using Scanner ...................................................................................................... 461
Section 77.5: Read the entire input as a String using Scanner ............................................................................. 462
Section 77.6: Carefully Closing a Scanner .............................................................................................................. 462
Section 77.7: Read an int from the command line ................................................................................................ 463
Chapter 78: Interfaces ........................................................................................................................................... 464
Section 78.1: Implementing multiple interfaces ...................................................................................................... 464
Section 78.2: Declaring and Implementing an Interface ...................................................................................... 465
Section 78.3: Extending an interface ....................................................................................................................... 465
 Section 78.4: Usefulness of interfaces .................................................................................................................... 466
Section 78.5: Default methods ................................................................................................................................. 468
Section 78.6: Modifiers in Interfaces ........................................................................................................................ 470
Section 78.7: Using Interfaces with Generics .......................................................................................................... 470
Section 78.8: Strengthen bounded type parameters ............................................................................................ 473
Section 78.9: Implementing interfaces in an abstract class ................................................................................. 473
Chapter 79: Regular Expressions ..................................................................................................................... 475
Section 79.1: Using capture groups ......................................................................................................................... 475
Section 79.2: Using regex with custom behaviour by compiling the Pattern with flags .................................... 476
Section 79.3: Escape Characters ............................................................................................................................. 476
Section 79.4: Not matching a given string .............................................................................................................. 477
Section 79.5: Matching with a regex literal ............................................................................................................. 477
Section 79.6: Matching a backslash ........................................................................................................................ 477
Chapter 80: Comparable and Comparator ................................................................................................ 479
Section 80.1: Sorting a List using Comparable<T> or a Comparator<T> ............................................................ 479
Section 80.2: The compareTo and compare Methods ......................................................................................... 482
Section 80.3: Natural (comparable) vs explicit (comparator) sorting ................................................................ 483
Section 80.4: Creating a Comparator using comparing method ........................................................................ 484
Section 80.5: Sorting Map entries ............................................................................................................................ 484
Chapter 81: Java Floating Point Operations .............................................................................................. 486
Section 81.1: Comparing floating point values ........................................................................................................ 486
Section 81.2: OverFlow and UnderFlow .................................................................................................................. 488
Section 81.3: Formatting the floating point values ................................................................................................ 489
Section 81.4: Strict Adherence to the IEEE Specification ....................................................................................... 489
Chapter 82: Currency and Money .................................................................................................................... 491
Section 82.1: Add custom currency ......................................................................................................................... 491
Chapter 83: Object Cloning .................................................................................................................................. 492
Section 83.1: Cloning performing a deep copy ...................................................................................................... 492
Section 83.2: Cloning using a copy factory ............................................................................................................ 493
Section 83.3: Cloning using a copy constructor ..................................................................................................... 493
Section 83.4: Cloning by implementing Clonable interface .................................................................................. 493
Section 83.5: Cloning performing a shallow copy ................................................................................................. 494
Chapter 84: Recursion ........................................................................................................................................... 496
Section 84.1: The basic idea of recursion ................................................................................................................ 496
Section 84.2: Deep recursion is problematic in Java ............................................................................................ 496
Section 84.3: Types of Recursion ............................................................................................................................ 498
Section 84.4: Computing the Nth Fibonacci Number ............................................................................................ 498
Section 84.5: StackOverflowError & recursion to loop .......................................................................................... 499
Section 84.6: Computing the Nth power of a number ........................................................................................... 501
Section 84.7: Traversing a Tree data structure with recursion ............................................................................ 501
Section 84.8: Reverse a string using Recursion ..................................................................................................... 502
Section 84.9: Computing the sum of integers from 1 to N .................................................................................... 502
Chapter 85: Converting to and from Strings ............................................................................................. 503
Section 85.1: Converting String to other datatypes ............................................................................................... 503
Section 85.2: Conversion to / from bytes ............................................................................................................... 504
Section 85.3: Base64 Encoding / Decoding ........................................................................................................... 504
Section 85.4: Converting other datatypes to String .............................................................................................. 505
Section 85.5: Getting a `String` from an `InputStream` .......................................................................................... 506
Chapter 86: Random Number Generation ................................................................................................... 507
 Section 86.1: Pseudo Random Numbers ................................................................................................................. 507
Section 86.2: Pseudo Random Numbers in Specific Range ................................................................................. 507
Section 86.3: Generating cryptographically secure pseudorandom numbers ................................................... 508
Section 86.4: Generating Random Numbers with a Specified Seed .................................................................... 508
Section 86.5: Select random numbers without duplicates .................................................................................... 509
Section 86.6: Generating Random number using apache-common lang3 ........................................................ 510
Chapter 87: Singletons .......................................................................................................................................... 511
Section 87.1: Enum Singleton .................................................................................................................................... 511
Section 87.2: Singleton without use of Enum (eager initialization) ...................................................................... 511
Section 87.3: Thread-safe lazy initialization using holder class | Bill Pugh Singleton implementation ............ 512
Section 87.4: Thread safe Singleton with double checked locking ...................................................................... 512
Section 87.5: Extending singleton (singleton inheritance) .................................................................................... 513
Chapter 88: Autoboxing ........................................................................................................................................ 516
Section 88.1: Using int and Integer interchangeably ............................................................................................. 516
Section 88.2: Auto-unboxing may lead to NullPointerException .......................................................................... 517
Section 88.3: Using Boolean in if statement ........................................................................................................... 517
Section 88.4: Dierent Cases When Integer and int can be used interchangeably .......................................... 518
Section 88.5: Memory and Computational Overhead of Autoboxing ................................................................. 519
Chapter 89: 2D Graphics in Java ...................................................................................................................... 521
Section 89.1: Example 1: Draw and Fill a Rectangle Using Java ........................................................................... 521
Section 89.2: Example 2: Drawing and Filling Oval ................................................................................................ 523
Chapter 90: JAXB ...................................................................................................................................................... 524
Section 90.1: Reading an XML file (unmarshalling) ............................................................................................... 524
Section 90.2: Writing an XML file (marshalling an object) .................................................................................... 524
Section 90.3: Manual field/property XML mapping configuration ...................................................................... 525
Section 90.4: Binding an XML namespace to a serializable Java class .............................................................. 526
Section 90.5: Using XmlAdapter to generate desired xml format ....................................................................... 526
Section 90.6: Using XmlAdapter to trim string ....................................................................................................... 528
Section 90.7: Automatic field/property XML mapping configuration (@XmlAccessorType) ........................... 528
Section 90.8: Specifying a XmlAdapter instance to (re)use existing data .......................................................... 530
Chapter 91: Class - Java Reflection ................................................................................................................. 533
Section 91.1: getClass() method of Object class ..................................................................................................... 533
Chapter 92: Networking ........................................................................................................................................ 534
Section 92.1: Basic Client and Server Communication using a Socket ................................................................ 534
Section 92.2: Basic Client/Server Communication using UDP (Datagram) ....................................................... 536
Section 92.3: Loading TrustStore and KeyStore from InputStream .................................................................... 537
Section 92.4: Socket example - reading a web page using a simple socket ...................................................... 538
Section 92.5: Temporarily disable SSL verification (for testing purposes) ......................................................... 539
Section 92.6: Downloading a file using Channel .................................................................................................... 539
Section 92.7: Multicasting ......................................................................................................................................... 540
Chapter 93: NIO - Networking ............................................................................................................................ 543
Section 93.1: Using Selector to wait for events (example with OP_CONNECT) .................................................. 543
Chapter 94: HttpURLConnection ...................................................................................................................... 545
Section 94.1: Get response body from a URL as a String ..................................................................................... 545
Section 94.2: POST data ........................................................................................................................................... 546
Section 94.3: Delete resource .................................................................................................................................. 546
Section 94.4: Check if resource exists ..................................................................................................................... 547
Chapter 95: JAX-WS ................................................................................................................................................ 549
Section 95.1: Basic Authentication ........................................................................................................................... 549
Chapter 96: Nashorn JavaScript engine ....................................................................................................... 550
Section 96.1: Execute JavaScript file ....................................................................................................................... 550
Section 96.2: Intercept script output ....................................................................................................................... 550
Section 96.3: Hello Nashorn ..................................................................................................................................... 551
Section 96.4: Evaluate Arithmetic Strings ............................................................................................................... 551
Section 96.5: Set global variables ............................................................................................................................ 551
Section 96.6: Set and get global variables ............................................................................................................. 552
Section 96.7: Usage of Java objects in JavaScript in Nashorn ............................................................................ 552
Section 96.8: Implementing an interface from script ............................................................................................ 553
Chapter 97: Java Native Interface .................................................................................................................. 554
Section 97.1: Calling C++ methods from Java ........................................................................................................ 554
Section 97.2: Calling Java methods from C++ (callback) ..................................................................................... 555
Section 97.3: Loading native libraries ..................................................................................................................... 557
Chapter 98: Functional Interfaces ................................................................................................................... 559
Section 98.1: List of standard Java Runtime Library functional interfaces by signature .................................. 559
Chapter 99: Fluent Interface .............................................................................................................................. 560
Section 99.1: Fluent programming style ................................................................................................................. 560
Section 99.2: Truth - Fluent Testing Framework .................................................................................................... 561
Chapter 100: Dequeue Interface ....................................................................................................................... 562
Section 100.1: Adding Elements to Deque ............................................................................................................... 562
Section 100.2: Removing Elements from Deque .................................................................................................... 562
Section 100.3: Retrieving Element without Removing ........................................................................................... 562
Section 100.4: Iterating through Deque .................................................................................................................. 562
Chapter 101: Remote Method Invocation (RMI) ......................................................................................... 564
Section 101.1: Callback: invoking methods on a "client" ......................................................................................... 564
Section 101.2: Simple RMI example with Client and Server implementation ....................................................... 568
Section 101.3: Client-Server: invoking methods in one JVM from another .......................................................... 570
Chapter 102: Iterator and Iterable .................................................................................................................. 573
Section 102.1: Removing elements using an iterator ............................................................................................. 573
Section 102.2: Creating your own Iterable .............................................................................................................. 573
Section 102.3: Using Iterable in for loop .................................................................................................................. 574
Section 102.4: Using the raw iterator ...................................................................................................................... 575
Chapter 103: Reflection API ................................................................................................................................. 576
Section 103.1: Dynamic Proxies ................................................................................................................................ 576
Section 103.2: Introduction ....................................................................................................................................... 577
Section 103.3: Evil Java hacks with Reflection ....................................................................................................... 578
Section 103.4: Misuse of Reflection API to change private and final variables ................................................... 580
Section 103.5: Getting and Setting fields ................................................................................................................. 581
Section 103.6: Call constructor ................................................................................................................................. 582
Section 103.7: Call constructor of nested class ...................................................................................................... 583
Section 103.8: Invoking a method ............................................................................................................................ 583
Section 103.9: Get Class given its (fully qualified) name ....................................................................................... 584
Section 103.10: Getting the Constants of an Enumeration .................................................................................... 584
Section 103.11: Call overloaded constructors using reflection ............................................................................... 585
Chapter 104: ByteBuer ....................................................................................................................................... 587
Section 104.1: Basic Usage - Using DirectByteBuer ............................................................................................ 587
Section 104.2: Basic Usage - Creating a ByteBuer ............................................................................................. 587
Section 104.3: Basic Usage - Write Data to the Buer .......................................................................................... 588
Chapter 105: Applets ............................................................................................................................................... 589
 Section 105.1: Minimal Applet ................................................................................................................................... 589
Section 105.2: Creating a GUI ................................................................................................................................... 590
Section 105.3: Open links from within the applet ................................................................................................... 590
Section 105.4: Loading images, audio and other resources ................................................................................. 591
Chapter 106: Expressions ...................................................................................................................................... 593
Section 106.1: Operator Precedence ........................................................................................................................ 593
Section 106.2: Expression Basics .............................................................................................................................. 594
Section 106.3: Expression evaluation order ............................................................................................................ 595
Section 106.4: Constant Expressions ....................................................................................................................... 596
Chapter 107: JSON in Java .................................................................................................................................. 599
Section 107.1: Using Jackson Object Mapper ......................................................................................................... 599
Section 107.2: JSON To Object (Gson Library) ....................................................................................................... 600
Section 107.3: JSONObject.NULL ............................................................................................................................. 600
Section 107.4: JSON Builder - chaining methods ................................................................................................... 601
Section 107.5: Object To JSON (Gson Library) ....................................................................................................... 601
Section 107.6: JSON Iteration ................................................................................................................................... 601
Section 107.7: optXXX vs getXXX methods ............................................................................................................. 602
Section 107.8: Extract single element from JSON .................................................................................................. 602
Section 107.9: JsonArray to Java List (Gson Library) ........................................................................................... 602
Section 107.10: Encoding data as JSON .................................................................................................................. 603
Section 107.11: Decoding JSON data ....................................................................................................................... 603
Chapter 108: XML Parsing using the JAXP APIs ......................................................................................... 605
Section 108.1: Parsing a document using the StAX API .......................................................................................... 605
Section 108.2: Parsing and navigating a document using the DOM API ............................................................. 606
Chapter 109: XML XPath Evaluation ................................................................................................................ 608
Section 109.1: Parsing multiple XPath Expressions in a single XML ...................................................................... 608
Section 109.2: Parsing single XPath Expression multiple times in an XML .......................................................... 608
Section 109.3: Evaluating a NodeList in an XML document .................................................................................. 609
Chapter 110: XOM - XML Object Model ........................................................................................................... 610
Section 110.1: Reading a XML file .............................................................................................................................. 610
Section 110.2: Writing to a XML File ......................................................................................................................... 612
Chapter 111: Polymorphism .................................................................................................................................. 615
Section 111.1: Method Overriding ............................................................................................................................... 615
Section 111.2: Method Overloading ........................................................................................................................... 616
Section 111.3: Polymorphism and dierent types of overriding ............................................................................ 617
Section 111.4: Virtual functions .................................................................................................................................. 620
Section 111.5: Adding behaviour by adding classes without touching existing code .......................................... 621
Chapter 112: Encapsulation .................................................................................................................................. 623
Section 112.1: Encapsulation to maintain invariants ............................................................................................... 623
Section 112.2: Encapsulation to reduce coupling .................................................................................................... 624
Chapter 113: Java Agents ...................................................................................................................................... 625
Section 113.1: Modifying classes with agents ........................................................................................................... 625
Section 113.2: Adding an agent at runtime ............................................................................................................. 625
Section 113.3: Setting up a basic agent .................................................................................................................... 626
Chapter 114: Varargs (Variable Argument) ................................................................................................ 627
Section 114.1: Working with Varargs parameters ................................................................................................... 627
Section 114.2: Specifying a varargs parameter ...................................................................................................... 627
Chapter 115: Logging (java.util.logging) ....................................................................................................... 628
Section 115.1: Logging complex messages (eciently) ......................................................................................... 628
 Section 115.2: Using the default logger ................................................................................................................... 629
Section 115.3: Logging levels .................................................................................................................................... 630
Chapter 116: log4j / log4j2 .................................................................................................................................. 632
Section 116.1: Properties-File to log to DB ............................................................................................................... 632
Section 116.2: How to get Log4j ................................................................................................................................ 632
Section 116.3: Setting up property file ...................................................................................................................... 633
Section 116.4: Basic log4j2.xml configuration file ................................................................................................... 634
Section 116.5: How to use Log4j in Java code ........................................................................................................ 634
Section 116.6: Migrating from log4j 1.x to 2.x ........................................................................................................... 635
Section 116.7: Filter Logoutput by level (log4j 1.x) ................................................................................................... 636
Chapter 117: Oracle Ocial Code Standard ............................................................................................... 637
Section 117.1: Naming Conventions .......................................................................................................................... 637
Section 117.2: Class Structure ................................................................................................................................... 638
Section 117.3: Annotations ......................................................................................................................................... 639
Section 117.4: Import statements ............................................................................................................................. 639
Section 117.5: Braces ................................................................................................................................................. 640
Section 117.6: Redundant Parentheses .................................................................................................................... 641
Section 117.7: Modifiers .............................................................................................................................................. 641
Section 117.8: Indentation .......................................................................................................................................... 642
Section 117.9: Literals ................................................................................................................................................. 642
Section 117.10: Package declaration ........................................................................................................................ 642
Section 117.11: Lambda Expressions ......................................................................................................................... 642
Section 117.12: Java Source Files .............................................................................................................................. 643
Section 117.13: Wrapping statements ....................................................................................................................... 643
Section 117.14: Wrapping Method Declarations ...................................................................................................... 644
Section 117.15: Wrapping Expressions ...................................................................................................................... 644
Section 117.16: Whitespace ........................................................................................................................................ 645
Section 117.17: Special Characters ............................................................................................................................ 645
Section 117.18: Variable Declarations ....................................................................................................................... 646
Chapter 118: Character encoding ..................................................................................................................... 647
Section 118.1: Reading text from a file encoded in UTF-8 ..................................................................................... 647
Section 118.2: Writing text to a file in UTF-8 ............................................................................................................ 647
Section 118.3: Getting byte representation of a string in UTF-8 ........................................................................... 648
Chapter 119: Apache Commons Lang ............................................................................................................. 649
Section 119.1: Implement equals() method .............................................................................................................. 649
Section 119.2: Implement hashCode() method ....................................................................................................... 649
Section 119.3: Implement toString() method ........................................................................................................... 650
Chapter 120: Localization and Internationalization ................................................................................ 652
Section 120.1: Locale .................................................................................................................................................. 652
Section 120.2: Automatically formatted Dates using "locale" .............................................................................. 653
Section 120.3: String Comparison ............................................................................................................................ 653
Chapter 121: Parallel programming with Fork/Join framework ...................................................... 654
Section 121.1: Fork/Join Tasks in Java .................................................................................................................... 654
Chapter 122: Non-Access Modifiers ................................................................................................................. 656
Section 122.1: final ...................................................................................................................................................... 656
Section 122.2: static ................................................................................................................................................... 657
Section 122.3: abstract .............................................................................................................................................. 658
Section 122.4: strictfp ................................................................................................................................................ 659
Section 122.5: volatile ................................................................................................................................................ 659
 Section 122.6: synchronized ..................................................................................................................................... 660
Section 122.7: transient ............................................................................................................................................. 661
Chapter 123: Process ............................................................................................................................................... 662
Section 123.1: Pitfall: Runtime.exec, Process and ProcessBuilder don't understand shell syntax ...................... 662
Section 123.2: Simple example (Java version < 1.5) ............................................................................................... 664
Chapter 124: Java Native Access ..................................................................................................................... 665
Section 124.1: Introduction to JNA ........................................................................................................................... 665
Chapter 125: Modules .............................................................................................................................................. 666
Section 125.1: Defining a basic module ................................................................................................................... 666
Chapter 126: Concurrent Programming (Threads) .................................................................................. 667
Section 126.1: Callable and Future ........................................................................................................................... 667
Section 126.2: CountDownLatch ............................................................................................................................... 668
Section 126.3: Basic Multithreading ......................................................................................................................... 670
Section 126.4: Locks as Synchronisation aids ......................................................................................................... 671
Section 126.5: Semaphore ........................................................................................................................................ 672
Section 126.6: Synchronization ................................................................................................................................. 673
Section 126.7: Runnable Object ................................................................................................................................ 674
Section 126.8: Creating basic deadlocked system ................................................................................................. 675
Section 126.9: Creating a java.lang.Thread instance ............................................................................................. 677
Section 126.10: Atomic operations ........................................................................................................................... 678
Section 126.11: Exclusive write / Concurrent read access ...................................................................................... 679
Section 126.12: Producer-Consumer ........................................................................................................................ 680
Section 126.13: Visualizing read/write barriers while using synchronized / volatile ........................................... 682
Section 126.14: Get status of all threads started by your program excluding system threads ........................ 683
Section 126.15: Using ThreadLocal ........................................................................................................................... 684
Section 126.16: Multiple producer/consumer example with shared global queue ............................................. 685
Section 126.17: Add two `int` arrays using a Threadpool ....................................................................................... 686
Section 126.18: Pausing Execution ............................................................................................................................ 687
Section 126.19: Thread Interruption / Stopping Threads ....................................................................................... 688
Chapter 127: Executor, ExecutorService and Thread pools ................................................................ 691
Section 127.1: ThreadPoolExecutor .......................................................................................................................... 691
Section 127.2: Retrieving value from computation - Callable ............................................................................... 692
Section 127.3: submit() vs execute() exception handling dierences .................................................................. 693
Section 127.4: Handle Rejected Execution .............................................................................................................. 695
Section 127.5: Fire and Forget - Runnable Tasks ................................................................................................... 695
Section 127.6: Use cases for dierent types of concurrency constructs ............................................................. 696
Section 127.7: Wait for completion of all tasks in ExecutorService ...................................................................... 697
Section 127.8: Use cases for dierent types of ExecutorService .......................................................................... 699
Section 127.9: Scheduling tasks to run at a fixed time, after a delay or repeatedly .......................................... 701
Section 127.10: Using Thread Pools ......................................................................................................................... 702
Chapter 128: ThreadLocal .................................................................................................................................... 703
Section 128.1: Basic ThreadLocal usage .................................................................................................................. 703
Section 128.2: ThreadLocal Java 8 functional initialization .................................................................................. 704
Section 128.3: Multiple threads with one shared object ........................................................................................ 705
Chapter 129: Using ThreadPoolExecutor in MultiThreaded applications. .................................... 707
Section 129.1: Performing Asynchronous Tasks Where No Return Value Is Needed Using a Runnable Class
Instance .............................................................................................................................................................. 707
Section 129.2: Performing Asynchronous Tasks Where a Return Value Is Needed Using a Callable Class
Instance .............................................................................................................................................................. 708
Section 129.3: Defining Asynchronous Tasks Inline using Lambdas .................................................................... 711
Chapter 130: Common Java Pitfalls ................................................................................................................ 713
Section 130.1: Pitfall: using == to compare primitive wrappers objects such as Integer ..................................... 713
Section 130.2: Pitfall: using == to compare strings ................................................................................................. 714
Section 130.3: Pitfall: forgetting to free resources ................................................................................................. 715
Section 130.4: Pitfall: testing a file before attempting to open it .......................................................................... 716
Section 130.5: Pitfall: thinking of variables as objects ........................................................................................... 718
Section 130.6: Pitfall: memory leaks ........................................................................................................................ 721
Section 130.7: Pitfall: Not understanding that String is an immutable class ....................................................... 722
Section 130.8: Pitfall: combining assignment and side-eects ............................................................................. 722
Chapter 131: Java Pitfalls - Exception usage .............................................................................................. 724
Section 131.1: Pitfall - Catching Throwable, Exception, Error or RuntimeException ............................................ 724
Section 131.2: Pitfall - Ignoring or squashing exceptions ....................................................................................... 725
Section 131.3: Pitfall - Throwing Throwable, Exception, Error or RuntimeException ........................................... 726
Section 131.4: Pitfall - Using exceptions for normal flowcontrol ........................................................................... 727
Section 131.5: Pitfall - Directly subclassing `Throwable` ......................................................................................... 728
Section 131.6: Pitfall - Catching InterruptedException ............................................................................................ 728
Section 131.7: Pitfall - Excessive or inappropriate stacktraces .............................................................................. 730
Chapter 132: Java Pitfalls - Language syntax ........................................................................................... 731
Section 132.1: Pitfall - Missing a ‘break’ in a 'switch' case ...................................................................................... 731
Section 132.2: Pitfall - Declaring classes with the same names as standard classes ........................................ 731
Section 132.3: Pitfall - Leaving out braces: the "dangling if" and "dangling else" problems ............................. 732
Section 132.4: Pitfall - Octal literals .......................................................................................................................... 734
Section 132.5: Pitfall - Using '==' to test a boolean ................................................................................................. 734
Section 132.6: Pitfall - Ignoring method visibility .................................................................................................... 735
Section 132.7: Pitfall: Using 'assert' for argument or user input validation ......................................................... 735
Section 132.8: Pitfall - Wildcard imports can make your code fragile ................................................................. 736
Section 132.9: Pitfall - Misplaced semicolons and missing braces ....................................................................... 737
Section 132.10: Pitfall - Overloading instead of overriding .................................................................................... 738
Section 132.11: Pitfall of Auto-Unboxing Null Objects into Primitives .................................................................... 739
Chapter 133: Java Pitfalls - Threads and Concurrency ......................................................................... 740
Section 133.1: Pitfall - Extending 'java.lang.Thread' ................................................................................................ 740
Section 133.2: Pitfall - Too many threads makes an application slower ............................................................. 741
Section 133.3: Pitfall: incorrect use of wait() / notify() ........................................................................................... 742
Section 133.4: Pitfall: Shared variables require proper synchronization .............................................................. 742
Section 133.5: Pitfall - Thread creation is relatively expensive ............................................................................. 745
Chapter 134: Java Pitfalls - Nulls and NullPointerException ............................................................. 748
Section 134.1: Pitfall - "Making good" unexpected nulls ......................................................................................... 748
Section 134.2: Pitfall - Using null to represent an empty array or collection ...................................................... 749
Section 134.3: Pitfall - Not checking if an I/O stream isn't even initialized when closing it ............................... 750
Section 134.4: Pitfall - Returning null instead of throwing an exception .............................................................. 750
Section 134.5: Pitfall - Unnecessary use of Primitive Wrappers can lead to NullPointerExceptions ................ 751
Section 134.6: Pitfall - Using "Yoda notation" to avoid NullPointerException ...................................................... 752
Chapter 135: Java Pitfalls - Performance Issues ...................................................................................... 753
Section 135.1: Pitfall - String concatenation in a loop does not scale .................................................................. 753
Section 135.2: Pitfall - Using size() to test if a collection is empty is inecient .................................................. 754
Section 135.3: Pitfall - Interning strings so that you can use == is a bad idea ..................................................... 754
Section 135.4: Pitfall - Using 'new' to create primitive wrapper instances is inecient ..................................... 756
Section 135.5: Pitfall - Eciency concerns with regular expressions ................................................................... 756
Section 135.6: Pitfall - Small reads / writes on unbuered streams are inecient ........................................... 759
Section 135.7: Pitfall - Over-use of primitive wrapper types is inecient ............................................................ 761
 Section 135.8: Pitfall - The overheads of creating log messages ......................................................................... 762
Section 135.9: Pitfall - Iterating a Map's keys can be inecient ........................................................................... 763
Section 135.10: Pitfall - Calling System.gc() is inecient ....................................................................................... 763
Section 135.11: Pitfall - Calling 'new String(String)' is inecient ............................................................................ 764
Chapter 136: ServiceLoader ................................................................................................................................ 765
Section 136.1: Simple ServiceLoader Example ........................................................................................................ 765
Section 136.2: Logger Service ................................................................................................................................... 766
Chapter 137: Classloaders .................................................................................................................................... 768
Section 137.1: Implementing a custom classLoader ............................................................................................... 768
Section 137.2: Loading an external .class file .......................................................................................................... 768
Section 137.3: Instantiating and using a classloader ............................................................................................. 769
Chapter 138: Creating Images Programmatically ................................................................................... 771
Section 138.1: Creating a simple image programmatically and displaying it ..................................................... 771
Section 138.2: Save an Image to disk ...................................................................................................................... 772
Section 138.3: Setting individual pixel's color in BueredImage ........................................................................... 772
Section 138.4: Specifying image rendering quality ................................................................................................ 773
Section 138.5: Creating an image with BueredImage class ............................................................................... 775
Section 138.6: Editing and re-using image with BueredImage ........................................................................... 776
Section 138.7: How to scale a BueredImage ........................................................................................................ 777
Chapter 139: Atomic Types .................................................................................................................................. 778
Section 139.1: Creating Atomic Types ...................................................................................................................... 778
Section 139.2: Motivation for Atomic Types ............................................................................................................ 778
Chapter 140: RSA Encryption ............................................................................................................................. 782
Section 140.1: An example using a hybrid cryptosystem consisting of OAEP and GCM .................................... 782
Chapter 141: Secure objects ................................................................................................................................ 787
Section 141.1: SealedObject (javax.crypto.SealedObject) ...................................................................................... 787
Section 141.2: SignedObject (java.security.SignedObject) ..................................................................................... 787
Chapter 142: Security & Cryptography ......................................................................................................... 789
Section 142.1: Compute Cryptographic Hashes ...................................................................................................... 789
Section 142.2: Encrypt and Decrypt Data with Public / Private Keys .................................................................. 789
Section 142.3: Generate Cryptographically Random Data ................................................................................... 790
Section 142.4: Generate Public / Private Key Pairs ................................................................................................ 790
Section 142.5: Compute and Verify Digital Signatures .......................................................................................... 791
Chapter 143: Security & Cryptography ......................................................................................................... 792
Section 143.1: The JCE ............................................................................................................................................... 792
Section 143.2: Keys and Key Management ............................................................................................................ 792
Section 143.3: Common Java vulnerabilities .......................................................................................................... 792
Section 143.4: Networking Concerns ....................................................................................................................... 792
Section 143.5: Randomness and You ....................................................................................................................... 792
Section 143.6: Hashing and Validation .................................................................................................................... 792
Chapter 144: SecurityManager ......................................................................................................................... 794
Section 144.1: Sandboxing classes loaded by a ClassLoader ............................................................................... 794
Section 144.2: Enabling the SecurityManager ........................................................................................................ 795
Section 144.3: Implementing policy deny rules ...................................................................................................... 795
Chapter 145: JNDI .................................................................................................................................................... 803
Section 145.1: RMI through JNDI .............................................................................................................................. 803
Chapter 146: sun.misc.Unsafe ............................................................................................................................ 807
Section 146.1: Instantiating sun.misc.Unsafe via reflection .................................................................................... 807
Section 146.2: Instantiating sun.misc.Unsafe via bootclasspath ........................................................................... 807
 Section 146.3: Getting Instance of Unsafe .............................................................................................................. 807
Section 146.4: Uses of Unsafe .................................................................................................................................. 808
Chapter 147: Java Memory Model ................................................................................................................... 809
Section 147.1: Motivation for the Memory Model .................................................................................................... 809
Section 147.2: Happens-before relationships ......................................................................................................... 811
Section 147.3: How to avoid needing to understand the Memory Model ............................................................ 812
Section 147.4: Happens-before reasoning applied to some examples ............................................................... 813
Chapter 148: Java deployment ......................................................................................................................... 816
Section 148.1: Making an executable JAR from the command line ..................................................................... 816
Section 148.2: Creating an UberJAR for an application and its dependencies .................................................. 817
Section 148.3: Creating JAR, WAR and EAR files ................................................................................................... 818
Section 148.4: Introduction to Java Web Start ....................................................................................................... 819
Chapter 149: Java plugin system implementations ............................................................................... 822
Section 149.1: Using URLClassLoader ...................................................................................................................... 822
Chapter 150: JavaBean ......................................................................................................................................... 826
Section 150.1: Basic Java Bean ................................................................................................................................ 826
Chapter 151: Java SE 7 Features ....................................................................................................................... 827
Section 151.1: New Java SE 7 programming language features .......................................................................... 827
Section 151.2: Binary Literals .................................................................................................................................... 827
Section 151.3: The try-with-resources statement ................................................................................................... 827
Section 151.4: Underscores in Numeric Literals ...................................................................................................... 828
Section 151.5: Type Inference for Generic Instance Creation ................................................................................ 828
Section 151.6: Strings in switch Statements ............................................................................................................. 828
Chapter 152: Java SE 8 Features ...................................................................................................................... 830
Section 152.1: New Java SE 8 programming language features ......................................................................... 830
Chapter 153: Dynamic Method Dispatch ....................................................................................................... 831
Section 153.1: Dynamic Method Dispatch - Example Code ................................................................................... 831
Chapter 154: Generating Java Code .............................................................................................................. 834
Section 154.1: Generate POJO From JSON ............................................................................................................. 834
Chapter 155: JShell .................................................................................................................................................. 835
Section 155.1: Editting Snippets ................................................................................................................................ 835
Section 155.2: Entering and Exiting JShell ............................................................................................................... 836
Section 155.3: Expressions ........................................................................................................................................ 836
Section 155.4: Methods and Classes ........................................................................................................................ 837
Section 155.5: Variables ............................................................................................................................................ 837
Chapter 156: Stack-Walking API ........................................................................................................................ 838
Section 156.1: Print all stack frames of the current thread .................................................................................... 838
Section 156.2: Print current caller class ................................................................................................................... 839
Section 156.3: Showing reflection and other hidden frames ................................................................................. 839
Chapter 157: Sockets .............................................................................................................................................. 841
Section 157.1: Read from socket .............................................................................................................................. 841
Chapter 158: Java Sockets .................................................................................................................................. 842
Section 158.1: A simple TCP echo back server ........................................................................................................ 842
Chapter 159: FTP (File Transfer Protocol) .................................................................................................... 845
Section 159.1: Connecting and Logging Into a FTP Server .................................................................................... 845
Chapter 160: Using Other Scripting Languages in Java ....................................................................... 850
Section 160.1: Evaluating A JavaScript file in -scripting mode of nashorn .......................................................... 850
Chapter 161: C++ Comparison ............................................................................................................................. 853
 Section 161.1: Static Class Members ......................................................................................................................... 853
Section 161.2: Classes Defined within Other Constructs ........................................................................................ 853
Section 161.3: Pass-by-value & Pass-by-reference ................................................................................................ 854
Section 161.4: Inheritance vs Composition .............................................................................................................. 855
Section 161.5: Outcast Downcasting ........................................................................................................................ 856
Section 161.6: Abstract Methods & Classes ............................................................................................................. 856
Chapter 162: Audio .................................................................................................................................................... 858
Section 162.1: Play a MIDI file .................................................................................................................................... 858
Section 162.2: Play an Audio file Looped ................................................................................................................ 859
Section 162.3: Basic audio output ............................................................................................................................ 859
Section 162.4: Bare metal sound .............................................................................................................................. 860
Chapter 163: Java Print Service ........................................................................................................................ 862
Section 163.1: Building the Doc that will be printed ................................................................................................ 862
Section 163.2: Discovering the available print services ......................................................................................... 862
Section 163.3: Defining print request attributes ...................................................................................................... 863
Section 163.4: Listening print job request status change ...................................................................................... 863
Section 163.5: Discovering the default print service .............................................................................................. 865
Section 163.6: Creating a print job from a print service ........................................................................................ 865
Chapter 164: CompletableFuture ..................................................................................................................... 867
Section 164.1: Simple Example of CompletableFuture ........................................................................................... 867
Chapter 165: Runtime Commands .................................................................................................................... 868
Section 165.1: Adding shutdown hooks .................................................................................................................... 868
Chapter 166: Unit Testing ...................................................................................................................................... 869
Section 166.1: What is Unit Testing? ......................................................................................................................... 869
Chapter 167: Asserting ........................................................................................................................................... 872
Section 167.1: Checking arithmetic with assert ....................................................................................................... 872
Chapter 168: Multi-Release JAR Files ............................................................................................................. 873
Section 168.1: Example of a multi-release Jar file's contents ............................................................................... 873
Section 168.2: Creating a multi-release Jar using the jar tool .............................................................................. 873
Section 168.3: URL of a loaded class inside a multi-release Jar .......................................................................... 874
Chapter 169: Just in Time (JIT) compiler ...................................................................................................... 876
Section 169.1: Overview ............................................................................................................................................. 876
Chapter 170: Bytecode Modification ............................................................................................................... 878
Section 170.1: What is Bytecode? ............................................................................................................................. 878
Section 170.2: How to edit jar files with ASM .......................................................................................................... 879
Section 170.3: How to load a ClassNode as a Class .............................................................................................. 881
Section 170.4: How to rename classes in a jar file ................................................................................................. 882
Section 170.5: Javassist Basic .................................................................................................................................. 882
Chapter 171: Disassembling and Decompiling ............................................................................................ 884
Section 171.1: Viewing bytecode with javap ............................................................................................................. 884
Chapter 172: JMX ...................................................................................................................................................... 891
Section 172.1: Simple example with Platform MBean Server ................................................................................ 891
Chapter 173: Java Virtual Machine (JVM) .................................................................................................... 895
Section 173.1: These are the basics .......................................................................................................................... 895
Chapter 174: XJC ....................................................................................................................................................... 896
Section 174.1: Generating Java code from simple XSD file ................................................................................... 896
Chapter 175: JVM Flags ......................................................................................................................................... 899
Section 175.1: -XXaggressive .................................................................................................................................... 899
 Section 175.2: -XXallocClearChunks ......................................................................................................................... 899
Section 175.3: -XXallocClearChunkSize .................................................................................................................... 899
Section 175.4: -XXcallProfiling .................................................................................................................................. 899
Section 175.5: -XXdisableFatSpin ............................................................................................................................. 900
Section 175.6: -XXdisableGCHeuristics .................................................................................................................... 900
Section 175.7: -XXdumpSize ...................................................................................................................................... 900
Section 175.8: -XXexitOnOutOfMemory ................................................................................................................... 901
Chapter 176: JVM Tool Interface ...................................................................................................................... 902
Section 176.1: Iterate over objects reachable from object (Heap 1.0) .................................................................. 902
Section 176.2: Get JVMTI environment .................................................................................................................... 904
Section 176.3: Example of initialization inside of Agent_OnLoad method .......................................................... 904
Chapter 177: Java Memory Management .................................................................................................... 906
Section 177.1: Setting the Heap, PermGen and Stack sizes ................................................................................... 906
Section 177.2: Garbage collection ............................................................................................................................ 907
Section 177.3: Memory leaks in Java ....................................................................................................................... 909
Section 177.4: Finalization ......................................................................................................................................... 910
Section 177.5: Manually triggering GC ..................................................................................................................... 911
Chapter 178: Java Performance Tuning ....................................................................................................... 912
Section 178.1: An evidence-based approach to Java performance tuning ........................................................ 912
Section 178.2: Reducing amount of Strings ............................................................................................................ 913
Section 178.3: General approach ............................................................................................................................. 913
Chapter 179: Benchmarks ..................................................................................................................................... 915
Section 179.1: Simple JMH example ......................................................................................................................... 915
Chapter 180: FileUpload to AWS ....................................................................................................................... 918
Section 180.1: Upload file to s3 bucket .................................................................................................................... 918
Chapter 181: AppDynamics and TIBCO BusinessWorks Instrumentation for Easy
Integration ................................................................................................................................................................... 920
Section 181.1: Example of Instrumentation of all BW Applications in a Single Step for Appdynamics ............. 920
Appendix A: Installing Java (Standard Edition) ........................................................................................ 921
Section A.1: Setting %PATH% and %JAVA_HOME% after installing on Windows .............................................. 921
Section A.2: Installing a Java JDK on Linux ........................................................................................................... 922
Section A.3: Installing a Java JDK on macOS ........................................................................................................ 924
Section A.4: Installing a Java JDK or JRE on Windows ........................................................................................ 925
Section A.5: Configuring and switching Java versions on Linux using alternatives .......................................... 926
Section A.6: What do I need for Java Development ............................................................................................. 927
Section A.7: Selecting an appropriate Java SE release ........................................................................................ 927
Section A.8: Java release and version naming ...................................................................................................... 928
Section A.9: Installing Oracle Java on Linux with latest tar file ............................................................................ 928
Section A.10: Post-installation checking and configuration on Linux ................................................................... 929
Appendix B: Java Editions, Versions, Releases and Distributions ................................................... 931
Section B.1: Dierences between Java SE JRE or Java SE JDK distributions .................................................... 931
Section B.2: Java SE Versions .................................................................................................................................. 932
Section B.3: Dierences between Java EE, Java SE, Java ME and JavaFX ....................................................... 933
Appendix C: The Classpath .................................................................................................................................. 935
Section C.1: Dierent ways to specify the classpath ............................................................................................. 935
Section C.2: Adding all JARs in a directory to the classpath ................................................................................ 935
Section C.3: Load a resource from the classpath .................................................................................................. 936
Section C.4: Classpath path syntax ......................................................................................................................... 936
Section C.5: Dynamic Classpath .............................................................................................................................. 937
 Section C.6: Mapping classnames to pathnames .................................................................................................. 937
Section C.7: The bootstrap classpath ..................................................................................................................... 937
Section C.8: What the classpath means: how searches work .............................................................................. 938
Appendix D: Resources (on classpath) .......................................................................................................... 939
Section D.1: Loading default configuration ............................................................................................................ 939
Section D.2: Loading an image from a resource ................................................................................................... 939
Section D.3: Finding and reading resources using a classloader ........................................................................ 939
Section D.4: Loading same-name resource from multiple JARs ......................................................................... 941
Credits ............................................................................................................................................................................ 942
You may also like ...................................................................................................................................................... 956
About

Please feel free to share this PDF with anyone for free,
latest version of this book can be downloaded from:
http://GoalKicker.com/JavaBook

This Java® Notes for Professionals book is compiled from Stack Overflow
Documentation, the content is written by the beautiful people at Stack Overflow.
Text content is released under Creative Commons BY-SA, see credits at the end
of this book whom contributed to the various chapters. Images may be copyright
of their respective owners unless otherwise specified

This is an unofficial free book created for educational purposes and is not
affiliated with official Java® group(s) or company(s) nor Stack Overflow. All
trademarks and registered trademarks are the property of their respective
company owners

The information presented in this book is not guaranteed to be correct nor

accurate, use at your own risk

Please send feedback and corrections to [email protected]

Java® Notes for Professionals 1

Chapter 1: Getting started with Java
Language
Java SE Version Code Name End-of-life (free1) Release Date
Java SE 9 (Early Access) None future 2017-07-27
Java SE 8 Spider future 2014-03-18
Java SE 7 Dolphin 2015-04-14 2011-07-28
Java SE 6 Mustang 2013-04-16 2006-12-23
Java SE 5 Tiger 2009-11-04 2004-10-04
Java SE 1.4 Merlin prior to 2009-11-04 2002-02-06
Java SE 1.3 Kestrel prior to 2009-11-04 2000-05-08
Java SE 1.2 Playground prior to 2009-11-04 1998-12-08
Java SE 1.1 None prior to 2009-11-04 1997-02-19
Java SE 1.0 Oak prior to 2009-11-04 1996-01-21

Section 1.1: Creating Your First Java Program

Create a new file in your text editor or IDE named HelloWorld.java. Then paste this code block into the file and
save:

public class HelloWorld {

public static void main(String[] args) {
System.out.println("Hello, World!");
}
}

Run live on Ideone

Note: For Java to recognize this as a public class (and not throw a compile time error), the filename must be the
same as the class name (HelloWorld in this example) with a .java extension. There should also be a public access
modifier before it.

Naming conventions recommend that Java classes begin with an uppercase character, and be in camel case format
(in which the first letter of each word is capitalized). The conventions recommend against underscores (_) and dollar
signs ($).

To compile, open a terminal window and navigate to the directory of HelloWorld.java:

cd /path/to/containing/folder/

Note: cd is the terminal command to change directory.

Enter javac followed by the file name and extension as follows:

$ javac HelloWorld.java

It's fairly common to get the error 'javac' is not recognized as an internal or external command, operable
program or batch file. even when you have installed the JDK and are able to run the program from IDE ex.
eclipse etc. Since the path is not added to the environment by default.

In case you get this on windows, to resolve, first try browsing to your javac.exe path, it's most probably in your
C:\Program Files\Java\jdk(version number)\bin. Then try running it with below.

Java® Notes for Professionals 2

$ C:\Program Files\Java\jdk(version number)\bin\javac HelloWorld.java

Previously when we were calling javac it was same as above command. Only in that case your OS knew where
javac resided. So let's tell it now, this way you don't have to type the whole path every-time. We would need to add
this to our PATH

To edit the PATH environment variable in Windows XP/Vista/7/8/10:

Control Panel ⇒ System ⇒ Advanced system settings

Switch to "Advanced" tab ⇒ Environment Variables
In "System Variables", scroll down to select "PATH" ⇒ Edit

You cannot undo this so be careful. First copy your existing path to notepad. Then to get the exact PATH to your
javac browse manually to the folder where javac resides and click on the address bar and then copy it. It should
look something like c:\Program Files\Java\jdk1.8.0_xx\bin

In "Variable value" field, paste this IN FRONT of all the existing directories, followed by a semi-colon (;). DO NOT
DELETE any existing entries.

Variable name : PATH

Variable value : c:\Program Files\Java\jdk1.8.0_xx\bin;[Existing Entries...]

Now this should resolve.

For Linux Based systems try here.

Note: The javac command invokes the Java compiler.

The compiler will then generate a bytecode file called HelloWorld.class which can be executed in the Java Virtual
Machine (JVM). The Java programming language compiler, javac, reads source files written in the Java programming
language and compiles them into bytecode class files. Optionally, the compiler can also process annotations found
in source and class files using the Pluggable Annotation Processing API. The compiler is a command line tool but
can also be invoked using the Java Compiler API.

To run your program, enter java followed by the name of the class which contains the main method (HelloWorld in
our example). Note how the .class is omitted:

$ java HelloWorld

Note: The java command runs a Java application.

This will output to your console:

Hello, World!

You have successfully coded and built your very first Java program!

Note: In order for Java commands (java, javac, etc) to be recognized, you will need to make sure:

A JDK is installed (e.g. Oracle, OpenJDK and other sources)

Your environment variables are properly set up

You will need to use a compiler (javac) and an executor (java) provided by your JVM. To find out which versions you

Java® Notes for Professionals 3

have installed, enter java -version and javac -version on the command line. The version number of your
program will be printed in the terminal (e.g. 1.8.0_73).

A closer look at the Hello World program

The "Hello World" program contains a single file, which consists of a HelloWorld class definition, a main method,
and a statement inside the main method.

public class HelloWorld {

The class keyword begins the class definition for a class named HelloWorld. Every Java application contains at least
one class definition (Further information about classes).

public static void main(String[] args) {

This is an entry point method (defined by its name and signature of public static void main(String[])) from
which the JVM can run your program. Every Java program should have one. It is:

public: meaning that the method can be called from anywhere mean from outside the program as well. See
Visibility for more information on this.
static: meaning it exists and can be run by itself (at the class level without creating an object).
void: meaning it returns no value. Note: This is unlike C and C++ where a return code such as int is expected
(Java's way is System.exit()).

This main method accepts:

An array (typically called args) of Strings passed as arguments to main function (e.g. from command line
arguments).

Almost all of this is required for a Java entry point method.

Non-required parts:

The name args is a variable name, so it can be called anything you want, although it is typically called args.
Whether its parameter type is an array (String[] args) or Varargs (String... args) does not matter
because arrays can be passed into varargs.

Note: A single application may have multiple classes containing an entry point (main) method. The entry point of the
application is determined by the class name passed as an argument to the java command.

Inside the main method, we see the following statement:

System.out.println("Hello, World!");

Let's break down this statement element-by-element:

Element Purpose
this denotes that the subsequent expression will call upon the System class, from the java.lang
System
package.
this is a "dot operator". Dot operators provide you access to a classes members1; i.e. its fields
. (variables) and its methods. In this case, this dot operator allows you to reference the out static field
within the System class.
this is the name of the static field of PrintStream type within the System class containing the standard
out
output functionality.

Java® Notes for Professionals 4

 this is another dot operator. This dot operator provides access to the println method within the out
.
variable.
this is the name of a method within the PrintStream class. This method in particular prints the
println
contents of the parameters into the console and inserts a newline after.
this parenthesis indicates that a method is being accessed (and not a field) and begins the
(
parameters being passed into the println method.
"Hello, this is the String literal that is passed as a parameter, into the println method. The double quotation
World!" marks on each end delimit the text as a String.
) this parenthesis signifies the closure of the parameters being passed into the println method.
; this semicolon marks the end of the statement.

Note: Each statement in Java must end with a semicolon (;).

The method body and class body are then closed.

} // end of main function scope

} // end of class HelloWorld scope

Here's another example demonstrating the OO paradigm. Let's model a football team with one (yes, one!) member.
There can be more, but we'll discuss that when we get to arrays.

First, let's define our Team class:

public class Team {

Member member;
public Team(Member member) { // who is in this Team?
this.member = member; // one 'member' is in this Team!
}
}

Now, let's define our Member class:

class Member {
private String name;
private String type;
private int level; // note the data type here
private int rank; // note the data type here as well

public Member(String name, String type, int level, int rank) {

this.name = name;
this.type = type;
this.level = level;
this.rank = rank;
}
}

Why do we use private here? Well, if someone wanted to know your name, they should ask you directly, instead of
reaching into your pocket and pulling out your Social Security card. This private does something like that: it
prevents outside entities from accessing your variables. You can only return private members through getter
functions (shown below).

After putting it all together, and adding the getters and main method as discussed before, we have:

public class Team {

Member member;
public Team(Member member) {
this.member = member;
}

Java® Notes for Professionals 5

 // here's our main method
public static void main(String[] args) {
Member myMember = new Member("Aurieel", "light", 10, 1);
Team myTeam = new Team(myMember);
System.out.println(myTeam.member.getName());
System.out.println(myTeam.member.getType());
System.out.println(myTeam.member.getLevel());
System.out.println(myTeam.member.getRank());
}
}

class Member {
private String name;
private String type;
private int level;
private int rank;

public Member(String name, String type, int level, int rank) {

this.name = name;
this.type = type;
this.level = level;
this.rank = rank;
}

/* let's define our getter functions here */

public String getName() { // what is your name?
return this.name; // my name is ...
}

public String getType() { // what is your type?

return this.type; // my type is ...
}

public int getLevel() { // what is your level?

return this.level; // my level is ...
}

public int getRank() { // what is your rank?

return this.rank; // my rank is
}
}

Output:

Aurieel
light
10
1

Run on ideone

Once again, the main method inside the Test class is the entry point to our program. Without the main method, we
cannot tell the Java Virtual Machine (JVM) from where to begin execution of the program.

1 - Because the HelloWorld class has little relation to the System class, it can only access public data.

Java® Notes for Professionals 6

Chapter 2: Type Conversion
Section 2.1: Numeric primitive casting
Numeric primitives can be cast in two ways. Implicit casting happens when the source type has smaller range than
the target type.

//Implicit casting
byte byteVar = 42;
short shortVar = byteVar;
int intVar = shortVar;
long longVar = intvar;
float floatVar = longVar;
double doubleVar = floatVar;

Explicit casting has to be done when the source type has larger range than the target type.

//Explicit casting
double doubleVar = 42.0d;
float floatVar = (float) doubleVar;
long longVar = (long) floatVar;
int intVar = (int) longVar;
short shortVar = (short) intVar;
byte byteVar = (byte) shortVar;

When casting floating point primitives (float, double) to whole number primitives, the number is rounded down.

Section 2.2: Basic Numeric Promotion

static void testNumericPromotion() {

char char1 = 1, char2 = 2;

short short1 = 1, short2 = 2;
int int1 = 1, int2 = 2;
float float1 = 1.0f, float2 = 2.0f;

// char1 = char1 + char2; // Error: Cannot convert from int to char;

// short1 = short1 + short2; // Error: Cannot convert from int to short;
int1 = char1 + char2; // char is promoted to int.
int1 = short1 + short2; // short is promoted to int.
int1 = char1 + short2; // both char and short promoted to int.
float1 = short1 + float2; // short is promoted to float.
int1 = int1 + int2; // int is unchanged.
}

Section 2.3: Non-numeric primitive casting

The boolean type cannot be cast to/from any other primitive type.

A char can be cast to/from any numeric type by using the code-point mappings specified by Unicode. A char is
represented in memory as an unsigned 16-bit integer value (2 bytes), so casting to byte (1 byte) will drop 8 of those
bits (this is safe for ASCII characters). The utility methods of the Character class use int (4 bytes) to transfer
to/from code-point values, but a short (2 bytes) would also suffice for storing a Unicode code-point.

int badInt = (int) true; // Compiler error: incompatible types

Java® Notes for Professionals 7

char char1 = (char) 65; // A
byte byte1 = (byte) 'A'; // 65
short short1 = (short) 'A'; // 65
int int1 = (int) 'A'; // 65

char char2 = (char) 8253; // ‽

byte byte2 = (byte) '‽'; // 61 (truncated code-point into the ASCII range)
short short2 = (short) '‽'; // 8253
int int2 = (int) '‽'; // 8253

Section 2.4: Object casting

As with primitives, objects can be cast both explicitly and implicitly.

Implicit casting happens when the source type extends or implements the target type (casting to a superclass or
interface).

Explicit casting has to be done when the source type is extended or implemented by the target type (casting to a
subtype). This can produce a runtime exception (ClassCastException) when the object being cast is not of the
target type (or the target's subtype).

Float floatVar = new Float(42.0f);

Number n = floatVar; //Implicit (Float implements Number)
Float floatVar2 = (Float) n; //Explicit
Double doubleVar = (Double) n; //Throws exception (the object is not Double)

Section 2.5: Testing if an object can be cast using instanceof

Java provides the instanceof operator to test if an object is of a certain type, or a subclass of that type. The
program can then choose to cast or not cast that object accordingly.

Object obj = Calendar.getInstance();

long time = 0;

if(obj instanceof Calendar)

{
time = ((Calendar)obj).getTime();
}
if(obj instanceof Date)
{
time = ((Date)obj).getTime(); // This line will never be reached, obj is not a Date type.
}

Java® Notes for Professionals 8

Chapter 3: Getters and Setters
This article discusses getters and setters; the standard way to provide access to data in Java classes.

Section 3.1: Using a setter or getter to implement a constraint

Setters and Getters allow for an object to contain private variables which can be accessed and changed with
restrictions. For example,

public class Person {

private String name;

public String getName() {

return name;
}

public void setName(String name) {

if(name!=null && name.length()>2)
this.name = name;
}
}

In this Person class, there is a single variable: name. This variable can be accessed using the getName() method and
changed using the setName(String) method, however, setting a name requires the new name to have a length
greater than 2 characters and to not be null. Using a setter method rather than making the variable name public
allows others to set the value of name with certain restrictions. The same can be applied to the getter method:

public String getName(){

if(name.length()>16)
return "Name is too large!";
else
return name;
}

In the modified getName() method above, the name is returned only if its length is less than or equal to 16.
Otherwise, "Name is too large" is returned. This allows the programmer to create variables that are reachable
and modifiable however they wish, preventing client classes from editing the variables unwantedly.

Section 3.2: Why Use Getters and Setters?

Consider a basic class containing an object with getters and setters in Java:

public class CountHolder {

private int count = 0;

public int getCount() { return count; }

public void setCount(int c) { count = c; }
}

We can't access the count variable because it's private. But we can access the getCount() and the setCount(int)
methods because they are public. To some, this might raise the question; why introduce the middleman? Why not
just simply make they count public?

public class CountHolder {

Java® Notes for Professionals 9

 public int count = 0;
}

For all intents and purposes, these two are exactly the same, functionality-wise. The difference between them is the
extensibility. Consider what each class says:

First: "I have a method that will give you an int value, and a method that will set that value to another int".
Second: "I have an int that you can set and get as you please."

These might sound similar, but the first is actually much more guarded in its nature; it only lets you interact with its
internal nature as it dictates. This leaves the ball in its court; it gets to choose how the internal interactions occur.
The second has exposed its internal implementation externally, and is now not only prone to external users, but, in
the case of an API, committed to maintaining that implementation (or otherwise releasing a non-backward-
compatible API).

Lets consider if we want to synchronize access to modifying and accessing the count. In the first, this is simple:

public class CountHolder {

private int count = 0;

public synchronized int getCount() { return count; }

public synchronized void setCount(int c) { count = c; }
}

but in the second example, this is now nearly impossible without going through and modifying each place where
the count variable is referenced. Worse still, if this is an item that you're providing in a library to be consumed by
others, you do not have a way of performing that modification, and are forced to make the hard choice mentioned
above.

So it begs the question; are public variables ever a good thing (or, at least, not evil)?

I'm unsure. On one hand, you can see examples of public variables that have stood the test of time (IE: the out
variable referenced in System.out). On the other, providing a public variable gives no benefit outside of extremely
minimal overhead and potential reduction in wordiness. My guideline here would be that, if you're planning on
making a variable public, you should judge it against these criteria with extreme prejudice:

1. The variable should have no conceivable reason to ever change in its implementation. This is something
that's extremely easy to screw up (and, even if you do get it right, requirements can change), which is why
getters/setters are the common approach. If you're going to have a public variable, this really needs to be
thought through, especially if released in a library/framework/API.
2. The variable needs to be referenced frequently enough that the minimal gains from reducing verbosity
warrants it. I don't even think the overhead for using a method versus directly referencing should be
considered here. It's far too negligible for what I'd conservatively estimate to be 99.9% of applications.

There's probably more than I haven't considered off the top of my head. If you're ever in doubt, always use
getters/setters.

Section 3.3: Adding Getters and Setters

Encapsulation is a basic concept in OOP. It is about wrapping data and code as a single unit. In this case, it is a good
practice to declare the variables as private and then access them through Getters and Setters to view and/or
modify them.

public class Sample {

Java® Notes for Professionals 10

 private String name;
private int age;

public int getAge() {

return age;
}

public void setAge(int age) {

this.age = age;
}

public String getName() {

return name;
}

public void setName(String name) {

this.name = name;
}
}

These private variables cannot be accessed directly from outside the class. Hence they are protected from
unauthorized access. But if you want to view or modify them, you can use Getters and Setters.

getXxx() method will return the current value of the variable xxx, while you can set the value of the variable xxx
using setXxx().

The naming convention of the methods are (in example variable is called variableName):

All non boolean variables

getVariableName() //Getter, The variable name should start with uppercase

setVariableName(..) //Setter, The variable name should start with uppercase

boolean variables

isVariableName() //Getter, The variable name should start with uppercase

setVariableName(...) //Setter, The variable name should start with uppercase

Public Getters and Setters are part of the Property definition of a Java Bean.

Java® Notes for Professionals 11

Chapter 4: Reference Data Types
Section 4.1: Dereferencing
Dereferencing happens with the . operator:

Object obj = new Object();

String text = obj.toString(); // 'obj' is dereferenced.

Dereferencing follows the memory address stored in a reference, to the place in memory where the actual object
resides. When an object has been found, the requested method is called (toString in this case).

When a reference has the value null, dereferencing results in a NullPointerException:

Object obj = null;

obj.toString(); // Throws a NullpointerException when this statement is executed.

null indicates the absence of a value, i.e. following the memory address leads nowhere. So there is no object on
which the requested method can be called.

Section 4.2: Instantiating a reference type

Object obj = new Object(); // Note the 'new' keyword

Where:

Object is a reference type.

obj is the variable in which to store the new reference.
Object() is the call to a constructor of Object.

What happens:

Space in memory is allocated for the object.

The constructor Object() is called to initialize that memory space.
The memory address is stored in obj, so that it references the newly created object.

This is different from primitives:

int i = 10;

Where the actual value 10 is stored in i.

Java® Notes for Professionals 12

Chapter 5: Java Compiler - 'javac'
Section 5.1: The 'javac' command - getting started
Simple example

Assuming that the "HelloWorld.java" contains the following Java source:

public class HelloWorld {

public static void main(String[] args) {
System.out.println("Hello world!");
}
}

(For an explanation of the above code, please refer to Getting started with Java Language .)

We can compile the above file using this command:

$ javac HelloWorld.java

This produces a file called "HelloWorld.class", which we can then run as follows:

$ java HelloWorld
Hello world!

The key points to note from this example are:

1. The source filename "HelloWorld.java" must match the class name in the source file ... which is HelloWorld. If
they don't match, you will get a compilation error.
2. The bytecode filename "HelloWorld.class" corresponds to the classname. If you were to rename the
"HelloWorld.class", you would get an error when your tried to run it.
3. When running a Java application using java, you supply the classname NOT the bytecode filename.

Example with packages

Most practical Java code uses packages to organize the namespace for classes and reduce the risk of accidental
class name collision.

If we wanted to declare the HelloWorld class in a package call com.example, the "HelloWorld.java" would contain
the following Java source:

package com.example;

public class HelloWorld {

public static void main(String[] args) {
System.out.println("Hello world!");
}
}

This source code file needs to stored in a directory tree whose structure corresponds to the package naming.

. # the current directory (for this example)

|
----com
|

Java® Notes for Professionals 13

 ----example
|
----HelloWorld.java

We can compile the above file using this command:

$ javac com/example/HelloWorld.java

This produces a file called "com/example/HelloWorld.class"; i.e. after compilation, the file structure should look like
this:

. # the current directory (for this example)

|
----com
|
----example
|
----HelloWorld.java
----HelloWorld.class

We can then run the application as follows:

$ java com.example.HelloWorld
Hello world!

Additional points to note from this example are:

1. The directory structure must match the package name structure.

2. When you run the class, the full class name must be supplied; i.e. "com.example.HelloWorld" not
"HelloWorld".
3. You don't have to compile and run Java code out of the current directory. We are just doing it here for
illustration.

Compiling multiple files at once with 'javac'.

If your application consists of multiple source code files (and most do!) you can compile them one at a time.
Alternatively, you can compile multiple files at the same time by listing the pathnames:

$ javac Foo.java Bar.java

or using your command shell's filename wildcard functionality ....

$ javac *.java
$ javac com/example/*.java
$ javac */**/*.java #Only works on Zsh or with globstar enabled on your shell

This will compile all Java source files in the current directory, in the "com/example" directory, and recursively in
child directories respectively. A third alternative is to supply a list of source filenames (and compiler options) as a
file. For example:

$ javac @sourcefiles

where the sourcefiles file contains:

Foo.java
Bar.java

Java® Notes for Professionals 14

com/example/HelloWorld.java

Note: compiling code like this is appropriate for small one-person projects, and for once-off programs. Beyond that,
it is advisable to select and use a Java build tool. Alternatively, most programmers use a Java IDE (e.g. NetBeans,
eclipse, IntelliJ IDEA) which offers an embedded compiler and incremental building of "projects".

Commonly used 'javac' options

Here are a few options for the javac command that are likely to be useful to you

The -d option sets a destination directory for writing the ".class" files.
The -sourcepath option sets a source code search path.
The -cp or -classpath option sets the search path for finding external and previously compiled classes. For
more information on the classpath and how to specify it, refer to the The Classpath Topic.
The -version option prints the compiler's version information.

A more complete list of compiler options will be described in a separate example.

References

The definitive reference for the javac command is the Oracle manual page for javac.

Section 5.2: Compiling for a dierent version of Java

The Java programming language (and its runtime) has undergone numerous changes since its release since its
initial public release. These changes include:

Changes in the Java programming language syntax and semantics

Changes in the APIs provided by the Java standard class libraries.
Changes in the Java (bytecode) instruction set and classfile format.

With very few exceptions (for example the enum keyword, changes to some "internal" classes, etc), these changes
are backwards compatible.

A Java program that was compiled using an older version of the Java toolchain will run on a newer version
Java platform without recompilation.
A Java program that was written in an older version of Java will compile successfully with a new Java compiler.

Compiling old Java with a newer compiler

If you need to (re-)compile older Java code on a newer Java platform to run on the newer platform, you generally
don't need to give any special compilation flags. In a few cases (e.g. if you had used enum as an identifier) you could
use the -source option to disable the new syntax. For example, given the following class:

public class OldSyntax {

private static int enum; // invalid in Java 5 or later
}

the following is required to compile the class using a Java 5 compiler (or later):

$ javac -source 1.4 OldSyntax.java

Compiling for an older execution platform

If you need to compile Java to run on an older Java platforms, the simplest approach is to install a JDK for the oldest
version you need to support, and use that JDK's compiler in your builds.

Java® Notes for Professionals 15

You can also compile with a newer Java compiler, but there are complicated. First of all, there some important
preconditions that must be satisfied:

The code you are compiling must not use Java language constructs that were not available in the version of
Java that you are targeting.
The code must not depend on standard Java classes, fields, methods and so on that were not available in the
older platforms.
Third party libraries that the code depends must also be built for the older platform and available at compile-
time and run-time.

Given the preconditions are met, you can recompile code for an older platform using the -target option. For
example,

$ javac -target 1.4 SomeClass.java

will compile the above class to produce bytecodes that are compatible with Java 1.4 or later JVM. (In fact, the -
source option implies a compatible -target, so javac -source 1.4 ... would have the same effect. The
relationship between -source and -target is described in the Oracle documentation.)

Having said that, if you simply use -target or -source, you will still be compiling against the standard class libraries
provided by the compiler's JDK. If you are not careful, you can end up with classes with the correct bytecode
version, but with dependencies on APIs that are not available. The solution is to use the -bootclasspath option. For
example:

$ javac -target 1.4 --bootclasspath path/to/java1.4/rt.jar SomeClass.java

will compile against an alternative set of runtime libraries. If the class being compiled has (accidental) dependencies
on newer libraries, this will give you compilation errors.

Java® Notes for Professionals 16

Chapter 6: Documenting Java Code
Documentation for java code is often generated using javadoc. Javadoc was created by Sun Microsystems for the
purpose of generating API documentation in HTML format from java source code. Using the HTML format gives the
convenience of being able to hyperlink related documents together.

Section 6.1: Building Javadocs From the Command Line

Many IDEs provide support for generating HTML from Javadocs automatically; some build tools (Maven and Gradle,
for example) also have plugins that can handle the HTML creation.

However, these tools are not required to generate the Javadoc HTML; this can be done using the command line
javadoc tool.

The most basic usage of the tool is:

javadoc JavaFile.java

Which will generate HTML from the Javadoc comments in JavaFile.java.

A more practical use of the command line tool, which will recursively read all java files in [source-directory],
create documentation for [package.name] and all sub-packages, and place the generated HTML in the [docs-
directory] is:

javadoc -d [docs-directory] -subpackages -sourcepath [source-directory] [package.name]

Section 6.2: Class Documentation

All Javadoc comments begin with a block comment followed by an asterisk (/**) and end when the block comment
does (*/). Optionally, each line can begin with arbitrary whitespace and a single asterisk; these are ignored when
the documentation files are generated.

/**
* Brief summary of this class, ending with a period.
*
* It is common to leave a blank line between the summary and further details.
* The summary (everything before the first period) is used in the class or package
* overview section.
*
* The following inline tags can be used (not an exhaustive list):
* {@link some.other.class.Documentation} for linking to other docs or symbols
* {@link some.other.class.Documentation Some Display Name} the link's appearance can be
* customized by adding a display name after the doc or symbol locator
* {@code code goes here} for formatting as code
* {@literal <>[]()foo} for interpreting literal text without converting to HTML markup
* or other tags.
*
* Optionally, the following tags may be used at the end of class documentation
* (not an exhaustive list):
*
* @author John Doe
* @version 1.0
* @since 5/10/15
* @see some.other.class.Documentation
* @deprecated This class has been replaced by some.other.package.BetterFileReader
*

Java® Notes for Professionals 17

 * You can also have custom tags for displaying additional information.
* Using the @custom.<NAME> tag and the -tag custom.<NAME>:htmltag:"context"
* command line option, you can create a custom tag.
*
* Example custom tag and generation:
* @custom.updated 2.0
* Javadoc flag: -tag custom.updated:a:"Updated in version:"
* The above flag will display the value of @custom.updated under "Updated in version:"
*
*/
public class FileReader {
}

The same tags and format used for Classes can be used for Enums and Interfaces as well.

Section 6.3: Method Documentation

All Javadoc comments begin with a block comment followed by an asterisk (/**) and end when the block comment
does (*/). Optionally, each line can begin with arbitrary whitespace and a single asterisk; these are ignored when
the documentation files are generated.

/**
* Brief summary of method, ending with a period.
*
* Further description of method and what it does, including as much detail as is
* appropriate. Inline tags such as
* {@code code here}, {@link some.other.Docs}, and {@literal text here} can be used.
*
* If a method overrides a superclass method, {@inheritDoc} can be used to copy the
* documentation
* from the superclass method
*
* @param stream Describe this parameter. Include as much detail as is appropriate
* Parameter docs are commonly aligned as here, but this is optional.
* As with other docs, the documentation before the first period is
* used as a summary.
*
* @return Describe the return values. Include as much detail as is appropriate
* Return type docs are commonly aligned as here, but this is optional.
* As with other docs, the documentation before the first period is used as a
* summary.
*
* @throws IOException Describe when and why this exception can be thrown.
* Exception docs are commonly aligned as here, but this is
* optional.
* As with other docs, the documentation before the first period
* is used as a summary.
* Instead of @throws, @exception can also be used.
*
* @since 2.1.0
* @see some.other.class.Documentation
* @deprecated Describe why this method is outdated. A replacement can also be specified.
*/
public String[] read(InputStream stream) throws IOException {
return null;
}

Java® Notes for Professionals 18

Section 6.4: Package Documentation
Version ≥ Java SE 5

It is possible to create package-level documentation in Javadocs using a file called package-info.java. This file
must be formatted as below. Leading whitespace and asterisks optional, typically present in each line for formatting
reason

/**
* Package documentation goes here; any documentation before the first period will
* be used as a summary.
*
* It is common practice to leave a blank line between the summary and the rest
* of the documentation; use this space to describe the package in as much detail
* as is appropriate.
*
* Inline tags such as {@code code here}, {@link reference.to.other.Documentation},
* and {@literal text here} can be used in this documentation.
*/
package com.example.foo;

// The rest of the file must be empty.

In the above case, you must put this file package-info.java inside the folder of the Java package com.example.foo.

Section 6.5: Links

Linking to other Javadocs is done with the @link tag:

/**
* You can link to the javadoc of an already imported class using {@link ClassName}.
*
* You can also use the fully-qualified name, if the class is not already imported:
* {@link some.other.ClassName}
*
* You can link to members (fields or methods) of a class like so:
* {@link ClassName#someMethod()}
* {@link ClassName#someMethodWithParameters(int, String)}
* {@link ClassName#someField}
* {@link #someMethodInThisClass()} - used to link to members in the current class
*
* You can add a label to a linked javadoc like so:
* {@link ClassName#someMethod() link text}
*/

Java® Notes for Professionals 19

With the @see tag you can add elements to the See also section. Like @param or @return the place where they appear
is not relevant. The spec says you should write it after @return.

/**
* This method has a nice explanation but you might found further
* information at the bottom.
*
* @see ClassName#someMethod()
*/

If you want to add links to external resources you can just use the HTML <a> tag. You can use it inline anywhere
or inside both @link and @see tags.

/**
* Wondering how this works? You might want
* to check this <a href="http://stackoverflow.com/">great service</a>.
*
* @see <a href="http://stackoverflow.com/">Stack Overflow</a>
*/

Section 6.6: Code snippets inside documentation

The canonical way of writing code inside documentation is with the {@code } construct. If you have multiline code
wrap inside <pre></pre>.

/**
* The Class TestUtils.
* <p>
* This is an {@code inline("code example")}.
* <p>
* You should wrap it in pre tags when writing multiline code.
* <pre>{@code
* Example example1 = new FirstLineExample();
* example1.butYouCanHaveMoreThanOneLine();
* }</pre>
* <p>
* Thanks for reading.
*/
class TestUtils {

Sometimes you may need to put some complex code inside the javadoc comment. The @ sign is specially
problematic. The use of the old <code> tag alongside the {@literal } construct solves the problem.

/**
* Usage:
* <pre><code>
* class SomethingTest {
* {@literal @}Rule

Java® Notes for Professionals 20

 * public SingleTestRule singleTestRule = new SingleTestRule("test1");
*
* {@literal @}Test
* public void test1() {
* // only this test will be executed
* }
*
* ...
* }
* </code></pre>
*/
class SingleTestRule implements TestRule { }

Section 6.7: Field Documentation

All Javadoc comments begin with a block comment followed by an asterisk (/**) and end when the block comment
does (*/). Optionally, each line can begin with arbitrary whitespace and a single asterisk; these are ignored when
the documentation files are generated.

/**
* Fields can be documented as well.
*
* As with other javadocs, the documentation before the first period is used as a
* summary, and is usually separated from the rest of the documentation by a blank
* line.
*
* Documentation for fields can use inline tags, such as:
* {@code code here}
* {@literal text here}
* {@link other.docs.Here}
*
* Field documentation can also make use of the following tags:
*
* @since 2.1.0
* @see some.other.class.Documentation
* @deprecated Describe why this field is outdated
*/
public static final String CONSTANT_STRING = "foo";

Section 6.8: Inline Code Documentation

Apart from the Javadoc documentation code can be documented inline.

Single Line comments are started by // and may be positioned after a statement on the same line, but not before.

public void method() {

//single line comment

someMethodCall(); //single line comment after statement

Multi-Line comments are defined between /* and */. They can span multiple lines and may even been positioned
between statements.

public void method(Object object) {

/*

Java® Notes for Professionals 21

 multi
line
comment
*/
object/*inner-line-comment*/.method();
}

JavaDocs are a special form of multi-line comments, starting with /**.

As too many inline comments may decrease readability of code, they should be used sparsely in case the code isn't
self-explanatory enough or the design decision isn't obvious.

An additional use case for single-line comments is the use of TAGs, which are short, convention driven keywords.
Some development environments recognize certain conventions for such single-comments. Common examples are

//TODO
//FIXME

Or issue references, i.e. for Jira

//PRJ-1234

Java® Notes for Professionals 22

Chapter 7: Command line Argument
Processing
Parameter Details
The command line arguments. Assuming that the main method is invoked by the Java launcher, args
args
will be non-null, and will have no null elements.

Section 7.1: Argument processing using GWT ToolBase

If you want to parse more complex command-line arguments, e.g. with optional parameters, than the best is to use
google's GWT approach. All classes are public available at:

https://gwt.googlesource.com/gwt/+/2.8.0-beta1/dev/core/src/com/google/gwt/util/tools/ToolBase.java

An example for handling the command-line myprogram -dir "~/Documents" -port 8888 is:

public class MyProgramHandler extends ToolBase {

protected File dir;
protected int port;
// getters for dir and port
...

public MyProgramHandler() {
this.registerHandler(new ArgHandlerDir() {
@Override
public void setDir(File dir) {
this.dir = dir;
}
});
this.registerHandler(new ArgHandlerInt() {
@Override
public String[] getTagArgs() {
return new String[]{"port"};
}
@Override
public void setInt(int value) {
this.port = value;
}
});
}
public static void main(String[] args) {
MyProgramHandler myShell = new MyProgramHandler();
if (myShell.processArgs(args)) {
// main program operation
System.out.println(String.format("port: %d; dir: %s",
myShell.getPort(), myShell.getDir()));
}
System.exit(1);
}
}

ArgHandler also has a method isRequired() which can be overwritten to say that the command-line argument is
required (default return is false so that the argument is optional.

Section 7.2: Processing arguments by hand

When the command-line syntax for an application is simple, it is reasonable to do the command argument

Java® Notes for Professionals 23

processing entirely in custom code.

In this example, we will present a series of simple case studies. In each case, the code will produce error messages
if the arguments are unacceptable, and then call System.exit(1) to tell the shell that the command has failed. (We
will assume in each case that the Java code is invoked using a wrapper whose name is "myapp".)

A command with no arguments

In this case-study, the command requires no arguments. The code illustrates that args.length gives us the number
of command line arguments.

public class Main {

public static void main(String[] args) {
if (args.length > 0) {
System.err.println("usage: myapp");
System.exit(1);
}
// Run the application
System.out.println("It worked");
}
}

A command with two arguments

In this case-study, the command requires at precisely two arguments.

public class Main {

public static void main(String[] args) {
if (args.length != 2) {
System.err.println("usage: myapp <arg1> <arg2>");
System.exit(1);
}
// Run the application
System.out.println("It worked: " + args[0] + ", " + args[1]);
}
}

Note that if we neglected to check args.length, the command would crash if the user ran it with too few
command-line arguments.

A command with "flag" options and at least one argument

In this case-study, the command has a couple of (optional) flag options, and requires at least one argument after
the options.

package tommy;
public class Main {
public static void main(String[] args) {
boolean feelMe = false;
boolean seeMe = false;
int index;
loop: for (index = 0; index < args.length; index++) {
String opt = args[index];
switch (opt) {
case "-c":
seeMe = true;
break;
case "-f":
feelMe = true;

Java® Notes for Professionals 24

 break;
default:
if (!opts.isEmpty() && opts.charAt(0) == '-') {
error("Unknown option: '" + opt + "'");
}
break loop;
}
}
if (index >= args.length) {
error("Missing argument(s)");
}

// Run the application

// ...
}

private static void error(String message) {

if (message != null) {
System.err.println(message);
}
System.err.println("usage: myapp [-f] [-c] [ <arg> ...]");
System.exit(1);
}
}

As you can see, processing the arguments and options gets rather cumbersome if the command syntax is
complicated. It is advisable to use a "command line parsing" library; see the other examples.

Java® Notes for Professionals 25

Chapter 8: The Java Command - 'java' and
'javaw'
Section 8.1: Entry point classes
A Java entry-point class has a main method with the following signature and modifiers:

public static void main(String[] args)

Sidenote: because of how arrays work, it can also be (String args[])

When the java command starts the virtual machine, it loads the specified entry-point classes and tries to find main.
If successful, the arguments from command line are converted to Java String objects and assembled into an array.
If main is invoked like this, the array will not be null and won't contain any null entries.

A valid entry-point class method must do the following:

Be named main (case-sensitive)

Be public and static
Have a void return type
Have a single argument with an array String[]. The argument must be present and no more than one
argument is allowed.
Be generic: type parameters are not allowed.
Have a non-generic, top-level (not nested or inner) enclosing class

It is conventional to declare the class as public but this not strictly necessary. From Java 5 onward, the main
method's argument type may be a String varargs instead of a string array. main can optionally throw exceptions,
and its parameter can be named anything, but conventionally it is args.

JavaFX entry-points

From Java 8 onwards the java command can also directly launch a JavaFX application. JavaFX is documented in the
JavaFX tag, but a JavaFX entry-point must do the following:

Extend javafx.application.Application
Be public and not abstract
Not be generic or nested
Have an explicit or implicit public no-args constructor

Section 8.2: Troubleshooting the 'java' command

This example covers common errors with using the 'java' command.

"Command not found"

If you get an error message like:

java: command not found

when trying to run the java command, this means that there is no java command on your shell's command search
path. The cause could be:

Java® Notes for Professionals 26

 you don't have a Java JRE or JDK installed at all,
you have not updated the PATH environment variable (correctly) in your shell initialization file, or
you have not "sourced" the relevant initialization file in the current shell.

Refer to "Installing Java" for the steps that you need to take.

"Could not find or load main class"

This error message is output by the java command if it has been unable to find / load the entry-point class that you
have specified. In general terms, there are three broad reasons that this can happen:

You have specified an entry point class that does not exist.
The class exists, but you have specified it incorrectly.
The class exists and you have specified it correctly, but Java cannot it find it because the classpath is
incorrect.

Here is a procedure to diagnose and solve the problem:

1. Find out the full name of the entry-point class.

If you have source code for a class, then the full name consists of the package name and the simple
class name. The instance the "Main" class is declared in the package "com.example.myapp" then its full
name is "com.example.myapp.Main".
If you have a compiled class file, you can find the class name by running javap on it.
If the class file is in a directory, you can infer the full class name from the directory names.
If the class file is in a JAR or ZIP file, you can infer the full class name from the file path in the JAR or ZIP
file.

2. Look at the error message from the java command. The message should end with the full class name that
java is trying to use.

Check that it exactly matches the full classname for the entry-point class.
It should not end with ".java" or ".class".
It should not contain slashes or any other character that is not legal in a Java identifier1.
The casing of the name should exactly match the full class name.

3. If you are using the correct classname, make sure that the class is actually on the classpath:

Work out the pathname that the classname maps to; see Mapping classnames to pathnames
Work out what the classpath is; see this example: Different ways to specify the classpath
Look at each of the JAR and ZIP files on the classpath to see if they contain a class with the required
pathname.
Look at each directory to see if the pathname resolves to a file within the directory.

If checking the classpath by hand did not find the issue, you could add the -Xdiag and -XshowSettings options. The
former lists all classes that are loaded, and the latter prints out settings that include the effective classpath for the
JVM.

Finally, there are some obscure causes for this problem:

An executable JAR file with a Main-Class attribute that specifies a class that does not exist.
An executable JAR file with an incorrect Class-Path attribute.
If you mess up2 the options before the classname, the java command may attempt to interpret one of them

Java® Notes for Professionals 27

 as the classname.
If someone has ignored Java style rules and used package or class identifiers that differ only in letter case,
and you are running on a platform that treats letter case in filenames as non-significant.
Problems with homoglyphs in class names in the code or on the command line.

"Main method not found in class <name>"

This problem happens when the java command is able to find and load the class that you nominated, but is then
unable to find an entry-point method.

There are three possible explanations:

If you are trying to run an executable JAR file, then the JAR's manifest has an incorrect "Main-Class" attribute
that specifies a class that is not a valid entry point class.
You have told the java command a class that is not an entry point class.
The entry point class is incorrect; see Entry point classes for more information.

Other Resources

What does "Could not find or load main class" mean?

http://docs.oracle.com/javase/tutorial/getStarted/problems/index.html

1 - From Java 8 and later, the java command will helpfully map a filename separator ("/" or "") to a period (".").
However, this behavior is not documented in the manual pages.

2 - A really obscure case is if you copy-and-paste a command from a formatted document where the text editor has
used a "long hyphen" instead of a regular hyphen.

Section 8.3: Running a Java application with library

dependencies
This is a continuation of the "main class" and "executable JAR" examples.

Typical Java applications consist of an application-specific code, and various reusable library code that you have
implemented or that has been implemented by third parties. The latter are commonly referred to as library
dependencies, and are typically packaged as JAR files.

Java is a dynamically bound language. When you run a Java application with library dependencies, the JVM needs to
know where the dependencies are so that it can load classes as required. Broadly speaking, there are two ways to
deal with this:

The application and its dependencies can be repackaged into a single JAR file that contains all of the required
classes and resources.

The JVM can be told where to find the dependent JAR files via the runtime classpath.

For an executable JAR file, the runtime classpath is specified by the "Class-Path" manifest attribute. (Editorial Note:
This should be described in a separate Topic on the jar command.) Otherwise, the runtime classpath needs to be
supplied using the -cp option or using the CLASSPATH environment variable.

For example, suppose that we have a Java application in the "myApp.jar" file whose entry point class is
com.example.MyApp. Suppose also that the application depends on library JAR files "lib/library1.jar" and
"lib/library2.jar". We could launch the application using the java command as follows in a command line:

$ # Alternative 1 (preferred)

Java® Notes for Professionals 28

$ java -cp myApp.jar:lib/library1.jar:lib/library2.jar com.example.MyApp

$ # Alternative 2
$ export CLASSPATH=myApp.jar:lib/library1.jar:lib/library2.jar
$ java com.example.MyApp

(On Windows, you would use ; instead of : as the classpath separator, and you would set the (local) CLASSPATH
variable using set rather than export.)

While a Java developer would be comfortable with that, it is not "user friendly". So it is common practice to write a
simple shell script (or Windows batch file) to hide the details that the user doesn't need to know about. For
example, if you put the following shell script into a file called "myApp", made it executable, and put it into a
directory on the command search path:

#!/bin/bash
# The 'myApp' wrapper script

export DIR=/usr/libexec/myApp
export CLASSPATH=$DIR/myApp.jar:$DIR/lib/library1.jar:$DIR/lib/library2.jar
java com.example.MyApp

then you could run it as follows:

$ myApp arg1 arg2 ...

Any arguments on the command line will be passed to the Java application via the "$@" expansion. (You can do
something similar with a Windows batch file, though the syntax is different.)

Section 8.4: Java Options

The java command supports a wide range of options:

All options start with a single hyphen or minus-sign (

): the GNU/Linux convention of using

--

for "long" options is not supported.

Options must appear before the <classname> or the -jar <jarfile> argument to be recognized. Any
arguments after them will be treated as arguments to be passed to Java app that is being run.

Options that do not start with -X or -XX are standard options. You can rely on all Java implementations1 to
support any standard option.

Options that start with -X are non-standard options, and may be withdrawn from one Java version to the
next.

Options that start with -XX are advanced options, and may also be withdrawn.

Setting system properties with -D

The -D<property>=<value> option is used to set a property in the system Properties object. This parameter can be
repeated to set different properties.

Java® Notes for Professionals 29

Memory, Stack and Garbage Collector options

The main options for controlling the heap and stack sizes are documented in Setting the Heap, PermGen and Stack
sizes. (Editorial note: Garbage Collector options should be described in the same topic.)

Enabling and disabling assertions

The -ea and -da options respectively enable and disable Java assert checking:

All assertion checking is disabled by default.

The -ea option enables checking of all assertions
The -ea:<packagename>... enables checking of assertions in a package and all subpackages.
The -ea:<classname>... enables checking of assertions in a class.
The -da option disables checking of all assertions
The -da:<packagename>... disables checking of assertions in a package and all subpackages.
The -da:<classname>... disables checking of assertions in a class.
The -esa option enables checking for all system classes.
The -dsa option disables checking for all system classes.

The options can be combined. For example.

$ # Enable all assertion checking in non-system classes

$ java -ea -dsa MyApp

$ # Enable assertions for all classes in a package except for one.

$ java -ea:com.wombat.fruitbat... -da:com.wombat.fruitbat.Brickbat MyApp

Note that enabling to assertion checking is liable to alter the behavior of a Java programming.

It is liable make the application slower in general.

It can cause specific methods to take longer to run, which could change timing of threads in a multi-threaded
application.
It can introduce serendipitous happens-before relations which can cause memory anomalies to disappear.
An incorrectly implemented assert statement could have unwanted side-effects.

Selecting the VM type

The -client and -server options allow you to select between two different forms of the HotSpot VM:

The "client" form is tuned for user applications and offers faster startup.
The "server" form is tuned for long running applications. It takes longer capturing statistic during JVM "warm
up" which allows the JIT compiler to do a better of job of optimizing the native code.

By default, the JVM will run in 64bit mode if possible, depending on the capabilities of the platform. The -d32 and -
d64 options allow you to select the mode explicitly.

1 - Check the official manual for the java command. Sometimes a standard option is described as "subject to
change".

Section 8.5: Spaces and other special characters in

arguments
First of all, the problem of handling spaces in arguments is NOT actually a Java problem. Rather it is a problem that
needs to be handled by the command shell that you are using when you run a Java program.

Java® Notes for Professionals 30

As an example, let us suppose that we have the following simple program that prints the size of a file:

import java.io.File;

public class PrintFileSizes {

public static void main(String[] args) {

for (String name: args) {
File file = new File(name);
System.out.println("Size of '" + file + "' is " + file.size());
}
}
}

Now suppose that we want print the size of a file whose pathname has spaces in it; e.g. /home/steve/Test
File.txt. If we run the command like this:

$ java PrintFileSizes /home/steve/Test File.txt

the shell won't know that /home/steve/Test File.txt is actually one pathname. Instead, it will pass 2 distinct
arguments to the Java application, which will attempt to find their respective file sizes, and fail because files with
those paths (probably) do not exist.

Solutions using a POSIX shell

POSIX shells include sh as well derivatives such as bash and ksh. If you are using one of these shells, then you can
solve the problem by quoting the argument.

$ java PrintFileSizes "/home/steve/Test File.txt"

The double-quotes around the pathname tell the shell that it should be passed as a single argument. The quotes
will be removed when this happens. There are a couple of other ways to do this:

$ java PrintFileSizes '/home/steve/Test File.txt'

Single (straight) quotes are treated like double-quotes except that they also suppress various expansions within the
argument.

$ java PrintFileSizes /home/steve/Test\ File.txt

A backslash escapes the following space, and causes it not to be interpreted as an argument separator.

For more comprehensive documentation, including descriptions of how to deal with other special characters in
arguments, please refer to the quoting topic in the Bash documentation.

Solution for Windows

The fundamental problem for Windows is that at the OS level, the arguments are passed to a child process as a
single string (source). This means that the ultimate responsibility of parsing (or re-parsing) the command line falls
on either program or its runtime libraries. There is lots of inconsistency.

In the Java case, to cut a long story short:

You can put double-quotes around an argument in a java command, and that will allow you to pass
arguments with spaces in them.

Java® Notes for Professionals 31

 Apparently, the java command itself is parsing the command string, and it gets it more or less right

However, when you try to combine this with the use of SET and variable substitution in a batch file, it gets
really complicated as to whether double-quotes get removed.

The cmd.exe shell apparently has other escaping mechanisms; e.g. doubling double-quotes, and using ^
escapes.

For more detail, please refer to the Batch-File documentation.

Section 8.6: Running an executable JAR file

Executable JAR files are the simplest way to assemble Java code into a single file that can be executed. *(Editorial
Note: Creation of JAR files should be covered by a separate Topic.) *

Assuming that you have an executable JAR file with pathname <jar-path>, you should be able to run it as follows:

java -jar <jar-path>

If the command requires command-line arguments, add them after the <jar-path>. For example:

java -jar <jar-path> arg1 arg2 arg3

If you need to provide additional JVM options on the java command line, they need to go before the -jar option.
Note that a -cp / -classpath option will be ignored if you use -jar. The application's classpath is determined by the
JAR file manifest.

Section 8.7: Running a Java applications via a "main" class

When an application has not been packaged as an executable JAR, you need to provide the name of an entry-point
class on the java command line.

Running the HelloWorld class

The "HelloWorld" example is described in Creating a new Java program . It consists of a single class called
HelloWorld which satisfies the requirements for an entry-point.

Assuming that the (compiled) "HelloWorld.class" file is in the current directory, it can be launched as follows:

java HelloWorld

Some important things to note are:

We must provide the name of the class: not the pathname for the ".class" file or the ".java" file.
If the class is declared in a package (as most Java classes are), then the class name we supply to the java
command must be the full classname. For instance if SomeClass is declared in the com.example package, then
the full classname will be com.example.SomeClass.

Specifying a classpath

Unless we are using in the java -jar command syntax, the java command looks for the class to be loaded by
searching the classpath; see The Classpath. The above command is relying on the default classpath being (or
including) the current directory. We can be more explicit about this by specifying the classpath to be used using the
-cp option.

Java® Notes for Professionals 32

java -cp . HelloWorld

This says to make the current directory (which is what "." refers to) the sole entry on the classpath.

The -cp is an option that is processed by the java command. All options that are intended for the java command
should be before the classname. Anything after the class will be treated as an command line argument for the Java
application, and will be passed to application in the String[] that is passed to the main method.

(If no -cp option is provided, the java will use the classpath that is given by the CLASSPATH environment variable. If
that variable is unset or empty, java uses "." as the default classpath.)

Java® Notes for Professionals 33

Chapter 9: Date Class
Parameter Explanation
No parameter Creates a new Date object using the allocation time (to the nearest millisecond)
Creates a new Date object with the time set to the number of milliseconds since "the epoch" (January
long date
1, 1970, 00:00:00 GMT)

Section 9.1: Convert java.util.Date to java.sql.Date

java.util.Date to java.sql.Date conversion is usually necessary when a Date object needs to be written in a
database.

java.sql.Date is a wrapper around millisecond value and is used by JDBC to identify an SQL DATE type

In the below example, we use the java.util.Date() constructor, that creates a Date object and initializes it to
represent time to the nearest millisecond. This date is used in the convert(java.util.Date utilDate) method to
return a java.sql.Date object

Example

public class UtilToSqlConversion {

public static void main(String args[])

{
java.util.Date utilDate = new java.util.Date();
System.out.println("java.util.Date is : " + utilDate);
java.sql.Date sqlDate = convert(utilDate);
System.out.println("java.sql.Date is : " + sqlDate);
DateFormat df = new SimpleDateFormat("dd/MM/YYYY - hh:mm:ss");
System.out.println("dateFormated date is : " + df.format(utilDate));
}

private static java.sql.Date convert(java.util.Date uDate) {

java.sql.Date sDate = new java.sql.Date(uDate.getTime());
return sDate;
}

Output

java.util.Date is : Fri Jul 22 14:40:35 IST 2016

java.sql.Date is : 2016-07-22
dateFormated date is : 22/07/2016 - 02:40:35

java.util.Date has both date and time information, whereas java.sql.Date only has date information

Section 9.2: A basic date output

Using the following code with the format string yyyy/MM/dd hh:mm.ss, we will receive the following output

2016/04/19 11:45.36

Java® Notes for Professionals 34

// define the format to use
String formatString = "yyyy/MM/dd hh:mm.ss";

// get a current date object

Date date = Calendar.getInstance().getTime();

// create the formatter

SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formatString);

// format the date

String formattedDate = simpleDateFormat.format(date);

// print it
System.out.println(formattedDate);

// single-line version of all above code

System.out.println(new SimpleDateFormat("yyyy/MM/dd
hh:mm.ss").format(Calendar.getInstance().getTime()));

Section 9.3: Java 8 LocalDate and LocalDateTime objects

Date and LocalDate objects cannot be exactly converted between each other since a Date object represents both a
specific day and time, while a LocalDate object does not contain time or timezone information. However, it can be
useful to convert between the two if you only care about the actual date information and not the time information.

Creates a LocalDate

// Create a default date

LocalDate lDate = LocalDate.now();

// Creates a date from values

lDate = LocalDate.of(2017, 12, 15);

// create a date from string

lDate = LocalDate.parse("2017-12-15");

// creates a date from zone

LocalDate.now(ZoneId.systemDefault());

Creates a LocalDateTime

// Create a default date time

LocalDateTime lDateTime = LocalDateTime.now();

// Creates a date time from values

lDateTime = LocalDateTime.of(2017, 12, 15, 11, 30);

// create a date time from string

lDateTime = LocalDateTime.parse("2017-12-05T11:30:30");

// create a date time from zone

LocalDateTime.now(ZoneId.systemDefault());

LocalDate to Date and vice-versa

Date date = Date.from(Instant.now());

ZoneId defaultZoneId = ZoneId.systemDefault();

Java® Notes for Professionals 35

// Date to LocalDate
LocalDate localDate = date.toInstant().atZone(defaultZoneId).toLocalDate();

// LocalDate to Date
Date.from(localDate.atStartOfDay(defaultZoneId).toInstant());

LocalDateTime to Date and vice-versa

Date date = Date.from(Instant.now());

ZoneId defaultZoneId = ZoneId.systemDefault();

// Date to LocalDateTime
LocalDateTime localDateTime = date.toInstant().atZone(defaultZoneId).toLocalDateTime();

// LocalDateTime to Date
Date out = Date.from(localDateTime.atZone(defaultZoneId).toInstant());

Section 9.4: Creating a Specific Date

While the Java Date class has several constructors, you'll notice that most are deprecated. The only acceptable way
of creating a Date instance directly is either by using the empty constructor or passing in a long (number of
milliseconds since standard base time). Neither are handy unless you're looking for the current date or have
another Date instance already in hand.

To create a new date, you will need a Calendar instance. From there you can set the Calendar instance to the date
that you need.

Calendar c = Calendar.getInstance();

This returns a new Calendar instance set to the current time. Calendar has many methods for mutating it's date
and time or setting it outright. In this case, we'll set it to a specific date.

c.set(1974, 6, 2, 8, 0, 0);
Date d = c.getTime();

The getTime method returns the Date instance that we need. Keep in mind that the Calendar set methods only set
one or more fields, they do not set them all. That is, if you set the year, the other fields remain unchanged.

PITFALL

In many cases, this code snippet fulfills its purpose, but keep in mind that two important parts of the date/time are
not defined.

the (1974, 6, 2, 8, 0, 0) parameters are interpreted within the default timezone, defined somewhere
else,
the milliseconds are not set to zero, but filled from the system clock at the time the Calendar instance is
created.

Section 9.5: Converting Date to a certain String format

format() from SimpleDateFormat class helps to convert a Date object into certain format String object by using
the supplied pattern string.

Date today = new Date();

Java® Notes for Professionals 36

SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MMM-yy"); //pattern is specified here
System.out.println(dateFormat.format(today)); //25-Feb-16

Patterns can be applied again by using applyPattern()

dateFormat.applyPattern("dd-MM-yyyy");
System.out.println(dateFormat.format(today)); //25-02-2016

dateFormat.applyPattern("dd-MM-yyyy HH:mm:ss E");

System.out.println(dateFormat.format(today)); //25-02-2016 06:14:33 Thu

Note: Here mm (small letter m) denotes minutes and MM (capital M) denotes month. Pay careful attention when
formatting years: capital "Y" (Y) indicates the "week in the year" while lower-case "y" (y) indicates the year.

Section 9.6: LocalTime

To use just the time part of a Date use LocalTime. You can instantiate a LocalTime object in a couple ways

1. LocalTime time = LocalTime.now();

2. time = LocalTime.MIDNIGHT;
3. time = LocalTime.NOON;
4. time = LocalTime.of(12, 12, 45);

LocalTime also has a built in toString method that displays the format very nicely.

System.out.println(time);

you can also get, add and subtract hours, minutes, seconds, and nanoseconds from the LocalTime object i.e.

time.plusMinutes(1);
time.getMinutes();
time.minusMinutes(1);

You can turn it into a Date object with the following code:

LocalTime lTime = LocalTime.now();

Instant instant = lTime.atDate(LocalDate.of(A_YEAR, A_MONTH, A_DAY)).
atZone(ZoneId.systemDefault()).toInstant();
Date time = Date.from(instant);

this class works very nicely within a timer class to simulate an alarm clock.

Section 9.7: Convert formatted string representation of date

to Date object
This method can be used to convert a formatted string representation of a date into a Date object.

/**
* Parses the date using the given format.
*
* @param formattedDate the formatted date string
* @param dateFormat the date format which was used to create the string.
* @return the date
*/
public static Date parseDate(String formattedDate, String dateFormat) {
Date date = null;

Java® Notes for Professionals 37

 SimpleDateFormat objDf = new SimpleDateFormat(dateFormat);
try {
date = objDf.parse(formattedDate);
} catch (ParseException e) {
// Do what ever needs to be done with exception.
}
return date;
}

Section 9.8: Creating Date objects

Date date = new Date();
System.out.println(date); // Thu Feb 25 05:03:59 IST 2016

Here this Date object contains the current date and time when this object was created.

Calendar calendar = Calendar.getInstance();

calendar.set(90, Calendar.DECEMBER, 11);
Date myBirthDate = calendar.getTime();
System.out.println(myBirthDate); // Mon Dec 31 00:00:00 IST 1990

Date objects are best created through a Calendar instance since the use of the data constructors is deprecated and
discouraged. To do se we need to get an instance of the Calendar class from the factory method. Then we can set
year, month and day of month by using numbers or in case of months constants provided py the Calendar class to
improve readability and reduce errors.

calendar.set(90, Calendar.DECEMBER, 11, 8, 32, 35);

Date myBirthDatenTime = calendar.getTime();
System.out.println(myBirthDatenTime); // Mon Dec 31 08:32:35 IST 1990

Along with date, we can also pass time in the order of hour, minutes and seconds.

Section 9.9: Comparing Date objects

Calendar, Date, and LocalDate
Version < Java SE 8
before, after, compareTo and equals methods
//Use of Calendar and Date objects
final Date today = new Date();
final Calendar calendar = Calendar.getInstance();
calendar.set(1990, Calendar.NOVEMBER, 1, 0, 0, 0);
Date birthdate = calendar.getTime();

final Calendar calendar2 = Calendar.getInstance();

calendar2.set(1990, Calendar.NOVEMBER, 1, 0, 0, 0);
Date samebirthdate = calendar2.getTime();

//Before example
System.out.printf("Is %1$tF before %2$tF? %3$b%n", today, birthdate,
Boolean.valueOf(today.before(birthdate)));
System.out.printf("Is %1$tF before %1$tF? %3$b%n", today, today,
Boolean.valueOf(today.before(today)));
System.out.printf("Is %2$tF before %1$tF? %3$b%n", today, birthdate,
Boolean.valueOf(birthdate.before(today)));

//After example
System.out.printf("Is %1$tF after %2$tF? %3$b%n", today, birthdate,

Java® Notes for Professionals 38

Boolean.valueOf(today.after(birthdate)));
System.out.printf("Is %1$tF after %1$tF? %3$b%n", today, birthdate,
Boolean.valueOf(today.after(today)));
System.out.printf("Is %2$tF after %1$tF? %3$b%n", today, birthdate,
Boolean.valueOf(birthdate.after(today)));

//Compare example
System.out.printf("Compare %1$tF to %2$tF: %3$d%n", today, birthdate,
Integer.valueOf(today.compareTo(birthdate)));
System.out.printf("Compare %1$tF to %1$tF: %3$d%n", today, birthdate,
Integer.valueOf(today.compareTo(today)));
System.out.printf("Compare %2$tF to %1$tF: %3$d%n", today, birthdate,
Integer.valueOf(birthdate.compareTo(today)));

//Equal example
System.out.printf("Is %1$tF equal to %2$tF? %3$b%n", today, birthdate,
Boolean.valueOf(today.equals(birthdate)));
System.out.printf("Is %1$tF equal to %2$tF? %3$b%n", birthdate, samebirthdate,
Boolean.valueOf(birthdate.equals(samebirthdate)));
System.out.printf(
"Because birthdate.getTime() -> %1$d is different from samebirthdate.getTime() -> %2$d,
there are millisecondes!%n",
Long.valueOf(birthdate.getTime()), Long.valueOf(samebirthdate.getTime()));

//Clear ms from calendars

calendar.clear(Calendar.MILLISECOND);
calendar2.clear(Calendar.MILLISECOND);
birthdate = calendar.getTime();
samebirthdate = calendar2.getTime();

System.out.printf("Is %1$tF equal to %2$tF after clearing ms? %3$b%n", birthdate, samebirthdate,
Boolean.valueOf(birthdate.equals(samebirthdate)));
Version ≥ Java SE 8
isBefore, isAfter, compareTo and equals methods
//Use of LocalDate
final LocalDate now = LocalDate.now();
final LocalDate birthdate2 = LocalDate.of(2012, 6, 30);
final LocalDate birthdate3 = LocalDate.of(2012, 6, 30);

//Hours, minutes, second and nanoOfsecond can also be configured with an other class LocalDateTime
//LocalDateTime.of(year, month, dayOfMonth, hour, minute, second, nanoOfSecond);

//isBefore example
System.out.printf("Is %1$tF before %2$tF? %3$b%n", now, birthdate2,
Boolean.valueOf(now.isBefore(birthdate2)));
System.out.printf("Is %1$tF before %1$tF? %3$b%n", now, birthdate2,
Boolean.valueOf(now.isBefore(now)));
System.out.printf("Is %2$tF before %1$tF? %3$b%n", now, birthdate2,
Boolean.valueOf(birthdate2.isBefore(now)));

//isAfter example
System.out.printf("Is %1$tF after %2$tF? %3$b%n", now, birthdate2,
Boolean.valueOf(now.isAfter(birthdate2)));
System.out.printf("Is %1$tF after %1$tF? %3$b%n", now, birthdate2,
Boolean.valueOf(now.isAfter(now)));
System.out.printf("Is %2$tF after %1$tF? %3$b%n", now, birthdate2,
Boolean.valueOf(birthdate2.isAfter(now)));

//compareTo example
System.out.printf("Compare %1$tF to %2$tF %3$d%n", now, birthdate2,
Integer.valueOf(now.compareTo(birthdate2)));

Java® Notes for Professionals 39

System.out.printf("Compare %1$tF to %1$tF %3$d%n", now, birthdate2,
Integer.valueOf(now.compareTo(now)));
System.out.printf("Compare %2$tF to %1$tF %3$d%n", now, birthdate2,
Integer.valueOf(birthdate2.compareTo(now)));

//equals example
System.out.printf("Is %1$tF equal to %2$tF? %3$b%n", now, birthdate2,
Boolean.valueOf(now.equals(birthdate2)));
System.out.printf("Is %1$tF to %2$tF? %3$b%n", birthdate2, birthdate3,
Boolean.valueOf(birthdate2.equals(birthdate3)));

//isEqual example
System.out.printf("Is %1$tF equal to %2$tF? %3$b%n", now, birthdate2,
Boolean.valueOf(now.isEqual(birthdate2)));
System.out.printf("Is %1$tF to %2$tF? %3$b%n", birthdate2, birthdate3,
Boolean.valueOf(birthdate2.isEqual(birthdate3)));

Date comparison before Java 8

Before Java 8, dates could be compared using java.util.Calendar and java.util.Date classes. Date class offers 4
methods to compare dates :

after(Date when)
before(Date when)
compareTo(Date anotherDate)
equals(Object obj)

after, before, compareTo and equals methods compare the values returned by getTime() method for each date.

compareTo method returns positive integer.

Value greater than 0 : when the Date is after the Date argument
Value greater than 0 : when the Date is before the Date argument
Value equals to 0 : when the Date is equal to the Date argument

equals results can be surprising as shown in the example because values, like milliseconds, are not initialize with
the same value if not explicitly given.

Since Java 8

With Java 8 a new Object to work with Date is available java.time.LocalDate. LocalDate implements
ChronoLocalDate, the abstract representation of a date where the Chronology, or calendar system, is pluggable.

To have the date time precision the Object java.time.LocalDateTime has to be used. LocalDate and LocalDateTime
use the same methods name for comparing.

Comparing dates using a LocalDate is different from using ChronoLocalDate because the chronology, or calendar
system are not taken in account the first one.

Because most application should use LocalDate, ChronoLocalDate is not included in examples. Further reading
here.

Most applications should declare method signatures, fields and variables as LocalDate, not
this[ChronoLocalDate] interface.

LocalDate has 5 methods to compare dates :

Java® Notes for Professionals 40

 isAfter(ChronoLocalDate other)
isBefore(ChronoLocalDate other)
isEqual(ChronoLocalDate other)
compareTo(ChronoLocalDate other)
equals(Object obj)

In case of LocalDate parameter, isAfter, isBefore, isEqual, equals and compareTo now use this method:

int compareTo0(LocalDate otherDate) {

int cmp = (year - otherDate.year);
if (cmp == 0) {
cmp = (month - otherDate.month);
if (cmp == 0) {
cmp = (day - otherDate.day);
}
}
return cmp;
}

equals method check if the parameter reference equals the date first whereas isEqual directly calls compareTo0.

In case of an other class instance of ChronoLocalDate the dates are compared using the Epoch Day. The Epoch Day
count is a simple incrementing count of days where day 0 is 1970-01-01 (ISO).

Section 9.10: Converting String into Date

parse() from SimpleDateFormat class helps to convert a String pattern into a Date object.

DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.SHORT, Locale.US);

String dateStr = "02/25/2016"; // input String
Date date = dateFormat.parse(dateStr);
System.out.println(date.getYear()); // 116

There are 4 different styles for the text format, SHORT, MEDIUM (this is the default), LONG and FULL, all of which
depend on the locale. If no locale is specified, the system default locale is used.

Style Locale.US Locale.France

SHORT 6/30/09 30/06/09
MEDIUM Jun 30, 2009 30 juin 2009
LONG June 30, 2009 30 juin 2009
FULL Tuesday, June 30, 2009 mardi 30 juin 2009

Section 9.11: Time Zones and java.util.Date

A java.util.Date object does not have a concept of time zone.

There is no way to set a timezone for a Date

There is no way to change the timezone of a Date object
A Date object created with the new Date() default constructor will be initialised with the current time in the
system default timezone

However, it is possible to display the date represented by the point in time described by the Date object in a
different time zone using e.g. java.text.SimpleDateFormat:

Date date = new Date();

//print default time zone

Java® Notes for Professionals 41

System.out.println(TimeZone.getDefault().getDisplayName());
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //note: time zone not in
format!
//print date in the original time zone
System.out.println(sdf.format(date));
//current time in London
sdf.setTimeZone(TimeZone.getTimeZone("Europe/London"));
System.out.println(sdf.format(date));

Output:

Central European Time

2016-07-21 22:50:56
2016-07-21 21:50:56

Java® Notes for Professionals 42

Chapter 10: Dates and Time (java.time.*)
Section 10.1: Calculate Dierence between 2 LocalDates
Use LocalDate and ChronoUnit:

LocalDate d1 = LocalDate.of(2017, 5, 1);

LocalDate d2 = LocalDate.of(2017, 5, 18);

now, since the method between of the ChronoUnit enumerator takes 2 Temporals as parameters so you can pass
without a problem the LocalDate instances

long days = ChronoUnit.DAYS.between(d1, d2);

System.out.println( days );

Section 10.2: Date and time

Date and time without time zone information

LocalDateTime dateTime = LocalDateTime.of(2016, Month.JULY, 27, 8, 0);

LocalDateTime now = LocalDateTime.now();
LocalDateTime parsed = LocalDateTime.parse("2016-07-27T07:00:00");

Date and time with time zone information

ZoneId zoneId = ZoneId.of("UTC+2");

ZonedDateTime dateTime = ZonedDateTime.of(2016, Month.JULY, 27, 7, 0, 0, 235, zoneId);
ZonedDateTime composition = ZonedDateTime.of(localDate, localTime, zoneId);
ZonedDateTime now = ZonedDateTime.now(); // Default time zone
ZonedDateTime parsed = ZonedDateTime.parse("2016-07-27T07:00:00+01:00[Europe/Stockholm]");

Date and time with offset information (i.e. no DST changes taken into account)

ZoneOffset zoneOffset = ZoneOffset.ofHours(2);

OffsetDateTime dateTime = OffsetDateTime.of(2016, 7, 27, 7, 0, 0, 235, zoneOffset);
OffsetDateTime composition = OffsetDateTime.of(localDate, localTime, zoneOffset);
OffsetDateTime now = OffsetDateTime.now(); // Offset taken from the default ZoneId
OffsetDateTime parsed = OffsetDateTime.parse("2016-07-27T07:00:00+02:00");

Section 10.3: Operations on dates and times

LocalDate tomorrow = LocalDate.now().plusDays(1);
LocalDateTime anHourFromNow = LocalDateTime.now().plusHours(1);
Long daysBetween = java.time.temporal.ChronoUnit.DAYS.between(LocalDate.now(),
LocalDate.now().plusDays(3)); // 3
Duration duration = Duration.between(Instant.now(),
ZonedDateTime.parse("2016-07-27T07:00:00+01:00[Europe/Stockholm]"))

Section 10.4: Instant

Represents an instant in time. Can be thought of as a wrapper around a Unix timestamp.

Instant now = Instant.now();

Instant epoch1 = Instant.ofEpochMilli(0);

Java® Notes for Professionals 43

Instant epoch2 = Instant.parse("1970-01-01T00:00:00Z");
java.time.temporal.ChronoUnit.MICROS.between(epoch1, epoch2); // 0

Section 10.5: Usage of various classes of Date Time API

Following example also have explanation required for understanding example within it.

import java.time.Clock;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.TimeZone;
public class SomeMethodsExamples {

/**
* Has the methods of the class {@link LocalDateTime}
*/
public static void checkLocalDateTime() {
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println("Local Date time using static now() method ::: >>> "
+ localDateTime);

LocalDateTime ldt1 = LocalDateTime.now(ZoneId.of(ZoneId.SHORT_IDS

.get("AET")));
System.out
.println("LOCAL TIME USING now(ZoneId zoneId) method ::: >>>>"
+ ldt1);

LocalDateTime ldt2 = LocalDateTime.now(Clock.system(ZoneId

.of(ZoneId.SHORT_IDS.get("PST"))));
System.out
.println("Local TIME USING now(Clock.system(ZoneId.of())) ::: >>>> "
+ ldt2);

System.out
.println("Following is a static map in ZoneId class which has mapping of short timezone
names to their Actual timezone names");
System.out.println(ZoneId.SHORT_IDS);

/**
* This has the methods of the class {@link LocalDate}
*/
public static void checkLocalDate() {
LocalDate localDate = LocalDate.now();
System.out.println("Gives date without Time using now() method. >> "
+ localDate);
LocalDate localDate2 = LocalDate.now(ZoneId.of(ZoneId.SHORT_IDS
.get("ECT")));
System.out
.println("now() is overridden to take ZoneID as parametere using this we can get the
same date under different timezones. >> "
+ localDate2);
}

/**

Java® Notes for Professionals 44

 * This has the methods of abstract class {@link Clock}. Clock can be used
* for time which has time with {@link TimeZone}.
*/
public static void checkClock() {
Clock clock = Clock.systemUTC();
// Represents time according to ISO 8601
System.out.println("Time using Clock class : " + clock.instant());
}

/**
* This has the {@link Instant} class methods.
*/
public static void checkInstant() {
Instant instant = Instant.now();

System.out.println("Instant using now() method :: " + instant);

Instant ins1 = Instant.now(Clock.systemUTC());

System.out.println("Instants using now(Clock clock) :: " + ins1);

/**
* This class checks the methods of the {@link Duration} class.
*/
public static void checkDuration() {
// toString() converts the duration to PTnHnMnS format according to ISO
// 8601 standard. If a field is zero its ignored.

// P is the duration designator (historically called "period") placed at

// the start of the duration representation.
// Y is the year designator that follows the value for the number of
// years.
// M is the month designator that follows the value for the number of
// months.
// W is the week designator that follows the value for the number of
// weeks.
// D is the day designator that follows the value for the number of
// days.
// T is the time designator that precedes the time components of the
// representation.
// H is the hour designator that follows the value for the number of
// hours.
// M is the minute designator that follows the value for the number of
// minutes.
// S is the second designator that follows the value for the number of
// seconds.

System.out.println(Duration.ofDays(2));
}

/**
* Shows Local time without date. It doesn't store or represenet a date and
* time. Instead its a representation of Time like clock on the wall.
*/
public static void checkLocalTime() {
LocalTime localTime = LocalTime.now();
System.out.println("LocalTime :: " + localTime);
}

/**

Java® Notes for Professionals 45

 * A date time with Time zone details in ISO-8601 standards.
*/
public static void checkZonedDateTime() {
ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId
.of(ZoneId.SHORT_IDS.get("CST")));
System.out.println(zonedDateTime);

}
}

Section 10.6: Date Time Formatting

Before Java 8, there was DateFormat and SimpleDateFormat classes in the package java.text and this legacy code
will be continued to be used for sometime.

But, Java 8 offers a modern approach to handling Formatting and Parsing.

In formatting and parsing first you pass a String object to DateTimeFormatter, and in turn use it for formatting or
parsing.

import java.time.*;
import java.time.format.*;

class DateTimeFormat
{
public static void main(String[] args) {

//Parsing
String pattern = "d-MM-yyyy HH:mm";
DateTimeFormatter dtF1 = DateTimeFormatter.ofPattern(pattern);

LocalDateTime ldp1 = LocalDateTime.parse("2014-03-25T01:30"), //Default format

ldp2 = LocalDateTime.parse("15-05-2016 13:55",dtF1); //Custom format

System.out.println(ldp1 + "\n" + ldp2); //Will be printed in Default format

//Formatting
DateTimeFormatter dtF2 = DateTimeFormatter.ofPattern("EEE d, MMMM, yyyy HH:mm");

DateTimeFormatter dtF3 = DateTimeFormatter.ISO_LOCAL_DATE_TIME;

LocalDateTime ldtf1 = LocalDateTime.now();

System.out.println(ldtf1.format(dtF2) +"\n"+ldtf1.format(dtF3));
}
}

An important notice, instead of using Custom patterns, it is good practice to use predefined formatters. Your code
look more clear and usage of ISO8061 will definitely help you in the long run.

Section 10.7: Simple Date Manipulations

Get the current date.

LocalDate.now()

Get yesterday's date.

Java® Notes for Professionals 46

LocalDate y = LocalDate.now().minusDays(1);

Get tomorrow's date

LocalDate t = LocalDate.now().plusDays(1);

Get a specific date.

LocalDate t = LocalDate.of(1974, 6, 2, 8, 30, 0, 0);

In addition to the plus and minus methods, there are a set of "with" methods that can be used to set a particular
field on a LocalDate instance.

LocalDate.now().withMonth(6);

The example above returns a new instance with the month set to June (this differs from java.util.Date where
setMonth was indexed a 0 making June 5).

Because LocalDate manipulations return immutable LocalDate instances, these methods may also be chained
together.

LocalDate ld = LocalDate.now().plusDays(1).plusYears(1);

This would give us tomorrow's date one year from now.

Java® Notes for Professionals 47

Chapter 11: LocalTime
Method Output
LocalTime.of(13, 12, 11) 13:12:11
LocalTime.MIDNIGHT 00:00
LocalTime.NOON 12:00
LocalTime.now() Current time from system clock
LocalTime.MAX The maximum supported local time 23:59:59.999999999
LocalTime.MIN The minimum supported local time 00:00
LocalTime.ofSecondOfDay(84399) 23:59:59 , Obtains Time from second-of-day value
LocalTime.ofNanoOfDay(2000000000) 00:00:02 , Obtains Time from nanos-of-day value

Section 11.1: Amount of time between two LocalTime

There are two equivalent ways to calculate the amount of time unit between two LocalTime: (1) through
until(Temporal, TemporalUnit) method and through (2) TemporalUnit.between(Temporal, Temporal).

import java.time.LocalTime;
import java.time.temporal.ChronoUnit;

public class AmountOfTime {

public static void main(String[] args) {

LocalTime start = LocalTime.of(1, 0, 0); // hour, minute, second

LocalTime end = LocalTime.of(2, 10, 20); // hour, minute, second

long halfDays1 = start.until(end, ChronoUnit.HALF_DAYS); // 0

long halfDays2 = ChronoUnit.HALF_DAYS.between(start, end); // 0

long hours1 = start.until(end, ChronoUnit.HOURS); // 1

long hours2 = ChronoUnit.HOURS.between(start, end); // 1

long minutes1 = start.until(end, ChronoUnit.MINUTES); // 70

long minutes2 = ChronoUnit.MINUTES.between(start, end); // 70

long seconds1 = start.until(end, ChronoUnit.SECONDS); // 4220

long seconds2 = ChronoUnit.SECONDS.between(start, end); // 4220

long millisecs1 = start.until(end, ChronoUnit.MILLIS); // 4220000

long millisecs2 = ChronoUnit.MILLIS.between(start, end); // 4220000

long microsecs1 = start.until(end, ChronoUnit.MICROS); // 4220000000

long microsecs2 = ChronoUnit.MICROS.between(start, end); // 4220000000

long nanosecs1 = start.until(end, ChronoUnit.NANOS); // 4220000000000

long nanosecs2 = ChronoUnit.NANOS.between(start, end); // 4220000000000

// Using others ChronoUnit will be thrown UnsupportedTemporalTypeException.

// The following methods are examples thereof.
long days1 = start.until(end, ChronoUnit.DAYS);
long days2 = ChronoUnit.DAYS.between(start, end);
}
}

Java® Notes for Professionals 48

Section 11.2: Intro
LocalTime is an immutable class and thread-safe, used to represent time, often viewed as hour-min-sec. Time is
represented to nanosecond precision. For example, the value "13:45.30.123456789" can be stored in a LocalTime.

This class does not store or represent a date or time-zone. Instead, it is a description of the local time as seen on a
wall clock. It cannot represent an instant on the time-line without additional information such as an offset or time-
zone. This is a value based class, equals method should be used for comparisons.

Fields

MAX - The maximum supported LocalTime, '23:59:59.999999999'. MIDNIGHT, MIN, NOON

Important Static Methods

now(), now(Clock clock), now(ZoneId zone), parse(CharSequence text)

Important Instance Methods

isAfter(LocalTime other), isBefore(LocalTime other), minus(TemporalAmount amountToSubtract), minus(long

amountToSubtract, TemporalUnit unit), plus(TemporalAmount amountToAdd), plus(long amountToAdd,
TemporalUnit unit)

ZoneId zone = ZoneId.of("Asia/Kolkata");

LocalTime now = LocalTime.now();
LocalTime now1 = LocalTime.now(zone);
LocalTime then = LocalTime.parse("04:16:40");

Difference in time can be calculated in any of following ways

long timeDiff = Duration.between(now, now1).toMinutes();

long timeDiff1 = java.time.temporal.ChronoUnit.MINUTES.between(now2, now1);

You can also add/subtract hours, minutes or seconds from any object of LocalTime.

minusHours(long hoursToSubtract), minusMinutes(long hoursToMinutes), minusNanos(long nanosToSubtract),

minusSeconds(long secondsToSubtract), plusHours(long hoursToSubtract), plusMinutes(long hoursToMinutes),
plusNanos(long nanosToSubtract), plusSeconds(long secondsToSubtract)

now.plusHours(1L);
now1.minusMinutes(20L);

Section 11.3: Time Modification

You can add hours, minutes, seconds and nanoseconds:

LocalTime time = LocalTime.now();

LocalTime addHours = time.plusHours(5); // Add 5 hours
LocaLTime addMinutes = time.plusMinutes(15) // Add 15 minutes
LocalTime addSeconds = time.plusSeconds(30) // Add 30 seconds
LocalTime addNanoseconds = time.plusNanos(150_000_000) // Add 150.000.000ns (150ms)

Section 11.4: Time Zones and their time dierence

import java.time.LocalTime;

Java® Notes for Professionals 49

import java.time.ZoneId;
import java.time.temporal.ChronoUnit;

public class Test {

public static void main(String[] args)
{
ZoneId zone1 = ZoneId.of("Europe/Berlin");
ZoneId zone2 = ZoneId.of("Brazil/East");

LocalTime now = LocalTime.now();

LocalTime now1 = LocalTime.now(zone1);
LocalTime now2 = LocalTime.now(zone2);

System.out.println("Current Time : " + now);

System.out.println("Berlin Time : " + now1);
System.out.println("Brazil Time : " + now2);

long minutesBetween = ChronoUnit.MINUTES.between(now2, now1);

System.out.println("Minutes Between Berlin and Brazil : " + minutesBetween +"mins");

}
}

Java® Notes for Professionals 50

Chapter 12: Literals
A Java literal is a syntactic element (i.e. something you find in the source code of a Java program) that represents a
value. Examples are 1, 0.333F, false, &#39;X&#39; and "Hello world\n".

Section 12.1: Using underscore to improve readability

Since Java 7 it has been possible to use one or more underscores (_) for separating groups of digits in a primitive
number literal to improve their readability.

For instance, these two declarations are equivalent:

Version ≥ Java SE 7
int i1 = 123456;
int i2 = 123_456;
System.out.println(i1 == i2); // true

This can be applied to all primitive number literals as shown below:

Version ≥ Java SE 7
byte color = 1_2_3;
short yearsAnnoDomini= 2_016;
int socialSecurtyNumber = 999_99_9999;
long creditCardNumber = 1234_5678_9012_3456L;
float piFourDecimals = 3.14_15F;
double piTenDecimals = 3.14_15_92_65_35;

This also works using prefixes for binary, octal and hexadecimal bases:

Version ≥ Java SE 7
short binary= 0b0_1_0_1;
int octal = 07_7_7_7_7_7_7_7_0;
long hexBytes = 0xFF_EC_DE_5E;

There are a few rules about underscores which forbid their placement in the following places:

At the beginning or end of a number (e.g. _123 or 123_ are not valid)
Adjacent to a decimal point in a floating point literal (e.g. 1._23 or 1_.23 are not valid)
Prior to an F or L suffix (e.g. 1.23_F or 9999999_L are not valid)
In positions where a string of digits is expected (e.g. 0_xFFFF is not valid)

Section 12.2: Hexadecimal, Octal and Binary literals

A hexadecimal number is a value in base-16. There are 16 digits, 0-9 and the letters A-F (case does not matter). A-F
represent 10-16.

An octal number is a value in base-8, and uses the digits 0-7.

A binary number is a value in base-2, and uses the digits 0 and 1.

All of these numbers result in the same value, 110:

int dec = 110; // no prefix --> decimal literal

int bin = 0b1101110; // '0b' prefix --> binary literal
int oct = 0156; // '0' prefix --> octal literal

Java® Notes for Professionals 51

int hex = 0x6E; // '0x' prefix --> hexadecimal literal

Note that binary literal syntax was introduced in Java 7.

The octal literal can easily be a trap for semantic errors. If you define a leading '0' to your decimal literals you will
get the wrong value:

int a = 0100; // Instead of 100, a == 64

Section 12.3: Boolean literals

Boolean literals are the simplest of the literals in the Java programming language. The two possible boolean values
are represented by the literals true and false. These are case-sensitive. For example:

boolean flag = true; // using the 'true' literal

flag = false; // using the 'false' literal

Section 12.4: String literals

String literals provide the most convenient way to represent string values in Java source code. A String literal
consists of:

An opening double-quote (") character.

Zero or more other characters that are neither a double-quote or a line-break character. (A backslash (\)
character alters the meaning of subsequent characters; see Escape sequences in literals.)
A closing double-quote character.

For example:

"Hello world" // A literal denoting an 11 character String

"" // A literal denoting an empty (zero length) String
"\"" // A literal denoting a String consisting of one
// double quote character
"1\t2\t3\n" // Another literal with escape sequences

Note that a single string literal may not span multiple source code lines. It is a compilation error for a line-break (or
the end of the source file) to occur before a literal's closing double-quote. For example:

"Jello world // Compilation error (at the end of the line!)

Long strings

If you need a string that is too long to fit on a line, the conventional way to express it is to split it into multiple
literals and use the concatenation operator (+) to join the pieces. For example

String typingPractice = "The quick brown fox " +

"jumped over " +
"the lazy dog"

An expression like the above consisting of string literals and + satisfies the requirements to be a Constant
Expression. That means that the expression will be evaluated by the compiler and represented at runtime by a
single String object.

Interning of string literals

Java® Notes for Professionals 52

When class file containing string literals is loaded by the JVM, the corresponding String objects are interned by the
runtime system. This means that a string literal used in multiple classes occupies no more space than if it was used
in one class.

For more information on interning and the string pool, refer to the String pool and heap storage example in the
Strings topic.

Section 12.5: The Null literal

The Null literal (written as null) represents the one and only value of the null type. Here are some examples

MyClass object = null;

MyClass[] objects = new MyClass[]{new MyClass(), null, new MyClass()};

myMethod(null);

if (objects != null) {
// Do something
}

The null type is rather unusual. It has no name, so you cannot express it in Java source code. (And it has no runtime
representation either.)

The sole purpose of the null type is to be the type of null. It is assignment compatible with all reference types, and
can be type cast to any reference type. (In the latter case, the cast does not entail a runtime type check.)

Finally, null has the property that null instanceof <SomeReferenceType> will evaluate to false, no matter what
the type is.

Section 12.6: Escape sequences in literals

String and character literals provide an escape mechanism that allows express character codes that would
otherwise not be allowed in the literal. An escape sequence consists of a backslash character (\) followed by one
ore more other characters. The same sequences are valid in both character an string literals.

The complete set of escape sequences is as follows:

Escape sequence Meaning

\\ Denotes an backslash (\) character
\' Denotes a single-quote (') character
\" Denotes a double-quote (") character
\n Denotes a line feed (LF) character
\r Denotes a carriage return (CR) character
\t Denotes a horizontal tab (HT) character
\f Denotes a form feed (FF) character
\b Denotes a backspace (BS) character
\<octal> Denotes a character code in the range 0 to 255.

The <octal> in the above consists of one, two or three octal digits ('0' through '7') which represent a number
between 0 and 255 (decimal).

Note that a backslash followed by any other character is an invalid escape sequence. Invalid escape sequences are
treated as compilation errors by the JLS.

Reference:

Java® Notes for Professionals 53

 JLS 3.10.6. Escape Sequences for Character and String Literals

Unicode escapes

In addition to the string and character escape sequences described above, Java has a more general Unicode
escaping mechanism, as defined in JLS 3.3. Unicode Escapes. A Unicode escape has the following syntax:

'\' 'u' <hex-digit> <hex-digit> <hex-digit> <hex-digit>

where <hex-digit> is one of '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C',
'D', 'E', 'F'.

A Unicode escape is mapped by the Java compiler to a character (strictly speaking a 16-bit Unicode code unit), and
can be used anywhere in the source code where the mapped character is valid. It is commonly used in character
and string literals when you need to represent a non-ASCII character in a literal.

Escaping in regexes

TBD

Section 12.7: Character literals

Character literals provide the most convenient way to express char values in Java source code. A character literal
consists of:

An opening single-quote (') character.

A representation of a character. This representation cannot be a single-quote or a line-break character, but it
can be an escape sequence introduced by a backslash (\) character; see Escape sequences in literals.
A closing single-quote (') character.

For example:

char a = 'a';
char doubleQuote = '"';
char singleQuote = '\'';

A line-break in a character literal is a compilation error:

char newline = '

// Compilation error in previous line
char newLine = '\n'; // Correct

Section 12.8: Decimal Integer literals

Integer literals provide values that can be used where you need a byte, short, int, long or char instance. (This
example focuses on the simple decimal forms. Other examples explain how to literals in octal, hexadecimal and
binary, and the use of underscores to improve readability.)

Ordinary integer literals

The simplest and most common form of integer literal is a decimal integer literal. For example:

0 // The decimal number zero (type 'int')

1 // The decimal number one (type 'int')
42 // The decimal number forty two (type 'int')

Java® Notes for Professionals 54

You need to be careful with leading zeros. A leading zero causes an integer literal to be interpreted as octal not
decimal.

077 // This literal actually means 7 x 8 + 7 ... or 63 decimal!

Integer literals are unsigned. If you see something like -10 or +10, these are actually expressions using the unary

and unary + operators.

The range of integer literals of this form have an intrinsic type of int, and must fall in the range zero to 231 or
2,147,483,648.

Note that 231 is 1 greater than Integer.MAX_VALUE. Literals from 0 through to 2147483647 can be used anywhere,
but it is a compilation error to use 2147483648 without a preceding unary

operator. (In other words, it is reserved for expressing the value of Integer.MIN_VALUE.)
int max = 2147483647; // OK
int min = -2147483648; // OK
int tooBig = 2147483648; // ERROR

Long integer literals

Literals of type long are expressed by adding an L suffix. For example:

0L // The decimal number zero (type 'long')

1L // The decimal number one (type 'long')
2147483648L // The value of Integer.MAX_VALUE + 1

long big = 2147483648; // ERROR

long big2 = 2147483648L; // OK

Note that the distinction between int and long literals is significant in other places. For example

int i = 2147483647;
long l = i + 1; // Produces a negative value because the operation is
// performed using 32 bit arithmetic, and the
// addition overflows
long l2 = i + 1L; // Produces the (intuitively) correct value.

Reference: JLS 3.10.1 - Integer Literals

Section 12.9: Floating-point literals

Floating point literals provide values that can be used where you need a float or double instance. There are three
kinds of floating point literal.

Simple decimal forms

Scaled decimal forms
Hexadecimal forms

(The JLS syntax rules combine the two decimal forms into a single form. We treat them separately for ease of
explanation.)

Java® Notes for Professionals 55

There are distinct literal types for float and double literals, expressed using suffixes. The various forms use letters
to express different things. These letters are case insensitive.

Simple decimal forms

The simplest form of floating point literal consists of one or more decimal digits and a decimal point (.) and an
optional suffix (f, F, d or D). The optional suffix allows you to specify that the literal is a float (f or F) or double (d or
D) value. The default (when no suffix is specified) is double.

For example

0.0 // this denotes zero

.0 // this also denotes zero
0. // this also denotes zero
3.14159 // this denotes Pi, accurate to (approximately!) 5 decimal places.
1.0F // a `float` literal
1.0D // a `double` literal. (`double` is the default if no suffix is given)

In fact, decimal digits followed by a suffix is also a floating point literal.

1F // means the same thing as 1.0F

The meaning of a decimal literal is the IEEE floating point number that is closest to the infinite precision
mathematical Real number denoted by the decimal floating point form. This conceptual value is converted to IEEE
binary floating point representation using round to nearest. (The precise semantics of decimal conversion are
specified in the javadocs for Double.valueOf(String) and Float.valueOf(String), bearing in mind that there are
differences in the number syntaxes.)

Scaled decimal forms

Scaled decimal forms consist of simple decimal with an exponent part introduced by an E or e, and followed by a
signed integer. The exponent part is a short hand for multiplying the decimal form by a power of ten, as shown in
the examples below. There is also an optional suffix to distinguish float and double literals. Here are some
examples:

1.0E1 // this means 1.0 x 10^1 ... or 10.0 (double)

1E-1D // this means 1.0 x 10^(-1) ... or 0.1 (double)
1.0e10f // this means 1.0 x 10^(10) ... or 10000000000.0 (float)

The size of a literal is limited by the representation (float or double). It is a compilation error if the scale factor
results in a value that is too large or too small.

Hexadecimal forms

Starting with Java 6, it is possible to express floating point literals in hexadecimal. The hexadecimal form have an
analogous syntax to the simple and scaled decimal forms with the following differences:

1. Every hexadecimal floating point literal starts with a zero (0) and then an x or X.
2. The digits of the number (but not the exponent part!) also include the hexadecimal digits a through f and
their uppercase equivalents.
3. The exponent is mandatory, and is introduced by the letter p (or P) instead of an e or E. The exponent
represents a scaling factor that is a power of 2 instead of a power of 10.

Here are some examples:

Java® Notes for Professionals 56

0x0.0p0f // this is zero expressed in hexadecimal form (`float`)
0xff.0p19 // this is 255.0 x 2^19 (`double`)

Advice: since hexadecimal floating-point forms are unfamiliar to most Java programmers, it is advisable to use them
sparingly.

Underscores

Starting with Java 7, underscores are permitted within the digit strings in all three forms of floating point literal. This
applies to the "exponent" parts as well. See Using underscores to improve readability.

Special cases

It is a compilation error if a floating point literal denotes a number that is too large or too small to represent in the
selected representation; i.e. if the number would overflow to +INF or -INF, or underflow to 0.0. However, it is legal
for a literal to represent a non-zero denormalized number.

The floating point literal syntax does not provide literal representations for IEEE 754 special values such as the INF
and NaN values. If you need to express them in source code, the recommended way is to use the constants defined
by the java.lang.Float and java.lang.Double; e.g. Float.NaN, Float.NEGATIVE_INFINITY and
Float.POSITIVE_INFINITY.

Java® Notes for Professionals 57

Chapter 13: Operators
Operators in Java programming language are special symbols that perform specific operations on one, two, or
three operands, and then return a result.

Section 13.1: The Increment/Decrement Operators (++/--)

Variables can be incremented or decremented by 1 using the ++ and

--

operators, respectively.

When the ++ and

--

operators follow variables, they are called post-increment and post-decrement respectively.
int a = 10;
a++; // a now equals 11
a--; // a now equals 10 again

When the ++ and

--

operators precede the variables the operations are called pre-increment and pre-decrement respectively.
int x = 10;
--x; // x now equals 9
++x; // x now equals 10

If the operator precedes the variable, the value of the expression is the value of the variable after being
incremented or decremented. If the operator follows the variable, the value of the expression is the value of the
variable prior to being incremented or decremented.

int x=10;

System.out.println("x=" + x + " x=" + x++ + " x=" + x); // outputs x=10 x=10 x=11
System.out.println("x=" + x + " x=" + ++x + " x=" + x); // outputs x=11 x=12 x=12
System.out.println("x=" + x + " x=" + x-- + " x=" + x); // outputs x=12 x=12 x=11
System.out.println("x=" + x + " x=" + --x + " x=" + x); // outputs x=11 x=10 x=10

Be careful not to overwrite post-increments or decrements. This happens if you use a post-in/decrement operator
at the end of an expression which is reassigned to the in/decremented variable itself. The in/decrement will not
have an effect. Even though the variable on the left hand side is incremented correctly, its value will be immediately
overwritten with the previously evaluated result from the right hand side of the expression:

int x = 0;
x = x++ + 1 + x++; // x = 0 + 1 + 1
// do not do this - the last increment has no effect (bug!)
System.out.println(x); // prints 2 (not 3!)

Correct:

int x = 0;
x = x++ + 1 + x; // evaluates to x = 0 + 1 + 1

Java® Notes for Professionals 58

x++; // adds 1
System.out.println(x); // prints 3

Section 13.2: The Conditional Operator (? :)

Syntax

{condition-to-evaluate} ? {statement-executed-on-true} : {statement-executed-on-false}

As shown in the syntax, the Conditional Operator (also known as the Ternary Operator1) uses the ? (question mark)
and : (colon) characters to enable a conditional expression of two possible outcomes. It can be used to replace
longer if-else blocks to return one of two values based on condition.

result = testCondition ? value1 : value2

Is equivalent to

if (testCondition) {
result = value1;
} else {
result = value2;
}

It can be read as “If testCondition is true, set result to value1; otherwise, set result to value2”.

For example:

// get absolute value using conditional operator

a = -10;
int absValue = a < 0 ? -a : a;
System.out.println("abs = " + absValue); // prints "abs = 10"

Is equivalent to

// get absolute value using if/else loop

a = -10;
int absValue;
if (a < 0) {
absValue = -a;
} else {
absValue = a;
}
System.out.println("abs = " + absValue); // prints "abs = 10"

Common Usage

You can use the conditional operator for conditional assignments (like null checking).

String x = y != null ? y.toString() : ""; //where y is an object

This example is equivalent to:

String x = "";

if (y != null) {
x = y.toString();
}

Java® Notes for Professionals 59

Since the Conditional Operator has the second-lowest precedence, above the Assignment Operators, there is rarely
a need for use parenthesis around the condition, but parenthesis is required around the entire Conditional
Operator construct when combined with other operators:

// no parenthesis needed for expressions in the 3 parts

10 <= a && a < 19 ? b * 5 : b * 7

// parenthesis required
7 * (a > 0 ? 2 : 5)

Conditional operators nesting can also be done in the third part, where it works more like chaining or like a switch
statement.

a ? "a is true" :
b ? "a is false, b is true" :
c ? "a and b are false, c is true" :
"a, b, and c are false"

//Operator precedence can be illustrated with parenthesis:

a ? x : (b ? y : (c ? z : w))

Footnote:

1 - Both the Java Language Specification and the Java Tutorial call the (? :) operator the Conditional Operator. The
Tutorial says that it is "also known as the Ternary Operator" as it is (currently) the only ternary operator defined by
Java. The "Conditional Operator" terminology is consistent with C and C++ and other languages with an equivalent
operator.

Section 13.3: The Bitwise and Logical Operators (~, &, |, ^)

The Java language provides 4 operators that perform bitwise or logical operations on integer or boolean operands.

The complement (~) operator is a unary operator that performs a bitwise or logical inversion of the bits of
one operand; see JLS 15.15.5..
The AND (&) operator is a binary operator that performs a bitwise or logical "and" of two operands; see JLS
15.22.2..
The OR (|) operator is a binary operator that performs a bitwise or logical "inclusive or" of two operands; see
JLS 15.22.2..
The XOR (^) operator is a binary operator that performs a bitwise or logical "exclusive or" of two operands;
see JLS 15.22.2..

The logical operations performed by these operators when the operands are booleans can be summarized as
follows:

A B ~A A & B A | B A ^ B
001 0 0 0
011 0 1 1
100 0 1 1
110 1 1 0

Note that for integer operands, the above table describes what happens for individual bits. The operators actually
operate on all 32 or 64 bits of the operand or operands in parallel.

Operand types and result types.

Java® Notes for Professionals 60

The usual arithmetic conversions apply when the operands are integers. Common use-cases for the bitwise
operators

The ~ operator is used to reverse a boolean value, or change all the bits in an integer operand.

The & operator is used for "masking out" some of the bits in an integer operand. For example:

int word = 0b00101010;

int mask = 0b00000011; // Mask for masking out all but the bottom
// two bits of a word
int lowBits = word & mask; // -> 0b00000010
int highBits = word & ~mask; // -> 0b00101000

The | operator is used to combine the truth values of two operands. For example:

int word2 = 0b01011111;

// Combine the bottom 2 bits of word1 with the top 30 bits of word2
int combined = (word & mask) | (word2 & ~mask); // -> 0b01011110

The ^ operator is used for toggling or "flipping" bits:

int word3 = 0b00101010;

int word4 = word3 ^ mask; // -> 0b00101001

For more examples of the use of the bitwise operators, see Bit Manipulation

Section 13.4: The String Concatenation Operator (+)

The + symbol can mean three distinct operators in Java:

If there is no operand before the +, then it is the unary Plus operator.

If there are two operands, and they are both numeric. then it is the binary Addition operator.
If there are two operands, and at least one of them is a String, then it it the binary Concatenation operator.

In the simple case, the Concatenation operator joins two strings to give a third string. For example:

String s1 = "a String";

String s2 = "This is " + s1; // s2 contains "This is a String"

When one of the two operands is not a string, it is converted to a String as follows:

An operand whose type is a primitive type is converted as if by calling toString() on the boxed value.

An operand whose type is a reference type is converted by calling the operand's toString() method. If the
operand is null, or if the toString() method returns null, then the string literal "null" is used instead.

For example:

int one = 1;
String s3 = "One is " + one; // s3 contains "One is 1"
String s4 = null + " is null"; // s4 contains "null is null"
String s5 = "{1} is " + new int[]{1}; // s5 contains something like
// "{} is [I@xxxxxxxx"

The explanation for the s5 example is that the toString() method on array types is inherited from
java.lang.Object, and the behavior is to produce a string that consists of the type name, and the object's identity

Java® Notes for Professionals 61

hashcode.

The Concatenation operator is specified to create a new String object, except in the case where the expression is a
Constant Expression. In the latter case, the expression is evaluated at compile type, and its runtime value is
equivalent to a string literal. This means that there is no runtime overhead in splitting a long string literal like this:

String typing = "The quick brown fox " +

"jumped over the " +
"lazy dog"; // constant expression

Optimization and efficiency

As noted above, with the exception of constant expressions, each string concatenation expression creates a new
String object. Consider this code:

public String stars(int count) {

String res = "";
for (int i = 0; i < count; i++) {
res = res + "*";
}
return res;
}

In the method above, each iteration of the loop will create a new String that is one character longer than the
previous iteration. Each concatenation copies all of the characters in the operand strings to form the new String.
Thus, stars(N) will:

create N new String objects, and throw away all but the last one,
copy N * (N + 1) / 2 characters, and
generate O(N^2) bytes of garbage.

This is very expensive for large N. Indeed, any code that concatenates strings in a loop is liable to have this problem.
A better way to write this would be as follows:

public String stars(int count) {

// Create a string builder with capacity 'count'
StringBuilder sb = new StringBuilder(count);
for (int i = 0; i < count; i++) {
sb.append("*");
}
return sb.toString();
}

Ideally, you should set the capacity of the StringBuilder, but if this is not practical, the class will automatically grow
the backing array that the builder uses to hold characters. (Note: the implementation expands the backing array
exponentially. This strategy keeps that amount of character copying to a O(N) rather than O(N^2).)

Some people apply this pattern to all string concatenations. However, this is unnecessary because the JLS allows a
Java compiler to optimize string concatenations within a single expression. For example:

String s1 = ...;
String s2 = ...;
String test = "Hello " + s1 + ". Welcome to " + s2 + "\n";

will typically be optimized by the bytecode compiler to something like this;

StringBuilder tmp = new StringBuilder();

Java® Notes for Professionals 62

tmp.append("Hello ")
tmp.append(s1 == null ? "null" + s1);
tmp.append("Welcome to ");
tmp.append(s2 == null ? "null" + s2);
tmp.append("\n");
String test = tmp.toString();

(The JIT compiler may optimize that further if it can deduce that s1 or s2 cannot be null.) But note that this
optimization is only permitted within a single expression.

In short, if you are concerned about the efficiency of string concatenations:

Do hand-optimize if you are doing repeated concatenation in a loop (or similar).

Don't hand-optimize a single concatenation expression.

Section 13.5: The Arithmetic Operators (+, -, *, /, %)

The Java language provides 7 operators that perform arithmetic on integer and floating point values.

There are two + operators:

The binary addition operator adds one number to another one. (There is also a binary + operator that
performs string concatenation. That is described in a separate example.)
The unary plus operator does nothing apart from triggering numeric promotion (see below)
There are two

operators:
The binary subtraction operator subtracts one number from another one.
The unary minus operator is equivalent to subtracting its operand from zero.
The binary multiply operator (*) multiplies one number by another.
The binary divide operator (/) divides one number by another.
The binary remainder1 operator (%) calculates the remainder when one number is divided by another.

1. This is often incorrectly referred to as the "modulus" operator. "Remainder" is the term that is used by the JLS.
"Modulus" and "remainder" are not the same thing.

Operand and result types, and numeric promotion

The operators require numeric operands and produce numeric results. The operand types can be any primitive
numeric type (i.e. byte, short, char, int, long, float or double) or any numeric wrapper type define in java.lang;
i.e. (Byte, Character, Short, Integer, Long, Float or Double.

The result type is determined base on the types of the operand or operands, as follows:

If either of the operands is a double or Double, then the result type is double.
Otherwise, if either of the operands is a float or Float, then the result type is float.
Otherwise, if either of the operands is a long or Long, then the result type is long.
Otherwise, the result type is int. This covers byte, short and char operands as well as `int.

The result type of the operation determines how the arithmetic operation is performed, and how the operands are
handled

If the result type is double, the operands are promoted to double, and the operation is performed using 64-
bit (double precision binary) IEE 754 floating point arithmetic.
If the result type is float, the operands are promoted to float, and the operation is performed using 32-bit

Java® Notes for Professionals 63

 (single precision binary) IEE 754 floating point arithmetic.
If the result type is long, the operands are promoted to long, and the operation is performed using 64-bit
signed twos-complement binary integer arithmetic.
If the result type is int, the operands are promoted to int, and the operation is performed using 32-bit
signed twos-complement binary integer arithmetic.

Promotion is performed in two stages:

If the operand type is a wrapper type, the operand value is unboxed to a value of the corresponding primitive
type.
If necessary, the primitive type is promoted to the required type:
Promotion of integers to int or long is loss-less.
Promotion of float to double is loss-less.
Promotion of an integer to a floating point value can lead to loss of precision. The conversion is
performed using IEE 768 "round-to-nearest" semantics.

The meaning of division

The / operator divides the left-hand operand n (the dividend) and the right-hand operand d (the divisor) and
produces the result q (the quotient).

Java integer division rounds towards zero. The JLS Section 15.17.2 specifies the behavior of Java integer division as
follows:

The quotient produced for operands n and d is an integer value q whose magnitude is as large as possible
while satisfying |d ? q| ? |n|. Moreover, q is positive when |n| ? |d| and n and d have the same sign,
but q is negative when |n| ? |d| and n and d have opposite signs.

There are a couple of special cases:

If the n is MIN_VALUE, and the divisor is -1, then integer overflow occurs and the result is MIN_VALUE. No
exception is thrown in this case.
If d is 0, then `ArithmeticException is thrown.

Java floating point division has more edge cases to consider. However the basic idea is that the result q is the value
that is closest to satisfying d . q = n.

Floating point division will never result in an exception. Instead, operations that divide by zero result in an INF and
NaN values; see below.

The meaning of remainder

Unlike C and C++, the remainder operator in Java works with both integer and floating point operations.

For integer cases, the result of a % b is defined to be the number r such that (a / b) * b + r is equal to a, where
/, * and + are the appropriate Java integer operators. This applies in all cases except when b is zero. That case,
remainder results in an ArithmeticException.

It follows from the above definition that a % b can be negative only if a is negative, and it be positive only if a is
positive. Moreover, the magnitude of a % b is always less than the magnitude of b.

Floating point remainder operation is a generalization of the integer case. The result of a % b is the remainder r is
defined by the mathematical relation r = a - (b ? q) where:

Java® Notes for Professionals 64

 q is an integer,
it is negative only if a / b is negative an positive only if a / b is positive, and
its magnitude is as large as possible without exceeding the magnitude of the true mathematical quotient of a
and b.

Floating point remainder can produce INF and NaN values in edge-cases such as when b is zero; see below. It will not
throw an exception.

Important note:

The result of a floating-point remainder operation as computed by % is not the same as that produced by
the remainder operation defined by IEEE 754. The IEEE 754 remainder may be computed using the
Math.IEEEremainder library method.

Integer Overflow

Java 32 and 64 bit integer values are signed and use twos-complement binary representation. For example, the
range of numbers representable as (32 bit) int -231 through +231 - 1.

When you add, subtract or multiple two N bit integers (N == 32 or 64), the result of the operation may be too large
to represent as an N bit integer. In this case, the operation leads to integer overflow, and the result can be computed
as follows:

The mathematical operation is performed to give a intermediate two's-complement representation of the

entire number. This representation will be larger than N bits.
The bottom 32 or 64 bits of the intermediate representation are used as the result.

It should be noted that integer overflow does not result in exceptions under any circumstances.

Floating point INF and NAN values

Java uses IEE 754 floating point representations for float and double. These representations have some special
values for representing values that fall outside of the domain of Real numbers:

The "infinite" or INF values denote numbers that are too large. The +INF value denote numbers that are too
large and positive. The -INF value denote numbers that are too large and negative.
The "indefinite" / "not a number" or NaN denote values resulting from meaningless operations.

The INF values are produced by floating operations that cause overflow, or by division by zero.

The NaN values are produced by dividing zero by zero, or computing zero remainder zero.

Surprisingly, it is possible perform arithmetic using INF and NaN operands without triggering exceptions. For
example:

Adding +INF and a finite value gives +INF.

Adding +INF and +INF gives +INF.
Adding +INF and -INF gives NaN.
Dividing by INF gives either +0.0 or -0.0.
All operations with one or more NaN operands give NaN.

For full details, please refer to the relevant subsections of JLS 15. Note that this is largely "academic". For typical
calculations, an INF or NaN means that something has gone wrong; e.g. you have incomplete or incorrect input data,

Java® Notes for Professionals 65

or the calculation has been programmed incorrectly.

Section 13.6: The Shift Operators (<<, >> and >>>)

The Java language provides three operator for performing bitwise shifting on 32 and 64 bit integer values. These
are all binary operators with the first operand being the value to be shifted, and the second operand saying how far
to shift.

The << or left shift operator shifts the value given by the first operand leftwards by the number of bit positions
given by the second operand. The empty positions at the right end are filled with zeros.

The '>>' or arithmetic shift operator shifts the value given by the first operand rightwards by the number of bit
positions given by the second operand. The empty positions at the left end are filled by copying the left-most
bit. This process is known as sign extension.

The '>>>' or logical right shift operator shifts the value given by the first operand rightwards by the number of
bit positions given by the second operand. The empty positions at the left end are filled with zeros.

Notes:

1. These operators require an int or long value as the first operand, and produce a value with the same type as
the first operand. (You will need to use an explicit type cast when assigning the result of a shift to a byte,
short or char variable.)

2. If you use a shift operator with a first operand that is a byte, char or short, it is promoted to an int and the
operation produces an int.)

3. The second operand is reduced modulo the number of bits of the operation to give the amount of the shift. For
more about the mod mathematical concept, see Modulus examples.

4. The bits that are shifted off the left or right end by the operation are discarded. (Java does not provide a
primitive "rotate" operator.)

5. The arithmetic shift operator is equivalent dividing a (two's complement) number by a power of 2.

6. The left shift operator is equivalent multiplying a (two's complement) number by a power of 2.

The following table will help you see the effects of the three shift operators. (The numbers have been expressed in
binary notation to aid vizualization.)

Operand1 Operand2 << >> >>>

0b0000000000001011 0 0b0000000000001011 0b0000000000001011 0b0000000000001011
0b0000000000001011 1 0b0000000000010110 0b0000000000000101 0b0000000000000101
0b0000000000001011 2 0b0000000000101100 0b0000000000000010 0b0000000000000010
0b0000000000001011 28 0b1011000000000000 0b0000000000000000 0b0000000000000000
0b0000000000001011 31 0b1000000000000000 0b0000000000000000 0b0000000000000000
0b0000000000001011 32 0b0000000000001011 0b0000000000001011 0b0000000000001011
... ... ... ... ...
0b1000000000001011 0 0b1000000000001011 0b1000000000001011 0b1000000000001011
0b1000000000001011 1 0b0000000000010110 0b1100000000000101 0b0100000000000101
0b1000000000001011 2 0b0000000000101100 0b1110000000000010 0b00100000000000100
0b1000000000001011 31 0b1000000000000000 0b1111111111111111 0b0000000000000001

There examples of the user of shift operators in Bit manipulation

Java® Notes for Professionals 66

Section 13.7: The Instanceof Operator
This operator checks whether the object is of a particular class/interface type. instanceof operator is written as:

( Object reference variable ) instanceof (class/interface type)

Example:

public class Test {

public static void main(String args[]){

String name = "Buyya";
// following will return true since name is type of String
boolean result = name instanceof String;
System.out.println( result );
}
}

This would produce the following result:

true

This operator will still return true if the object being compared is the assignment compatible with the type on the
right.

Example:

class Vehicle {}

public class Car extends Vehicle {

public static void main(String args[]){
Vehicle a = new Car();
boolean result = a instanceof Car;
System.out.println( result );
}
}

This would produce the following result:

true

Section 13.8: The Assignment Operators (=, +=, -=, *=, /=, %=,
<<=, >>= , >>>=, &=, |= and ^=)
The left hand operand for these operators must be a either a non-final variable or an element of an array. The right
hand operand must be assignment compatible with the left hand operand. This means that either the types must be
the same, or the right operand type must be convertible to the left operands type by a combination of boxing,
unboxing or widening. (For complete details refer to JLS 5.2.)

The precise meaning of the "operation and assign" operators is specified by JLS 15.26.2 as:

A compound assignment expression of the form E1 op= E2 is equivalent to E1 = (T) ((E1) op (E2)),
where T is the type of E1, except that E1 is evaluated only once.

Java® Notes for Professionals 67

Note that there is an implicit type-cast before the final assignment.

1.

The simple assignment operator: assigns the value of the right hand operand to the left hand operand.

Example: c = a + b will add the value of a + b to the value of c and assign it to c

2. +=

The "add and assign" operator: adds the value of right hand operand to the value of the left hand operand and
assigns the result to left hand operand. If the left hand operand has type String, then this a "concatenate and
assign" operator.

Example: c += a is roughly the same as c = c + a

3. -=

The "subtract and assign" operator: subtracts the value of the right operand from the value of the left hand
operand and assign the result to left hand operand.

Example: c -= a is roughly the same as c = c - a

4. *=

The "multiply and assign" operator: multiplies the value of the right hand operand by the value of the left hand
operand and assign the result to left hand operand. .

Example: c *= a is roughly the same as c = c * a

5. /=

The "divide and assign" operator: divides the value of the right hand operand by the value of the left hand operand
and assign the result to left hand operand.

Example: c /*= a is roughly the same as c = c / a

6. %=

The "modulus and assign" operator: calculates the modulus of the value of the right hand operand by the value of
the left hand operand and assign the result to left hand operand.

Example: c %*= a is roughly the same as c = c % a

Java® Notes for Professionals 68

7. <<=

The "left shift and assign" operator.

Example: c <<= 2 is roughly the same as c = c << 2

8. >>=

The "arithmetic right shift and assign" operator.

Example: c >>= 2 is roughly the same as c = c >> 2

9. >>>=

The "logical right shift and assign" operator.

Example: c >>>= 2 is roughly the same as c = c >>> 2

10. &=

The "bitwise and and assign" operator.

Example: c &= 2 is roughly the same as c = c & 2

11. |=

The "bitwise or and assign" operator.

Example: c |= 2 is roughly the same as c = c | 2

12. ^=

The "bitwise exclusive or and assign" operator.

Example: c ^= 2 is roughly the same as c = c ^ 2

Section 13.9: The conditional-and and conditional-or

Operators ( && and || )
Java provides a conditional-and and a conditional-or operator, that both take one or two operands of type boolean
and produce a boolean result. These are:

&& - the conditional-AND operator,

|| - the conditional-OR operators. The evaluation of <left-expr> && <right-expr> is equivalent to the
following pseudo-code:

Java® Notes for Professionals 69

 {
boolean L = evaluate(<left-expr>);
if (L) {
return evaluate(<right-expr>);
} else {
// short-circuit the evaluation of the 2nd operand expression
return false;
}
}

The evaluation of <left-expr> || <right-expr> is equivalent to the following pseudo-code:

{
boolean L = evaluate(<left-expr>);
if (!L) {
return evaluate(<right-expr>);
} else {
// short-circuit the evaluation of the 2nd operand expression
return true;
}
}

As the pseudo-code above illustrates, the behavior of the short-circuit operators are equivalent to using if / else
statements.

Example - using && as a guard in an expression

The following example shows the most common usage pattern for the && operator. Compare these two versions of
a method to test if a supplied Integer is zero.

public boolean isZero(Integer value) {

return value == 0;
}

public boolean isZero(Integer value) {

return value != null && value == 0;
}

The first version works in most cases, but if the value argument is null, then a NullPointerException will be
thrown.

In the second version we have added a "guard" test. The value != null && value == 0 expression is evaluated by
first performing the value != null test. If the null test succeeds (i.e. it evaluates to true) then the value == 0
expression is evaluated. If the null test fails, then the evaluation of value == 0 is skipped (short-circuited), and we
don't get a NullPointerException.

Example - using && to avoid a costly calculation

The following example shows how && can be used to avoid a relatively costly calculation:

public boolean verify(int value, boolean needPrime) {

return !needPrime | isPrime(value);
}

public boolean verify(int value, boolean needPrime) {

return !needPrime || isPrime(value);
}

Java® Notes for Professionals 70

In the first version, both operands of the | will always be evaluated, so the (expensive) isPrime method will be
called unnecessarily. The second version avoids the unnecessary call by using || instead of |.

Section 13.10: The Relational Operators (<, <=, >, >=)

The operators <, <=, > and >= are binary operators for comparing numeric types. The meaning of the operators is as
you would expect. For example, if a and b are declared as any of byte, short, char, int, long, float, double or the
corresponding boxed types:

- `a < b` tests if the value of `a` is less than the value of `b`.
- `a <= b` tests if the value of `a` is less than or equal to the value of `b`.
- `a > b` tests if the value of `a` is greater than the value of `b`.
- `a >= b` tests if the value of `a` is greater than or equal to the value of `b`.

The result type for these operators is boolean in all cases.

Relational operators can be used to compare numbers with different types. For example:

int i = 1;
long l = 2;
if (i < l) {
System.out.println("i is smaller");
}

Relational operators can be used when either or both numbers are instances of boxed numeric types. For example:

Integer i = 1; // 1 is autoboxed to an Integer

Integer j = 2; // 2 is autoboxed to an Integer
if (i < j) {
System.out.println("i is smaller");
}

The precise behavior is summarized as follows:

1. If one of the operands is a boxed type, it is unboxed.

2. If either of the operands now a byte, short or char, it is promoted to an int.
3. If the types of the operands are not the same, then the operand with the "smaller" type is promoted to the
"larger" type.
4. The comparison is performed on the resulting int, long, float or double values.

You need to be careful with relational comparisons that involve floating point numbers:

Expressions that compute floating point numbers often incur rounding errors due to the fact that the
computer floating-point representations have limited precision.
When comparing an integer type and a floating point type, the conversion of the integer to floating point can
also lead to rounding errors.

Finally, Java does bit support the use of relational operators with any types other than the ones listed above. For
example, you cannot use these operators to compare strings, arrays of numbers, and so on.

Section 13.11: The Equality Operators (==, !=)

The

==

Java® Notes for Professionals 71

and != operators are binary operators that evaluate to true or false depending on whether the operands are
equal. The

==

operator gives true if the operands are equal and false otherwise. The != operator gives false if the operands are
equal and true otherwise.

These operators can be used operands with primitive and reference types, but the behavior is significantly
different. According to the JLS, there are actually three distinct sets of these operators:

The Boolean

==

and != operators.
The Numeric

==

and != operators.
The Reference

==

and != operators.

However, in all cases, the result type of the

==

and != operators is boolean.

The Numeric

==

and != operators

When one (or both) of the operands of an

==

or != operator is a primitive numeric type (byte, short, char, int, long, float or double), the operator is a numeric
comparison. The second operand must be either a primitive numeric type, or a boxed numeric type.

The behavior other numeric operators is as follows:

1. If one of the operands is a boxed type, it is unboxed.

2. If either of the operands now a byte, short or char, it is promoted to an int.
3. If the types of the operands are not the same, then the operand with the "smaller" type is promoted to the
"larger" type.
4. The comparison is then carried out as follows:
If the promoted operands are int or long then the values are tested to see if they are identical.
If the promoted operands are float or double then:
the two versions of zero (+0.0 and -0.0) are treated as equal
a NaN value is treated as not equals to anything, and
other values are equal if their IEEE 754 representations are identical.

Note: you need to be careful when using

Java® Notes for Professionals 72

==

and != to compare floating point values.

The Boolean

==

and != operators

If both operands are boolean, or one is boolean and the other is Boolean, these operators the Boolean

==

and != operators. The behavior is as follows:

1. If one of the operands is a Boolean, it is unboxed.

2. The unboxed operands are tested and the boolean result is calculated according to the following truth table

A B A == B A != B
false false true false
false true false true
true false false true
true true true false

There are two "pitfalls" that make it advisable to use

==

and != sparingly with truth values:

If you use

==

or != to compare two Boolean objects, then the Reference operators are used. This may give an unexpected
result; see Pitfall: using == to compare primitive wrappers objects such as Integer

The

==

operator can easily be mistyped as

. For most operand types, this mistake leads to a compilation error. However, for boolean and Boolean
operands the mistake leads to incorrect runtime behavior; see Pitfall - Using '==' to test a boolean

The Reference

==

and != operators

If both operands are object references, the

==

and != operators test if the two operands refer to the same object. This often not what you want. To test if two
objects are equal by value, the .equals() method should be used instead.
String s1 = "We are equal";
String s2 = new String("We are equal");

Java® Notes for Professionals 73

s1.equals(s2); // true

// WARNING - don't use == or != with String values

s1 == s2; // false

Warning: using

==

and != to compare String values is incorrect in most cases; see

http://stackoverflow.com/documentation/java/4388/java-pitfalls/16290/using-to-compare-strings . A similar
problem applies to primitive wrapper types; see
http://stackoverflow.com/documentation/java/4388/java-pitfalls/8996/using-to-compare-primitive-wrappers-objects
-such-as-integer .
About the NaN edge-cases

JLS 15.21.1 states the following:

If either operand is NaN, then the result of

==

is false but the result of != is true. Indeed, the test x != x is true if and only if the value of x is NaN.

This behavior is (to most programmers) unexpected. If you test if a NaN value is equal to itself, the answer is "No it
isn't!". In other words,

==

is not reflexive for NaN values.

However, this is not a Java "oddity", this behavior is specified in the IEEE 754 floating-point standards, and you will
find that it is implemented by most modern programming languages. (For more information, see
http://stackoverflow.com/a/1573715/139985 ... noting that this is written by someone who was "in the room when
the decisions were made"!)

Section 13.12: The Lambda operator ( -> )

From Java 8 onwards, the Lambda operator ( -> ) is the operator used to introduce a Lambda Expression. There are
two common syntaxes, as illustrated by these examples:

Version ≥ Java SE 8
a -> a + 1 // a lambda that adds one to its argument
a -> { return a + 1; } // an equivalent lambda using a block.

A lambda expression defines an anonymous function, or more correctly an instance of an anonymous class that
implements a functional interface.

(This example is included here for completeness. Refer to the Lambda Expressions topic for the full treatment.)

Java® Notes for Professionals 74

Chapter 14: Primitive Data Types
The 8 primitive data types byte, short, int, long, char, boolean, float, and double are the types that store most
raw numerical data in Java programs.

Section 14.1: The char primitive

A char can store a single 16-bit Unicode character. A character literal is enclosed in single quotes

char myChar = 'u';

char myChar2 = '5';
char myChar3 = 65; // myChar3 == 'A'

It has a minimum value of \u0000 (0 in the decimal representation, also called the null character) and a maximum
value of \uffff (65,535).

The default value of a char is \u0000.

char defaultChar; // defaultChar == \u0000

In order to define a char of ' value an escape sequence (character preceded by a backslash) has to be used:

char singleQuote = '\'';

There are also other escape sequences:

char tab = '\t';

char backspace = '\b';
char newline = '\n';
char carriageReturn = '\r';
char formfeed = '\f';
char singleQuote = '\'';
char doubleQuote = '\"'; // escaping redundant here; '"' would be the same; however still allowed
char backslash = '\\';
char unicodeChar = '\uXXXX' // XXXX represents the Unicode-value of the character you want to
display

You can declare a char of any Unicode character.

char heart = '\u2764';

System.out.println(Character.toString(heart)); // Prints a line containing "❤".

It is also possible to add to a char. e.g. to iterate through every lower-case letter, you could do to the following:

for (int i = 0; i <= 26; i++) {

char letter = (char) ('a' + i);
System.out.println(letter);
}

Section 14.2: Primitive Types Cheatsheet

Table showing size and values range of all primitive types:

default
data type numeric representation range of values
value

Java® Notes for Professionals 75

boolean n/a false and true false
byte 8-bit signed -27 to 27 - 1 0
-128 to +127
short 16-bit signed -215 to 215 - 1 0
-32,768 to +32,767
int 32-bit signed -231 to 231 - 1 0
-2,147,483,648 to +2,147,483,647
long 64-bit signed -263 to 263 - 1 0L
-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
float 32-bit floating point 1.401298464e-45 to 3.402823466e+38 (positive or negative) 0.0F
4.94065645841246544e-324d to 1.79769313486231570e+308d
double 64-bit floating point 0.0D
(positive or negative)
char 16-bit unsigned 0 to 216 - 1 0
0 to 65,535

Notes:

1. The Java Language Specification mandates that signed integral types (byte through long) use binary twos-
complement representation, and the floating point types use standard IEE 754 binary floating point
representations.
2. Java 8 and later provide methods to perform unsigned arithmetic operations on int and long. While these
methods allow a program to treat values of the respective types as unsigned, the types remain signed types.
3. The smallest floating point shown above are subnormal; i.e. they have less precision than a normal value. The
smallest normal numbers are 1.175494351e?38 and 2.2250738585072014e?308
4. A char conventionally represents a Unicode / UTF-16 code unit.
5. Although a boolean contains just one bit of information, its size in memory varies depending on the Java
Virtual Machine implementation (see boolean type).

Section 14.3: The float primitive

A float is a single-precision 32-bit IEEE 754 floating point number. By default, decimals are interpreted as doubles.
To create a float, simply append an f to the decimal literal.

double doubleExample = 0.5; // without 'f' after digits = double

float floatExample = 0.5f; // with 'f' after digits = float

float myFloat = 92.7f; // this is a float...

float positiveFloat = 89.3f; // it can be positive,
float negativeFloat = -89.3f; // or negative
float integerFloat = 43.0f; // it can be a whole number (not an int)
float underZeroFloat = 0.0549f; // it can be a fractional value less than 0

Floats handle the five common arithmetical operations: addition, subtraction, multiplication, division, and modulus.

Note: The following may vary slightly as a result of floating point errors. Some results have been rounded for clarity and
readability purposes (i.e. the printed result of the addition example was actually 34.600002).

// addition
float result = 37.2f + -2.6f; // result: 34.6

// subtraction
float result = 45.1f - 10.3f; // result: 34.8

// multiplication
float result = 26.3f * 1.7f; // result: 44.71

Java® Notes for Professionals 76

// division
float result = 37.1f / 4.8f; // result: 7.729166

// modulus
float result = 37.1f % 4.8f; // result: 3.4999971

Because of the way floating point numbers are stored (i.e. in binary form), many numbers don't have an exact
representation.

float notExact = 3.1415926f;

System.out.println(notExact); // 3.1415925

While using float is fine for most applications, neither float nor double should be used to store exact
representations of decimal numbers (like monetary amounts), or numbers where higher precision is required.
Instead, the BigDecimal class should be used.

The default value of a float is 0.0f.

float defaultFloat; // defaultFloat == 0.0f

A float is precise to roughly an error of 1 in 10 million.

Note: Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.NaN are float values. NaN stands for results of
operations that cannot be determined, such as dividing 2 infinite values. Furthermore 0f and -0f are different, but

==

yields true:
float f1 = 0f;
float f2 = -0f;
System.out.println(f1 == f2); // true
System.out.println(1f / f1); // Infinity
System.out.println(1f / f2); // -Infinity
System.out.println(Float.POSITIVE_INFINITY / Float.POSITIVE_INFINITY); // NaN

Section 14.4: The int primitive

A primitive data type such as int holds values directly into the variable that is using it, meanwhile a variable that
was declared using Integer holds a reference to the value.

According to java API: "The Integer class wraps a value of the primitive type int in an object. An object of type
Integer contains a single field whose type is int."

By default, int is a 32-bit signed integer. It can store a minimum value of -231, and a maximum value of 231 - 1.

int example = -42;

int myInt = 284;
int anotherInt = 73;

int addedInts = myInt + anotherInt; // 284 + 73 = 357

int subtractedInts = myInt - anotherInt; // 284 - 73 = 211

If you need to store a number outside of this range, long should be used instead. Exceeding the value range of int
leads to an integer overflow, causing the value exceeding the range to be added to the opposite site of the range
(positive becomes negative and vise versa). The value is ((value - MIN_VALUE) % RANGE) + MIN_VALUE, or ((value
+ 2147483648) % 4294967296) - 2147483648

Java® Notes for Professionals 77

int demo = 2147483647; //maximum positive integer
System.out.println(demo); //prints 2147483647
demo = demo + 1; //leads to an integer overflow
System.out.println(demo); // prints -2147483648

The maximum and minimum values of int can be found at:

int high = Integer.MAX_VALUE; // high == 2147483647

int low = Integer.MIN_VALUE; // low == -2147483648

The default value of an int is 0

int defaultInt; // defaultInt == 0

Section 14.5: Converting Primitives

In Java, we can convert between integer values and floating-point values. Also, since every character corresponds to
a number in the Unicode encoding, char types can be converted to and from the integer and floating-point types.
boolean is the only primitive datatype that cannot be converted to or from any other primitive datatype.

There are two types of conversions: widening conversion and narrowing conversion.

A widening conversion is when a value of one datatype is converted to a value of another datatype that occupies
more bits than the former. There is no issue of data loss in this case.

Correspondingly, A narrowing conversion is when a value of one datatype is converted to a value of another
datatype that occupies fewer bits than the former. Data loss can occur in this case.

Java performs widening conversions automatically. But if you want to perform a narrowing conversion (if you are sure
that no data loss will occur), then you can force Java to perform the conversion using a language construct known
as a cast.

Widening Conversion:

int a = 1;
double d = a; // valid conversion to double, no cast needed (widening)

Narrowing Conversion:

double d = 18.96
int b = d; // invalid conversion to int, will throw a compile-time error
int b = (int) d; // valid conversion to int, but result is truncated (gets rounded down)
// This is type-casting
// Now, b = 18

Section 14.6: Memory consumption of primitives vs. boxed

primitives
Primitive Boxed Type Memory Size of primitive / boxed
boolean Boolean 1 byte / 16 bytes
byte Byte 1 byte / 16 bytes
short Short 2 bytes / 16 bytes
char Char 2 bytes / 16 bytes
int Integer 4 bytes / 16 bytes

Java® Notes for Professionals 78

long Long 8 bytes / 16 bytes
float Float 4 bytes / 16 bytes
double Double 8 bytes / 16 bytes

Boxed objects always require 8 bytes for type and memory management, and because the size of objects is always
a multiple of 8, boxed types all require 16 bytes total. In addition, each usage of a boxed object entails storing a
reference which accounts for another 4 or 8 bytes, depending on the JVM and JVM options.

In data-intensive operations, memory consumption can have a major impact on performance. Memory
consumption grows even more when using arrays: a float[5] array will require only 32 bytes; whereas a Float[5]
storing 5 distinct non-null values will require 112 bytes total (on 64 bit without compressed pointers, this increases
to 152 bytes).

Boxed value caches

The space overheads of the boxed types can be mitigated to a degree by the boxed value caches. Some of the
boxed types implement a cache of instances. For example, by default, the Integer class will cache instances to
represent numbers in the range -128 to +127. This does not, however, reduce the additional cost arising from the
additional memory indirection.

If you create an instance of a boxed type either by autoboxing or by calling the static valueOf(primitive) method,
the runtime system will attempt to use a cached value. If your application uses a lot of values in the range that is
cached, then this can substantially reduce the memory penalty of using boxed types. Certainly, if you are creating
boxed value instances "by hand", it is better to use valueOf rather than new. (The new operation always creates a
new instance.) If, however, the majority of your values are not in the cached range, it can be faster to call new and
save the cache lookup.

Section 14.7: The double primitive

A double is a double-precision 64-bit IEEE 754 floating point number.

double example = -7162.37;

double myDouble = 974.21;
double anotherDouble = 658.7;

double addedDoubles = myDouble + anotherDouble; // 315.51

double subtractedDoubles = myDouble - anotherDouble; // 1632.91

double scientificNotationDouble = 1.2e-3; // 0.0012

Because of the way floating point numbers are stored, many numbers don't have an exact representation.

double notExact = 1.32 - 0.42; // result should be 0.9

System.out.println(notExact); // 0.9000000000000001

While using double is fine for most applications, neither float nor double should be used to store precise numbers
such as currency. Instead, the BigDecimal class should be used

The default value of a double is 0.0d

public double defaultDouble; // defaultDouble == 0.0

Note: Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.NaN are double values. NaN stands for
results of operations that cannot be determined, such as dividing 2 infinite values. Furthermore 0d and -0d are
different, but

Java® Notes for Professionals 79

==

yields true:
double d1 = 0d;
double d2 = -0d;
System.out.println(d1 == d2); // true
System.out.println(1d / d1); // Infinity
System.out.println(1d / d2); // -Infinity
System.out.println(Double.POSITIVE_INFINITY / Double.POSITIVE_INFINITY); // NaN

Section 14.8: The long primitive

By default, long is a 64-bit signed integer (in Java 8, it can be either signed or unsigned). Signed, it can store a
minimum value of -263, and a maximum value of 263 - 1, and unsigned it can store a minimum value of 0 and a
maximum value of 264 - 1

long example = -42;

long myLong = 284;
long anotherLong = 73;

//an "L" must be appended to the end of the number, because by default,
//numbers are assumed to be the int type. Appending an "L" makes it a long
//as 549755813888 (2 ^ 39) is larger than the maximum value of an int (2^31 - 1),
//"L" must be appended
long bigNumber = 549755813888L;

long addedLongs = myLong + anotherLong; // 284 + 73 = 357

long subtractedLongs = myLong - anotherLong; // 284 - 73 = 211

The maximum and minimum values of long can be found at:

long high = Long.MAX_VALUE; // high == 9223372036854775807L

long low = Long.MIN_VALUE; // low == -9223372036854775808L

The default value of a long is 0L

long defaultLong; // defaultLong == 0L

Note: letter "L" appended at the end of long literal is case insensitive, however it is good practice to use capital as it
is easier to distinct from digit one:

2L == 2l; // true

Warning: Java caches Integer objects instances from the range -128 to 127. The reasoning is explained here:
https://blogs.oracle.com/darcy/entry/boxing_and_caches_integer_valueof

The following results can be found:

Long val1 = 127L;

Long val2 = 127L;

System.out.println(val1 == val2); // true

Long val3 = 128L;

Long val4 = 128L;

Java® Notes for Professionals 80

System.out.println(val3 == val4); // false

To properly compare 2 Object Long values, use the following code(From Java 1.7 onward):

Long val3 = 128L;

Long val4 = 128L;

System.out.println(Objects.equal(val3, val4)); // true

Comparing a primitive long to an Object long will not result in a false negative like comparing 2 objects with ==
does.

Section 14.9: The boolean primitive

A boolean can store one of two values, either true or false

boolean foo = true;

System.out.println("foo = " + foo); // foo = true

boolean bar = false;

System.out.println("bar = " + bar); // bar = false

boolean notFoo = !foo;

System.out.println("notFoo = " + notFoo); // notFoo = false

boolean fooAndBar = foo && bar;

System.out.println("fooAndBar = " + fooAndBar); // fooAndBar = false

boolean fooOrBar = foo || bar;

System.out.println("fooOrBar = " + fooOrBar); // fooOrBar = true

boolean fooXorBar = foo ^ bar;

System.out.println("fooXorBar = " + fooXorBar); // fooXorBar = true

The default value of a boolean is false

boolean defaultBoolean; // defaultBoolean == false

Section 14.10: The byte primitive

A byte is a 8-bit signed integer. It can store a minimum value of -27 (-128), and a maximum value of 27 - 1 (127)

byte example = -36;

byte myByte = 96;
byte anotherByte = 7;

byte addedBytes = (byte) (myByte + anotherByte); // 103

byte subtractedBytes = (byte) (myBytes - anotherByte); // 89

The maximum and minimum values of byte can be found at:

byte high = Byte.MAX_VALUE; // high == 127

byte low = Byte.MIN_VALUE; // low == -128

The default value of a byte is 0

Java® Notes for Professionals 81

byte defaultByte; // defaultByte == 0

Section 14.11: Negative value representation

Java and most other languages store negative integral numbers in a representation called 2's complement notation.

For a unique binary representation of a data type using n bits, values are encoded like this:

The least significant n-1 bits store a positive integral number x in integral representation. Most significant value
stores a bit vith value s. The value repesented by those bits is

x - s * 2n-1

i.e. if the most significant bit is 1, then a value that is just by 1 larger than the number you could represent with the
other bits (2n-2 + 2n-3 + ... + 21 + 20 = 2n-1 - 1) is subtracted allowing a unique binary representation for
each value from - 2n-1 (s = 1; x = 0) to 2n-1 - 1 (s = 0; x = 2n-1 - 1).

This also has the nice side effect, that you can add the binary representations as if they were positive binary
numbers:

v1 = x1 - s1 * 2n-1 v2 = x2 - s2 * 2n-1
s1 s2 x1 + x2 overflow addition result
0 0 No x1 + x2 = v1 + v2
0 0 Yes too large to be represented with data type (overflow)
x1 + x2 - 2n-1 = x1 + x2 - s2 * 2n-1
0 1 No
= v1 + v2
(x1 + x2) mod 2n-1 = x1 + x2 - 2n-1
0 1 Yes
= v1 + v2
1 0 * see above (swap summands)
1 1 No too small to be represented with data type (x1 + x2 - 2n < -2n-1 ; underflow)
(x1 + x2) mod 2n-1 - 2n-1 = (x1 + x2 - 2n-1) - 2n-1
1 1 Yes = (x1 - s1 * 2n-1) + (x2 - s2 * 2n-1)
= v1 + v2

Note that this fact makes finding binary representation of the additive inverse (i.e. the negative value) easy:

Observe that adding the bitwise complement to the number results in all bits being 1. Now add 1 to make value
overflow and you get the neutral element 0 (all bits 0).

So the negative value of a number i can be calculated using (ignoring possible promotion to int here)

(~i) + 1

Example: taking the negative value of 0 (byte):

The result of negating 0, is 11111111. Adding 1 gives a value of 100000000 (9 bits). Because a byte can only store 8
bits, the leftmost value is truncated, and the result is 00000000

Original Process Result

0 (00000000) Negate -0 (11111111)
11111111 Add 1 to binary 100000000
100000000 Truncate to 8 bits 00000000 (-0 equals 0)

Java® Notes for Professionals 82

Section 14.12: The short primitive
A short is a 16-bit signed integer. It has a minimum value of -215 (-32,768), and a maximum value of 215 ?1 (32,767)

short example = -48;

short myShort = 987;
short anotherShort = 17;

short addedShorts = (short) (myShort + anotherShort); // 1,004

short subtractedShorts = (short) (myShort - anotherShort); // 970

The maximum and minimum values of short can be found at:

short high = Short.MAX_VALUE; // high == 32767

short low = Short.MIN_VALUE; // low == -32768

The default value of a short is 0

short defaultShort; // defaultShort == 0

Java® Notes for Professionals 83

Chapter 15: Constructors
While not required, constructors in Java are methods recognized by the compiler to instantiate specific values for
the class which may be essential to the role of the object. This topic demonstrates proper usage of Java class
constructors.

Section 15.1: Default Constructor

The "default" for constructors is that they do not have any arguments. In case you do not specify any constructor,
the compiler will generate a default constructor for you.
This means the following two snippets are semantically equivalent:

public class TestClass {

private String test;
}

public class TestClass {

private String test;
public TestClass() {

}
}

The visibility of the default constructor is the same as the visibility of the class. Thus a class defined package-
privately has a package-private default constructor

However, if you have non-default constructor, the compiler will not generate a default constructor for you. So these
are not equivalent:

public class TestClass {

private String test;
public TestClass(String arg) {
}
}

public class TestClass {

private String test;
public TestClass() {
}
public TestClass(String arg) {
}
}

Beware that the generated constructor performs no non-standard initialization. This means all fields of your class
will have their default value, unless they have an initializer.

public class TestClass {

private String testData;

public TestClass() {
testData = "Test"
}
}

Constructors are called like this:

Java® Notes for Professionals 84

 TestClass testClass = new TestClass();

Section 15.2: Call parent constructor

Say you have a Parent class and a Child class. To construct a Child instance always requires some Parent
constructor to be run at the very gebinning of the Child constructor. We can select the Parent constructor we want
by explicitly calling super(...) with the appropriate arguments as our first Child constructor statement. Doing this
saves us time by reusing the Parent classes' constructor instead of rewriting the same code in the Child classes'
constructor.

Without super(...) method:

(implicitly, the no-args version super() is called invisibly)

class Parent {
private String name;
private int age;

public Parent() {} // necessary because we call super() without arguments

public Parent(String tName, int tAge) {

name = tName;
age = tAge;
}
}

// This does not even compile, because name and age are private,
// making them invisible even to the child class.
class Child extends Parent {
public Child() {
// compiler implicitly calls super() here
name = "John";
age = 42;
}
}

With super() method:

class Parent {
private String name;
private int age;
public Parent(String tName, int tAge) {
name = tName;
age = tAge;
}
}

class Child extends Parent {

public Child() {
super("John", 42); // explicit super-call
}
}

Note: Calls to another constructor (chaining) or the super constructor MUST be the first statement inside the
constructor.

If you call the super(...) constructor explicitly, a matching parent constructor must exist (that's straightforward,
isn't it?).

Java® Notes for Professionals 85

If you don't call any super(...) constructor explicitly, your parent class must have a no-args constructor - and this
can be either written explicitly or created as a default by the compiler if the parent class doesn't provide any
constructor.

class Parent{
public Parent(String tName, int tAge) {}
}

class Child extends Parent{

public Child(){}
}

The class Parent has no default constructor, so, the compiler can't add super in the Child constructor. This code will
not compile. You must change the constructors to fit both sides, or write your own super call, like that:

class Child extends Parent{

public Child(){
super("",0);
}
}

Section 15.3: Constructor with Arguments

Constructors can be created with any kinds of arguments.

public class TestClass {

private String testData;

public TestClass(String testData) {

this.testData = testData;
}
}

Called like this:

TestClass testClass = new TestClass("Test Data");

A class can have multiple constructors with different signatures. To chain constructor calls (call a different
constructor of the same class when instantiating) use this().

public class TestClass {

private String testData;

public TestClass(String testData) {

this.testData = testData;
}

public TestClass() {
this("Test"); // testData defaults to "Test"
}
}

Called like this:

TestClass testClass1 = new TestClass("Test Data");

Java® Notes for Professionals 86

TestClass testClass2 = new TestClass();

Java® Notes for Professionals 87

Chapter 16: Object Class Methods and
Constructor
This documentation page is for showing details with example about java class constructors and about Object Class
Methods which are automatically inherited from the superclass Object of any newly created class.

Section 16.1: hashCode() method

When a Java class overrides the equals method, it should override the hashCode method as well. As defined in the
method's contract:

Whenever it is invoked on the same object more than once during an execution of a Java
application, the hashCode method must consistently return the same integer, provided no
information used in equals comparisons on the object is modified. This integer need not remain
consistent from one execution of an application to another execution of the same application.
If two objects are equal according to the equals(Object) method, then calling the hashCode
method on each of the two objects must produce the same integer result.
It is not required that if two objects are unequal according to the equals(Object) method, then
calling the hashCode method on each of the two objects must produce distinct integer results.
However, the programmer should be aware that producing distinct integer results for unequal
objects may improve the performance of hash tables.

Hash codes are used in hash implementations such as HashMap, HashTable, and HashSet. The result of the hashCode
function determines the bucket in which an object will be put. These hash implementations are more efficient if the
provided hashCode implementation is good. An important property of good hashCode implementation is that the
distribution of the hashCode values is uniform. In other words, there is a small probability that numerous instances
will be stored in the same bucket.

An algorithm for computing a hash code value may be similar to the following:

public class Foo {

private int field1, field2;
private String field3;

public Foo(int field1, int field2, String field3) {

this.field1 = field1;
this.field2 = field2;
this.field3 = field3;
}

@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}

Foo f = (Foo) obj;

return field1 == f.field1 &&
field2 == f.field2 &&
(field3 == null ? f.field3 == null : field3.equals(f.field3);
}

Java® Notes for Professionals 88

 @Override
public int hashCode() {
int hash = 1;
hash = 31 * hash + field1;
hash = 31 * hash + field2;
hash = 31 * hash + (field3 == null ? 0 : field3.hashCode());
return hash;
}
}

Using Arrays.hashCode() as a short cut

Version ≥ Java SE 1.2

In Java 1.2 and above, instead of developing an algorithm to compute a hash code, one can be generated using
java.util.Arrays#hashCode by supplying an Object or primitives array containing the field values:

@Override
public int hashCode() {
return Arrays.hashCode(new Object[] {field1, field2, field3});
}
Version ≥ Java SE 7

Java 1.7 introduced the java.util.Objects class which provides a convenience method, hash(Object...
objects), that computes a hash code based on the values of the objects supplied to it. This method works just like
java.util.Arrays#hashCode.

@Override
public int hashCode() {
return Objects.hash(field1, field2, field3);
}

Note: this approach is inefficient, and produces garbage objects each time your custom hashCode() method is
called:

A temporary Object[] is created. (In the Objects.hash() version, the array is created by the "varargs"
mechanism.)
If any of the fields are primitive types, they must be boxed and that may create more temporary objects.
The array must be populated.
The array must iterated by the Arrays.hashCode or Objects.hash method.
The calls to Object.hashCode() that Arrays.hashCode or Objects.hash has to make (probably) cannot be
inlined.

Internal caching of hash codes

Since the calculation of an object's hash code can be expensive, it can be attractive to cache the hash code value
within the object the first time that it is calculated. For example

public final class ImmutableArray {

private int[] array;
private volatile int hash = 0;

public ImmutableArray(int[] initial) {

array = initial.clone();
}

// Other methods

@Override
public boolean equals(Object obj) {

Java® Notes for Professionals 89

 // ...
}

@Override
public int hashCode() {
int h = hash;
if (h == 0) {
h = Arrays.hashCode(array);
hash = h;
}
return h;
}
}

This approach trades off the cost of (repeatedly) calculating the hash code against the overhead of an extra field to
cache the hash code. Whether this pays off as a performance optimization will depend on how often a given object
is hashed (looked up) and other factors.

You will also notice that if the true hashcode of an ImmutableArray happens to be zero (one chance in 232), the
cache is ineffective.

Finally, this approach is much harder to implement correctly if the object we are hashing is mutable. However,
there are bigger concerns if hash codes change; see the contract above.

Section 16.2: toString() method

The toString() method is used to create a String representation of an object by using the object´s content. This
method should be overridden when writing your class. toString() is called implicitly when an object is
concatenated to a string as in "hello " + anObject.

Consider the following:

public class User {

private String firstName;
private String lastName;

public User(String firstName, String lastName) {

this.firstName = firstName;
this.lastName = lastName;
}

@Override
public String toString() {
return firstName + " " + lastName;
}

public static void main(String[] args) {

User user = new User("John", "Doe");
System.out.println(user.toString()); // Prints "John Doe"
}
}

Here toString() from Object class is overridden in the User class to provide meaningful data regarding the object
when printing it.

When using println(), the object's toString() method is implicitly called. Therefore, these statements do the
same thing:

Java® Notes for Professionals 90

 System.out.println(user); // toString() is implicitly called on `user`
System.out.println(user.toString());

If the toString() is not overridden in the above mentioned User class, System.out.println(user) may return
User@659e0bfd or a similar String with almost no useful information except the class name. This will be because the
call will use the toString() implementation of the base Java Object class which does not know anything about the
User class's structure or business rules. If you want to change this functionality in your class, simply override the
method.

Section 16.3: equals() method

TL;DR

==

tests for reference equality (whether they are the same object)

.equals() tests for value equality (whether they are logically "equal")

equals() is a method used to compare two objects for equality. The default implementation of the equals()
method in the Object class returns true if and only if both references are pointing to the same instance. It
therefore behaves the same as comparison by

==

.
public class Foo {
int field1, field2;
String field3;

public Foo(int i, int j, String k) {

field1 = i;
field2 = j;
field3 = k;
}

public static void main(String[] args) {

Foo foo1 = new Foo(0, 0, "bar");
Foo foo2 = new Foo(0, 0, "bar");

System.out.println(foo1.equals(foo2)); // prints false

}
}

Even though foo1 and foo2 are created with the same fields, they are pointing to two different objects in memory.
The default equals() implementation therefore evaluates to false.

To compare the contents of an object for equality, equals() has to be overridden.

public class Foo {

int field1, field2;
String field3;

public Foo(int i, int j, String k) {

field1 = i;
field2 = j;
field3 = k;

Java® Notes for Professionals 91

 }

@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}

Foo f = (Foo) obj;

return field1 == f.field1 &&
field2 == f.field2 &&
(field3 == null ? f.field3 == null : field3.equals(f.field3));
}

@Override
public int hashCode() {
int hash = 1;
hash = 31 * hash + this.field1;
hash = 31 * hash + this.field2;
hash = 31 * hash + (field3 == null ? 0 : field3.hashCode());
return hash;
}

public static void main(String[] args) {

Foo foo1 = new Foo(0, 0, "bar");
Foo foo2 = new Foo(0, 0, "bar");

System.out.println(foo1.equals(foo2)); // prints true

}
}

Here the overridden equals() method decides that the objects are equal if their fields are the same.

Notice that the hashCode() method was also overwritten. The contract for that method states that when two
objects are equal, their hash values must also be the same. That's why one must almost always override
hashCode() and equals() together.

Pay special attention to the argument type of the equals method. It is Object obj, not Foo obj. If you put the latter
in your method, that is not an override of the equals method.

When writing your own class, you will have to write similar logic when overriding equals() and hashCode(). Most
IDEs can automatically generate this for you.

An example of an equals() implementation can be found in the String class, which is part of the core Java API.
Rather than comparing pointers, the String class compares the content of the String.

Version ≥ Java SE 7

Java 1.7 introduced the java.util.Objects class which provides a convenience method, equals, that compares two
potentially null references, so it can be used to simplify implementations of the equals method.

@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {

Java® Notes for Professionals 92

 return false;
}

Foo f = (Foo) obj;

return field1 == f.field1 && field2 == f.field2 && Objects.equals(field3, f.field3);
}

Class Comparison

Since the equals method can run against any object, one of the first things the method often does (after checking
for null) is to check if the class of the object being compared matches the current class.

@Override
public boolean equals(Object obj) {
//...check for null
if (getClass() != obj.getClass()) {
return false;
}
//...compare fields
}

This is typically done as above by comparing the class objects. However, that can fail in a few special cases which
may not be obvious. For example, some frameworks generate dynamic proxies of classes and these dynamic
proxies are actually a different class. Here is an example using JPA.

Foo detachedInstance = ...

Foo mergedInstance = entityManager.merge(detachedInstance);
if (mergedInstance.equals(detachedInstance)) {
//Can never get here if equality is tested with getClass()
//as mergedInstance is a proxy (subclass) of Foo
}

One mechanism to work around that limitation is to compare classes using instanceof

@Override
public final boolean equals(Object obj) {
if (!(obj instanceof Foo)) {
return false;
}
//...compare fields
}

However, there are a few pitfalls that must be avoided when using instanceof. Since Foo could potentially have
other subclasses and those subclasses might override equals() you could get into a case where a Foo is equal to a
FooSubclass but the FooSubclass is not equal to Foo.

Foo foo = new Foo(7);

FooSubclass fooSubclass = new FooSubclass(7, false);
foo.equals(fooSubclass) //true
fooSubclass.equals(foo) //false

This violates the properties of symmetry and transitivity and thus is an invalid implementation of the equals()
method. As a result, when using instanceof, a good practice is to make the equals() method final (as in the
above example). This will ensure that no subclass overrides equals() and violates key assumptions.

Java® Notes for Professionals 93

Section 16.4: wait() and notify() methods
wait() and notify() work in tandem – when one thread calls wait() on an object, that thread will block until
another thread calls notify() or notifyAll() on that same object.

(See Also: wait()/notify() )

package com.example.examples.object;

import java.util.concurrent.atomic.AtomicBoolean;

public class WaitAndNotify {

public static void main(String[] args) throws InterruptedException {

final Object obj = new Object();
AtomicBoolean aHasFinishedWaiting = new AtomicBoolean(false);

Thread threadA = new Thread("Thread A") {

public void run() {
System.out.println("A1: Could print before or after B1");
System.out.println("A2: Thread A is about to start waiting...");
try {
synchronized (obj) { // wait() must be in a synchronized block
// execution of thread A stops until obj.notify() is called
obj.wait();
}
System.out.println("A3: Thread A has finished waiting. "
+ "Guaranteed to happen after B3");
} catch (InterruptedException e) {
System.out.println("Thread A was interrupted while waiting");
} finally {
aHasFinishedWaiting.set(true);
}
}
};

Thread threadB = new Thread("Thread B") {

public void run() {
System.out.println("B1: Could print before or after A1");

System.out.println("B2: Thread B is about to wait for 10 seconds");

for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000); // sleep for 1 second
} catch (InterruptedException e) {
System.err.println("Thread B was interrupted from waiting");
}
}

System.out.println("B3: Will ALWAYS print before A3 since "

+ "A3 can only happen after obj.notify() is called.");

while (!aHasFinishedWaiting.get()) {
synchronized (obj) {
// notify ONE thread which has called obj.wait()
obj.notify();
}
}
}
};

Java® Notes for Professionals 94

 threadA.start();
threadB.start();

threadA.join();
threadB.join();

System.out.println("Finished!");
}
}

Some example output:

A1: Could print before or after B1

B1: Could print before or after A1
A2: Thread A is about to start waiting...
B2: Thread B is about to wait for 10 seconds
B3: Will ALWAYS print before A3 since A3 can only happen after obj.notify() is called.
A3: Thread A has finished waiting. Guaranteed to happen after B3
Finished!

B1: Could print before or after A1

B2: Thread B is about to wait for 10 seconds
A1: Could print before or after B1
A2: Thread A is about to start waiting...
B3: Will ALWAYS print before A3 since A3 can only happen after obj.notify() is called.
A3: Thread A has finished waiting. Guaranteed to happen after B3
Finished!

A1: Could print before or after B1

A2: Thread A is about to start waiting...
B1: Could print before or after A1
B2: Thread B is about to wait for 10 seconds
B3: Will ALWAYS print before A3 since A3 can only happen after obj.notify() is called.
A3: Thread A has finished waiting. Guaranteed to happen after B3
Finished!

Section 16.5: getClass() method

The getClass() method can be used to find the runtime class type of an object. See the example below:

public class User {

private long userID;

private String name;

public User(long userID, String name) {

this.userID = userID;
this.name = name;
}
}

public class SpecificUser extends User {

private String specificUserID;

public SpecificUser(String specificUserID, long userID, String name) {

super(userID, name);
this.specificUserID = specificUserID;
}
}

Java® Notes for Professionals 95

public static void main(String[] args){
User user = new User(879745, "John");
SpecificUser specificUser = new SpecificUser("1AAAA", 877777, "Jim");
User anotherSpecificUser = new SpecificUser("1BBBB", 812345, "Jenny");

System.out.println(user.getClass()); //Prints "class User"

System.out.println(specificUser.getClass()); //Prints "class SpecificUser"
System.out.println(anotherSpecificUser.getClass()); //Prints "class SpecificUser"
}

The getClass() method will return the most specific class type, which is why when getClass() is called on
anotherSpecificUser, the return value is class SpecificUser because that is lower down the inheritance tree
than User.

It is noteworthy that, while the getClass method is declared as:

public final native Class<?> getClass();

The actual static type returned by a call to getClass is Class<? extends T> where T is the static type of the object
on which getClass is called.

i.e. the following will compile:

Class<? extends String> cls = "".getClass();

Section 16.6: clone() method

The clone() method is used to create and return a copy of an object. This method arguable should be avoided as it
is problematic and a copy constructor or some other approach for copying should be used in favour of clone().

For the method to be used all classes calling the method must implement the Cloneable interface.

The Cloneable interface itself is just a tag interface used to change the behaviour of the native clone() method
which checks if the calling objects class implements Cloneable. If the caller does not implement this interface a
CloneNotSupportedException will be thrown.

The Object class itself does not implement this interface so a CloneNotSupportedException will be thrown if the
calling object is of class Object.

For a clone to be correct it should be independent of the object it is being cloned from, therefore it may be
necessary to modify the object before it gets returned. This means to essentially create a "deep copy" by also
copying any of the mutable objects that make up the internal structure of the object being cloned. If this is not
implemented correctly the cloned object will not be independent and have the same references to the mutable
objects as the object that it was cloned from. This would result in inconsistent behaviour as any changes to those in
one would affect the other.

class Foo implements Cloneable {

int w;
String x;
float[] y;
Date z;

public Foo clone() {

try {
Foo result = new Foo();
// copy primitives by value

Java® Notes for Professionals 96

 result.w = this.w;
// immutable objects like String can be copied by reference
result.x = this.x;

// The fields y and z refer to a mutable objects; clone them recursively.

if (this.y != null) {
result.y = this.y.clone();
}
if (this.z != null) {
result.z = this.z.clone();
}

// Done, return the new object

return result;

} catch (CloneNotSupportedException e) {
// in case any of the cloned mutable fields do not implement Cloneable
throw new AssertionError(e);
}
}
}

Section 16.7: Object constructor

All constructors in Java must make a call to the Object constructor. This is done with the call super(). This has to be
the first line in a constructor. The reason for this is so that the object can actually be created on the heap before
any additional initialization is performed.

If you do not specify the call to super() in a constructor the compiler will put it in for you.

So all three of these examples are functionally identical

with explicit call to super() constructor

public class MyClass {

public MyClass() {
super();
}
}

with implicit call to super() constructor

public class MyClass {

public MyClass() {
// empty
}
}

with implicit constructor

public class MyClass {

What about Constructor-Chaining?

Java® Notes for Professionals 97

It is possible to call other constructors as the first instruction of a constructor. As both the explicit call to a super
constructor and the call to another constructor have to be both first instructions, they are mutually exclusive.

public class MyClass {

public MyClass(int size) {

doSomethingWith(size);

public MyClass(Collection<?> initialValues) {

this(initialValues.size());
addInitialValues(initialValues);
}
}

Calling new MyClass(Arrays.asList("a", "b", "c")) will call the second constructor with the List-argument,
which will in turn delegate to the first constructor (which will delegate implicitly to super()) and then call
addInitialValues(int size) with the second size of the list. This is used to reduce code duplication where
multiple constructors need to do the same work.

How do I call a specific constructor?

Given the example above, one can either call new MyClass("argument") or new MyClass("argument", 0). In other
words, much like method overloading, you just call the constructor with the parameters that are necessary for your
chosen constructor.

What will happen in the Object class constructor?

Nothing more than would happen in a sub-class that has a default empty constructor (minus the call to super()).

The default empty constructor can be explicitly defined but if not the compiler will put it in for you as long as no
other constructors are already defined.

How is an Object then created from the constructor in Object?

The actual creation of objects is down to the JVM. Every constructor in Java appears as a special method named
<init> which is responsible for instance initializing. This <init> method is supplied by the compiler and because
<init> is not a valid identifier in Java, it cannot be used directly in the language.

How does the JVM invoke this <init> method?

The JVM will invoke the <init> method using the invokespecial instruction and can only be invoked on
uninitialized class instances.

For more information take a look at the JVM specification and the Java Language Specification:

Special Methods (JVM) - JVMS - 2.9

Java® Notes for Professionals 98

 Constructors - JLS - 8.8

Section 16.8: finalize() method

This is a protected and non-static method of the Object class. This method is used to perform some final operations
or clean up operations on an object before it gets removed from the memory.

According to the doc, this method gets called by the garbage collector on an object when garbage
collection determines that there are no more references to the object.

But there are no guarantees that finalize() method would gets called if the object is still reachable or no Garbage
Collectors run when the object become eligible. That's why it's better not rely on this method.

In Java core libraries some usage examples could be found, for instance in FileInputStream.java:

protected void finalize() throws IOException {

if ((fd != null) && (fd != FileDescriptor.in)) {
/* if fd is shared, the references in FileDescriptor
* will ensure that finalizer is only called when
* safe to do so. All references using the fd have
* become unreachable. We can call close()
*/
close();
}
}

In this case it's the last chance to close the resource if that resource has not been closed before.

Generally it's considered bad practice to use finalize() method in applications of any kind and should be avoided.

Finalizers are not meant for freeing resources (e.g., closing files). The garbage collector gets called when (if!) the
system runs low on heap space. You can't rely on it to be called when the system is running low on file handles or,
for any other reason.

The intended use-case for finalizers is for an object that is about to be reclaimed to notify some other object about
its impending doom. A better mechanism now exists for that purpose---the java.lang.ref.WeakReference<T>
class. If you think you need write a finalize() method, then you should look into whether you can solve the same
problem using WeakReference instead. If that won't solve your problem, then you may need to re-think your design
on a deeper level.

For further reading here is an Item about finalize() method from "Effective Java" book by Joshua Bloch.

Java® Notes for Professionals 99

Chapter 17: Annotations
In Java, an annotation is a form of syntactic metadata that can be added to Java source code. It provides data about
a program that is not part of the program itself. Annotations have no direct effect on the operation of the code they
annotate. Classes, methods, variables, parameters and packages are allowed to be annotated.

Section 17.1: The idea behind Annotations

The Java Language Specification describes Annotations as follows:

An annotation is a marker which associates information with a program construct, but has no effect at
run time.

Annotations may appear before types or declarations. It is possible for them to appear in a place where they could
apply to both a type or a declaration.
What exactly an annotation applies to is governed by the "meta-annotation" @Target. See "Defining annotation
types" for more information.

Annotations are used for a multitude of purposes. Frameworks like Spring and Spring-MVC make use of
annotations to define where Dependencies should be injected or where requests should be routed.

Other frameworks use annotations for code-generation. Lombok and JPA are prime examples, that use annotations
to generate Java (and SQL) code.

This topic aims to provide a comprehensive overview of:

How to define your own Annotations?

What Annotations does the Java Language provide?

How are Annotations used in practice?

Section 17.2: Defining annotation types

Annotation types are defined with @interface. Parameters are defined similar to methods of a regular interface.

@interface MyAnnotation {
String param1();
boolean param2();
int[] param3(); // array parameter
}

Default values
@interface MyAnnotation {
String param1() default "someValue";
boolean param2() default true;
int[] param3() default {};
}

Meta-Annotations

Meta-annotations are annotations that can be applied to annotation types. Special predefined meta-annotation
define how annotation types can be used.

Java® Notes for Professionals 100

@Target

The @Target meta-annotation restricts the types the annotation can be applied to.

@Target(ElementType.METHOD)
@interface MyAnnotation {
// this annotation can only be applied to methods
}

Multiple values can be added using array notation, e.g. @Target({ElementType.FIELD, ElementType.TYPE})

Available Values
ElementType target example usage on target element
@Retention(RetentionPolicy.RUNTIME) terface
ANNOTATION_TYPE annotation types
MyAnnotation
CONSTRUCTOR constructors @MyAnnotationlic MyClass() {}
FIELD fields, enum constants @XmlAttributevate int count;
for (@LoopVariable int i = 0; i < 100; i++) { @Unused
variable declarations inside
LOCAL_VARIABLE String resultVariable;
methods
}
package (in package-
PACKAGE @Deprecatedkage very.old;
info.java)
METHOD methods @XmlElementlic int getCount() {...}
public Rectangle( @NamedArg("width") double width,
method/constructor @NamedArg("height") double height) {
PARAMETER
parameters ...
}
TYPE classes, interfaces, enums @XmlRootElementlic class Report {}
Version ≥ Java SE 8
ElementType target example usage on target element
TYPE_PARAMETER Type parameter declarations public <@MyAnnotation T> void f(T t) {}
TYPE_USE Use of a type Object o = "42";ing s = (@MyAnnotation String) o;
@Retention

The @Retention meta-annotation defines the annotation visibility during the applications compilation process or
execution. By default, annotations are included in .class files, but are not visible at runtime. To make an
annotation accessible at runtime, RetentionPolicy.RUNTIME has to be set on that annotation.

@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
// this annotation can be accessed with reflections at runtime
}

Available values
RetentionPolicy Effect
CLASS The annotation is available in the .class file, but not at runtime
RUNTIME The annotation is available at runtime and can be accessed via reflection
The annotation is available at compile time, but not added to the .class files. The annotation can
SOURCE
be used e.g. by an annotation processor.
@Documented

The @Documented meta-annotation is used to mark annotations whose usage should be documented by API
documentation generators like javadoc. It has no values. With @Documented, all classes that use the annotation will
list it on their generated documentation page. Without @Documented, it's not possible to see which classes use the
annotation in the documentation.

@Inherited

Java® Notes for Professionals 101

The @Inherited meta-annotation is relevant to annotations that are applied to classes. It has no values. Marking an
annotation as @Inherited alters the way that annotation querying works.

For a non-inherited annotation, the query only examines the class being examined.
For an inherited annotation, the query will also check the super-class chain (recursively) until an instance of
the annotation is found.

Note that only the super-classes are queried: any annotations attached to interfaces in the classes hierarchy will be
ignored.

@Repeatable

The @Repeatable meta-annotation was added in Java 8. It indicates that multiple instances of the annotation can be
attached to the annotation's target. This meta-annotation has no values.

Section 17.3: Runtime annotation checks via reflection

Java's Reflection API allows the programmer to perform various checks and operations on class fields, methods and
annotations during runtime. However, in order for an annotation to be at all visible at runtime, the
RetentionPolicy must be changed to RUNTIME, as demonstrated in the example below:

@interface MyDefaultAnnotation {

@Retention(RetentionPolicy.RUNTIME)
@interface MyRuntimeVisibleAnnotation {

public class AnnotationAtRuntimeTest {

@MyDefaultAnnotation
static class RuntimeCheck1 {
}

@MyRuntimeVisibleAnnotation
static class RuntimeCheck2 {
}

public static void main(String[] args) {

Annotation[] annotationsByType = RuntimeCheck1.class.getAnnotations();
Annotation[] annotationsByType2 = RuntimeCheck2.class.getAnnotations();

System.out.println("default retention: " + Arrays.toString(annotationsByType));

System.out.println("runtime retention: " + Arrays.toString(annotationsByType2));
}
}

Section 17.4: Built-in annotations

The Standard Edition of Java comes with some annotations predefined. You do not need to define them by yourself
and you can use them immediately. They allow the compiler to enable some fundamental checking of methods,
classes and code.

@Override

Java® Notes for Professionals 102

This annotation applies to a method and says that this method must override a superclass' method or implement
an abstract superclass' method definition. If this annotation is used with any other kind of method, the compiler will
throw an error.

Concrete superclass

public class Vehicle {

public void drive() {
System.out.println("I am driving");
}
}

class Car extends Vehicle {

// Fine
@Override
public void drive() {
System.out.prinln("Brrrm, brrm");
}
}

Abstract class

abstract class Animal {

public abstract void makeNoise();
}

class Dog extends Animal {

// Fine
@Override
public void makeNoise() {
System.out.prinln("Woof");
}
}

Does not work

class Logger1 {
public void log(String logString) {
System.out.prinln(logString);
}
}

class Logger2 {
// This will throw compile-time error. Logger2 is not a subclass of Logger1.
// log method is not overriding anything
@Override
public void log(String logString) {
System.out.println("Log 2" + logString);
}
}

The main purpose is to catch mistyping, where you think you are overriding a method, but are actually defining a
new one.

class Vehicle {
public void drive() {
System.out.println("I am driving");
}
}

Java® Notes for Professionals 103

class Car extends Vehicle {
// Compiler error. "dirve" is not the correct method name to override.
@Override
public void dirve() {
System.out.prinln("Brrrm, brrm");
}
}

Note that the meaning of @Override has changed over time:

In Java 5, it meant that the annotated method had to override a non-abstract method declared in the
superclass chain.
From Java 6 onward, it is also satisfied if the annotated method implements an abstract method declared in
the classes superclass / interface hierarchy.

(This can occasionally cause problems when back-porting code to Java 5.)

@Deprecated

This marks the method as deprecated. There can be several reasons for this:

the API is flawed and is impractical to fix,

usage of the API is likely to lead to errors,

the API has been superseded by another API,

the API is obsolete,

the API is experimental and is subject to incompatible changes,

or any combination of the above.

The specific reason for deprecation can usually be found in the documentation of the API.

The annotation will cause the compiler to emit an error if you use it. IDEs may also highlight this method somehow
as deprecated

class ComplexAlgorithm {
@Deprecated
public void oldSlowUnthreadSafeMethod() {
// stuff here
}

public void quickThreadSafeMethod() {

// client code should use this instead
}
}

@SuppressWarnings

In almost all cases, when the compiler emits a warning, the most appropriate action is to fix the cause. In some
instances (Generics code using untype-safe pre-generics code, for example) this may not be possible and it's better
to suppress those warnings that you expect and cannot fix, so you can more clearly see unexpected warnings.

This annotation can be applied to a whole class, method or line. It takes the category of warning as a parameter.

@SuppressWarnings("deprecation")

Java® Notes for Professionals 104

public class RiddledWithWarnings {
// several methods calling deprecated code here
}

@SuppressWarning("finally")
public boolean checkData() {
// method calling return from within finally block
}

It is better to limit the scope of the annotation as much as possible, to prevent unexpected warnings also being
suppressed. For example, confining the scope of the annotation to a single-line:

ComplexAlgorithm algorithm = new ComplexAlgorithm();

@SuppressWarnings("deprecation") algoritm.slowUnthreadSafeMethod();
// we marked this method deprecated in an example above

@SuppressWarnings("unsafe") List<Integer> list = getUntypeSafeList();

// old library returns, non-generic List containing only integers

The warnings supported by this annotation may vary from compiler to compiler. Only the unchecked and
deprecation warnings are specifically mentioned in the JLS. Unrecognized warning types will be ignored.

@SafeVarargs

Because of type erasure, void method(T... t) will be converted to void method(Object[] t) meaning that the
compiler is not always able to verify that the use of varargs is type-safe. For instance:

private static <T> void generatesVarargsWarning(T... lists) {

There are instances where the use is safe, in which case you can annotate the method with the SafeVarargs
annotation to suppress the warning. This obviously hides the warning if your use is unsafe too.

@FunctionalInterface

This is an optional annotation used to mark a FunctionalInterface. It will cause the compiler to complain if it does
not conform to the FunctionalInterface spec (has a single abstract method)

@FunctionalInterface
public interface ITrade {
public boolean check(Trade t);
}

@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}

Section 17.5: Compile time processing using annotation

processor
This example demonstrates how to do compile time checking of an annotated element.

The annotation

The @Setter annotation is a marker can be applied to methods. The annotation will be discarded during
compilation not be available afterwards.

Java® Notes for Professionals 105

package annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.METHOD)
public @interface Setter {
}

The annotation processor

The SetterProcessor class is used by the compiler to process the annotations. It checks, if the methods annotated
with the @Setter annotation are public, non-static methods with a name starting with set and having a
uppercase letter as 4th letter. If one of these conditions isn't met, a error is written to the Messager. The compiler
writes this to stderr, but other tools could use this information differently. E.g. the NetBeans IDE allows the user
specify annotation processors that are used to display error messages in the editor.

package annotation.processor;

import annotation.Setter;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;

@SupportedAnnotationTypes({"annotation.Setter"})
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class SetterProcessor extends AbstractProcessor {

private Messager messager;

@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
// get elements annotated with the @Setter annotation
Set<? extends Element> annotatedElements = roundEnv.getElementsAnnotatedWith(Setter.class);

for (Element element : annotatedElements) {

if (element.getKind() == ElementKind.METHOD) {
// only handle methods as targets
checkMethod((ExecutableElement) element);
}
}

// don't claim annotations to allow other processors to process them

return false;
}

private void checkMethod(ExecutableElement method) {

Java® Notes for Professionals 106

 // check for valid name
String name = method.getSimpleName().toString();
if (!name.startsWith("set")) {
printError(method, "setter name must start with \"set\"");
} else if (name.length() == 3) {
printError(method, "the method name must contain more than just \"set\"");
} else if (Character.isLowerCase(name.charAt(3))) {
if (method.getParameters().size() != 1) {
printError(method, "character following \"set\" must be upper case");
}
}

// check, if setter is public

if (!method.getModifiers().contains(Modifier.PUBLIC)) {
printError(method, "setter must be public");
}

// check, if method is static

if (method.getModifiers().contains(Modifier.STATIC)) {
printError(method, "setter must not be static");
}
}

private void printError(Element element, String message) {

messager.printMessage(Diagnostic.Kind.ERROR, message, element);
}

@Override
public void init(ProcessingEnvironment processingEnvironment) {
super.init(processingEnvironment);

// get messager for printing errors

messager = processingEnvironment.getMessager();
}

Packaging

To be applied by the compiler, the annotation processor needs to be made available to the SPI (see ServiceLoader).

To do this a text file META-INF/services/javax.annotation.processing.Processor needs to be added to the jar

file containing the annotation processor and the annotation in addition to the other files. The file needs to include
the fully qualified name of the annotation processor, i.e. it should look like this

annotation.processor.SetterProcessor

We'll assume the jar file is called AnnotationProcessor.jar below.

Example annotated class

The following class is example class in the default package with the annotations being applied to the correct
elements according to the retention policy. However only the annotation processor only considers the second
method a valid annotation target.

import annotation.Setter;

public class AnnotationProcessorTest {

@Setter

Java® Notes for Professionals 107

 private void setValue(String value) {}

@Setter
public void setString(String value) {}

@Setter
public static void main(String[] args) {}

Using the annotation processor with javac

If the annotation processor is discovered using the SPI, it is automatically used to process annotated elements. E.g.
compiling the AnnotationProcessorTest class using

javac -cp AnnotationProcessor.jar AnnotationProcessorTest.java

yields the following output

AnnotationProcessorTest.java:6: error: setter must be public

private void setValue(String value) {}
^
AnnotationProcessorTest.java:12: error: setter name must start with "set"
public static void main(String[] args) {}
^
2 errors

instead of compiling normally. No .class file is created.

This could be prevented by specifying the -proc:none option for javac. You could also forgo the usual compilation
by specifying -proc:only instead.

IDE integration
Netbeans

Annotation processors can be used in the NetBeans editor. To do this the annotation processor needs to be
specified in the project settings:

1. go to Project Properties > Build > Compiling

2. add check marks for Enable Annotation Processing and Enable Annotation Processing in Editor

3. click Add next to the annotation processor list

4. in the popup that appears enter the fully qualified class name of the annotation processor and click Ok.

Result

Java® Notes for Professionals 108

Section 17.6: Repeating Annotations
Until Java 8, two instances of the same annotation could not be applied to a single element. The standard
workaround was to use a container annotation holding an array of some other annotation:

// Author.java
@Retention(RetentionPolicy.RUNTIME)
public @interface Author {
String value();
}

// Authors.java
@Retention(RetentionPolicy.RUNTIME)
public @interface Authors {
Author[] value();
}

// Test.java
@Authors({
@Author("Mary"),
@Author("Sam")
})
public class Test {
public static void main(String[] args) {
Author[] authors = Test.class.getAnnotation(Authors.class).value();
for (Author author : authors) {
System.out.println(author.value());
// Output:
// Mary
// Sam
}
}
}
Version ≥ Java SE 8

Java 8 provides a cleaner, more transparent way of using container annotations, using the @Repeatable annotation.
First we add this to the Author class:

@Repeatable(Authors.class)

This tells Java to treat multiple @Author annotations as though they were surrounded by the @Authors container.
We can also use Class.getAnnotationsByType() to access the @Author array by its own class, instead of through its

Java® Notes for Professionals 109

container:

@Author("Mary")
@Author("Sam")
public class Test {
public static void main(String[] args) {
Author[] authors = Test.class.getAnnotationsByType(Author.class);
for (Author author : authors) {
System.out.println(author.value());
// Output:
// Mary
// Sam
}
}
}

Section 17.7: Inherited Annotations

By default class annotations do not apply to types extending them. This can be changed by adding the @Inherited
annotation to the annotation definition

Example

Consider the following 2 Annotations:

@Inherited
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface InheritedAnnotationType {
}

and

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface UninheritedAnnotationType {
}

If three classes are annotated like this:

@UninheritedAnnotationType
class A {
}

@InheritedAnnotationType
class B extends A {
}

class C extends B {
}

running this code

System.out.println(new A().getClass().getAnnotation(InheritedAnnotationType.class));
System.out.println(new B().getClass().getAnnotation(InheritedAnnotationType.class));
System.out.println(new C().getClass().getAnnotation(InheritedAnnotationType.class));
System.out.println("_________________________________");
System.out.println(new A().getClass().getAnnotation(UninheritedAnnotationType.class));

Java® Notes for Professionals 110

System.out.println(new B().getClass().getAnnotation(UninheritedAnnotationType.class));
System.out.println(new C().getClass().getAnnotation(UninheritedAnnotationType.class));

will print a result similar to this (depending on the packages of the annotation):

null
@InheritedAnnotationType()
@InheritedAnnotationType()
_________________________________
@UninheritedAnnotationType()
null
null

Note that annotations can only be inherited from classes, not interfaces.

Section 17.8: Getting Annotation values at run-time

You can fetch the current properties of the Annotation by using Reflection to fetch the Method or Field or Class
which has an Annotation applied to it, and then fetching the desired properties.

@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
String key() default "foo";
String value() default "bar";
}

class AnnotationExample {
// Put the Annotation on the method, but leave the defaults
@MyAnnotation
public void testDefaults() throws Exception {
// Using reflection, get the public method "testDefaults", which is this method with no args
Method method = AnnotationExample.class.getMethod("testDefaults", null);

// Fetch the Annotation that is of type MyAnnotation from the Method

MyAnnotation annotation = (MyAnnotation)method.getAnnotation(MyAnnotation.class);

// Print out the settings of the Annotation

print(annotation);
}

//Put the Annotation on the method, but override the settings

@MyAnnotation(key="baz", value="buzz")
public void testValues() throws Exception {
// Using reflection, get the public method "testValues", which is this method with no args
Method method = AnnotationExample.class.getMethod("testValues", null);

// Fetch the Annotation that is of type MyAnnotation from the Method

MyAnnotation annotation = (MyAnnotation)method.getAnnotation(MyAnnotation.class);

// Print out the settings of the Annotation

print(annotation);
}

public void print(MyAnnotation annotation) {

// Fetch the MyAnnotation 'key' & 'value' properties, and print them out
System.out.println(annotation.key() + " = " + annotation.value());
}

public static void main(String[] args) {

Java® Notes for Professionals 111

 AnnotationExample example = new AnnotationExample();
try {
example.testDefaults();
example.testValues();
} catch( Exception e ) {
// Shouldn't throw any Exceptions
System.err.println("Exception [" + e.getClass().getName() + "] - " + e.getMessage());
e.printStackTrace(System.err);
}
}
}

The output will be

foo = bar
baz = buzz

Section 17.9: Annotations for 'this' and receiver parameters

When Java annotations were first introduced there was no provision for annotating the target of an instance
method or the hidden constructor parameter for an inner classes constructor. This was remedied in Java 8 with
addition of receiver parameter declarations; see JLS 8.4.1.

The receiver parameter is an optional syntactic device for an instance method or an inner class's
constructor. For an instance method, the receiver parameter represents the object for which the method
is invoked. For an inner class's constructor, the receiver parameter represents the immediately enclosing
instance of the newly constructed object. Either way, the receiver parameter exists solely to allow the type
of the represented object to be denoted in source code, so that the type may be annotated. The receiver
parameter is not a formal parameter; more precisely, it is not a declaration of any kind of variable
(§4.12.3), it is never bound to any value passed as an argument in a method invocation expression or
qualified class instance creation expression, and it has no effect whatsoever at run time.

The following example illustrates the syntax for both kinds of receiver parameter:

public class Outer {

public class Inner {
public Inner (Outer this) {
// ...
}
public void doIt(Inner this) {
// ...
}
}
}

The sole purpose of receiver parameters is to allow you to add annotations. For example, you might have a custom
annotation @IsOpen whose purpose is to assert that a Closeable object has not been closed when a method is
called. For example:

public class MyResource extends Closeable {

public void update(@IsOpen MyResource this, int value) {
// ...
}

Java® Notes for Professionals 112

 public void close() {
// ...
}
}

At one level, the @IsOpen annotation on this could simply serve as documentation. However, we could potentially
do more. For example:

An annotation processor could insert a runtime check that this is not in closed state when update is called.
A code checker could perform a static code analysis to find cases where this could be closed when update is
called.

Section 17.10: Add multiple annotation values

An Annotation parameter can accept multiple values if it is defined as an array. For example the standard
annotation @SuppressWarnings is defined like this:

public @interface SuppressWarnings {

String[] value();
}

The value parameter is an array of Strings. You can set multiple values by using a notation similar to Array
initializers:

@SuppressWarnings({"unused"})
@SuppressWarnings({"unused", "javadoc"})

If you only need to set a single value, the brackets can be omitted:

@SuppressWarnings("unused")

Java® Notes for Professionals 113

Chapter 18: Immutable Class
Immutable objects are instances whose state doesn’t change after it has been initialized. For example, String is an
immutable class and once instantiated its value never changes.

Section 18.1: Example without mutable refs

public final class Color {
final private int red;
final private int green;
final private int blue;

private void check(int red, int green, int blue) {

if (red < 0 || red > 255 || green < 0 || green > 255 || blue < 0 || blue > 255) {
throw new IllegalArgumentException();
}
}

public Color(int red, int green, int blue) {

check(red, green, blue);
this.red = red;
this.green = green;
this.blue = blue;
}

public Color invert() {

return new Color(255 - red, 255 - green, 255 - blue);
}
}

Section 18.2: What is the advantage of immutability?

The advantage of immutability comes with concurrency. It is difficult to maintain correctness in mutable objects, as
multiple threads could be trying to change the state of the same object, leading to some threads seeing a different
state of the same object, depending on the timing of the reads and writes to the said object.

By having an immutable object, one can ensure that all threads that are looking at the object will be seeing the
same state, as the state of an immutable object will not change.

Section 18.3: Rules to define immutable classes

The following rules define a simple strategy for creating immutable objects.

1. Don't provide "setter" methods - methods that modify fields or objects referred to by fields.
2. Make all fields final and private.
3. Don't allow subclasses to override methods. The simplest way to do this is to declare the class as final. A
more sophisticated approach is to make the constructor private and construct instances in factory methods.
4. If the instance fields include references to mutable objects, don't allow those objects to be changed:
5. Don't provide methods that modify the mutable objects.
6. Don't share references to the mutable objects. Never store references to external, mutable objects passed to
the constructor; if necessary, create copies, and store references to the copies. Similarly, create copies of
your internal mutable objects when necessary to avoid returning the originals in your methods.

Java® Notes for Professionals 114

Section 18.4: Example with mutable refs
In this case class Point is mutable and some user can modify state of object of this class.

class Point {
private int x, y;

public Point(int x, int y) {

this.x = x;
this.y = y;
}

public int getX() {

return x;
}

public void setX(int x) {

this.x = x;
}

public int getY() {

return y;
}

public void setY(int y) {

this.y = y;
}
}

//...

public final class ImmutableCircle {

private final Point center;
private final double radius;

public ImmutableCircle(Point center, double radius) {

// we create new object here because it shouldn't be changed
this.center = new Point(center.getX(), center.getY());
this.radius = radius;
}

Java® Notes for Professionals 115

Chapter 19: Immutable Objects
Section 19.1: Creating an immutable version of a type using
defensive copying
Some basic types and classes in Java are fundamentally mutable. For example, all array types are mutable, and so
are classes like java.util.Data. This can be awkward in situations where an immutable type is mandated.

One way to deal with this is to create an immutable wrapper for the mutable type. Here is a simple wrapper for an
array of integers

public class ImmutableIntArray {

private final int[] array;

public ImmutableIntArray(int[] array) {

this.array = array.clone();
}

public int[] getValue() {

return this.clone();
}
}

This class works by using defensive copying to isolate the mutable state (the int[]) from any code that might mutate
it:

The constructor uses clone() to create a distinct copy of the parameter array. If the caller of the constructor
subsequent changed the parameter array, it would not affect the state of the ImmutableIntArray.

The getValue() method also uses clone() to create the array that is returned. If the caller were to change
the result array, it would not affect the state of the ImmutableIntArray.

We could also add methods to ImmutableIntArray to perform read-only operations on the wrapped array; e.g. get
its length, get the value at a particular index, and so on.

Note that an immutable wrapper type implemented this way is not type compatible with the original type. You
cannot simply substitute the former for the latter.

Section 19.2: The recipe for an immutable class

An immutable object is an object whose state cannot be changed. An immutable class is a class whose instances are
immutable by design, and implementation. The Java class which is most commonly presented as an example of
immutability is java.lang.String.

The following is a stereotypical example:

public final class Person {

private final String name;
private final String ssn; // (SSN == social security number)

public Person(String name, String ssn) {

this.name = name;
this.ssn = ssn;
}

Java® Notes for Professionals 116

 public String getName() {
return name;
}

public String getSSN() {

return ssn;
}
}

A variation on this is to declare the constructor as private and provide a public static factory method instead.

The standard recipe for an immutable class is as follows:

All properties must be set in the constructor(s) or factory method(s).

There should be no setters.
If it is necessary to include setters for interface compatibility reasons, they should either do nothing or throw
an exception.
All properties should be declared as private and final.
For all properties that are references to mutable types:
the property should be initialized with a deep copy of the value passed via the constructor, and
the property's getter should return a deep copy of the property value.
The class should be declared as final to prevent someone creating a mutable subclass of an immutable
class.

A couple of other things to note:

Immutability does not prevent object from being nullable; e.g. null can be assigned to a String variable.
If an immutable classes properties are declared as final, instances are inherently thread-safe. This makes
immutable classes a good building block for implementing multi-threaded applications.

Section 19.3: Typical design flaws which prevent a class from

being immutable
Using some setters, without setting all needed properties in the constructor(s)

public final class Person { // example of a bad immutability

private final String name;
private final String surname;
public Person(String name) {
this.name = name;
}
public String getName() { return name;}
public String getSurname() { return surname;}
public void setSurname(String surname) { this.surname = surname); }
}

It’s easy to show that Person class is not immutable:

Person person = new Person("Joe");

person.setSurname("Average"); // NOT OK, change surname field after creation

To fix it, simply delete setSurname() and refactor the constructor as follows:

public Person(String name, String surname) {

this.name = name;
this.surname = surname;

Java® Notes for Professionals 117

 }

Not marking instance variables as private and final

Take a look at the following class:

public final class Person {

public String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}

The following snippet shows that the above class is not immutable:

Person person = new Person("Average Joe");

person.name = "Magic Mike"; // not OK, new name for person after creation

To fix it, simply mark name property as private and final.

Exposing a mutable object of the class in a getter

Take a look at the following class:

import java.util.List;
import java.util.ArrayList;
public final class Names {
private final List<String> names;
public Names(List<String> names) {
this.names = new ArrayList<String>(names);
}
public List<String> getNames() {
return names;
}
public int size() {
return names.size();
}
}

Names class seems immutable at the first sight, but it is not as the following code shows:

List<String> namesList = new ArrayList<String>();

namesList.add("Average Joe");
Names names = new Names(namesList);
System.out.println(names.size()); // 1, only containing "Average Joe"
namesList = names.getNames();
namesList.add("Magic Mike");
System.out.println(names.size()); // 2, NOT OK, now names also contains "Magic Mike"

This happened because a change to the reference List returned by getNames() can modify the actual list of Names.

To fix this, simply avoid returning references that reference class's mutable objects either by making defensive
copies, as follows:

Java® Notes for Professionals 118

public List<String> getNames() {
return new ArrayList<String>(this.names); // copies elements
}

or by designing getters in way that only other immutable objects and primitives are returned, as follows:

public String getName(int index) {

return names.get(index);
}
public int size() {
return names.size();
}

Injecting constructor with object(s) that can be modified outside the immutable class

This is a variation of the previous flaw. Take a look at the following class:

import java.util.List;
public final class NewNames {
private final List<String> names;
public Names(List<String> names) {
this.names = names;
}
public String getName(int index) {
return names.get(index);
}
public int size() {
return names.size();
}
}

As Names class before, also NewNames class seems immutable at the first sight, but it is not, in fact the following
snippet proves the contrary:

List<String> namesList = new ArrayList<String>();

namesList.add("Average Joe");
NewNames names = new NewNames(namesList);
System.out.println(names.size()); // 1, only containing "Average Joe"
namesList.add("Magic Mike");
System.out.println(names.size()); // 2, NOT OK, now names also contains "Magic Mike"

To fix this, as in the previous flaw, simply make defensive copies of the object without assigning it directly to the
immutable class, i.e. constructor can be changed as follows:

public Names(List<String> names) {

this.names = new ArrayList<String>(names);
}

Letting the methods of the class being overridden

Take a look at the following class:

public class Person {

private final String name;
public Person(String name) {
this.name = name;
}
public String getName() { return name;}

Java® Notes for Professionals 119

}

Person class seems immutable at the first sight, but suppose a new subclass of Person is defined:

public class MutablePerson extends Person {

private String newName;
public MutablePerson(String name) {
super(name);
}
@Override
public String getName() {
return newName;
}
public void setName(String name) {
newName = name;
}
}

now Person (im)mutability can be exploited through polymorphism by using the new subclass:

Person person = new MutablePerson("Average Joe");

System.out.println(person.getName()); prints Average Joe
person.setName("Magic Mike"); // NOT OK, person has now a new name!
System.out.println(person.getName()); // prints Magic Mike

To fix this, either mark the class as final so it cannot be extended or declare all of its constructor(s) as private.

Java® Notes for Professionals 120

Chapter 20: Visibility (controlling access to
members of a class)
Section 20.1: Private Visibility
private visibility allows a variable to only be accessed by its class. They are often used in conjunction with public
getters and setters.

class SomeClass {
private int variable;

public int getVariable() {

return variable;
}

public void setVariable(int variable) {

this.variable = variable;
}
}

public class SomeOtherClass {

public static void main(String[] args) {
SomeClass sc = new SomeClass();

// These statement won't compile because SomeClass#variable is private:

sc.variable = 7;
System.out.println(sc.variable);

// Instead, you should use the public getter and setter:

sc.setVariable(7);
System.out.println(sc.getVariable());
}
}

Section 20.2: Public Visibility

Visible to the class, package, and subclass.

Let's see an example with the class Test.

public class Test{

public int number = 2;

public Test(){

}
}

Now let's try to create an instance of the class. In this example, we can access number because it is public.

public class Other{

public static void main(String[] args){

Test t = new Test();
System.out.println(t.number);
}

Java® Notes for Professionals 121

}

Section 20.3: Package Visibility

With no modifier, the default is package visibility. From the Java Documentation, "[package visibility] indicates
whether classes in the same package as the class (regardless of their parentage) have access to the member." In
this example from javax.swing,

package javax.swing;
public abstract class JComponent extends Container … {
…
static boolean DEBUG_GRAPHICS_LOADED;
…
}

DebugGraphics is in the same package, so DEBUG_GRAPHICS_LOADED is accessible.

package javax.swing;
public class DebugGraphics extends Graphics {
…
static {
JComponent.DEBUG_GRAPHICS_LOADED = true;
}
…
}

This article gives some background on the topic.

Section 20.4: Protected Visibility

Protected visibility causes means that this member is visible to its package, along with any of its subclasses.

As an example:

package com.stackexchange.docs;
public class MyClass{
protected int variable; //This is the variable that we are trying to access
public MyClass(){
variable = 2;
};
}

Now we'll extend this class and try to access one of its protected members.

package some.other.pack;
import com.stackexchange.docs.MyClass;
public class SubClass extends MyClass{
public SubClass(){
super();
System.out.println(super.variable);
}
}

You would be also able to access a protected member without extending it if you are accessing it from the same
package.

Note that this modifier only works on members of a class, not on the class itself.

Java® Notes for Professionals 122

Section 20.5: Summary of Class Member Access Modifiers
Access Modifier Visibility Inheritance
Private Class only Can't be inherited
No modifier / Package In package Available if subclass in package
Protected In package Available in subclass
Public Everywhere Available in subclass

There was once a private protected (both keywords at once) modifier that could be applied to methods or
variables to make them accessible from a subclass outside the package, but make them private to the classes in
that package. However, this was removed in Java 1.0's release.

Section 20.6: Interface members

public interface MyInterface {
public void foo();
int bar();

public String TEXT = "Hello";

int ANSWER = 42;

public class X {
}

class Y {
}
}

Interface members always have public visibility, even if the public keyword is omitted. So both foo(), bar(), TEXT,
ANSWER, X, and Y have public visibility. However, access may still be limited by the containing interface - since
MyInterface has public visibility, its members may be accessed from anywhere, but if MyInterface had had
package visibility, its members would only have been accessible from within the same package.

Java® Notes for Professionals 123

Chapter 21: Generics
Generics are a facility of generic programming that extend Java's type system to allow a type or method to operate
on objects of various types while providing compile-time type safety. In particular, the Java collections framework
supports generics to specify the type of objects stored in a collection instance.

Section 21.1: Creating a Generic Class

Generics enable classes, interfaces, and methods to take other classes and interfaces as type parameters.

This example uses generic class Param to take a single type parameter T, delimited by angle brackets (<>):

public class Param<T> {

private T value;

public T getValue() {
return value;
}

public void setValue(T value) {

this.value = value;
}
}

To instantiate this class, provide a type argument in place of T. For example, Integer:

Param<Integer> integerParam = new Param<Integer>();

The type argument can be any reference type, including arrays and other generic types:

Param<String[]> stringArrayParam;
Param<int[][]> int2dArrayParam;
Param<Param<Object>> objectNestedParam;

In Java SE 7 and later, the type argument can be replaced with an empty set of type arguments (<>) called the
diamond:

Version ≥ Java SE 7
Param<Integer> integerParam = new Param<>();

Unlike other identifiers, type parameters have no naming constraints. However their names are commonly the first
letter of their purpose in upper case. (This is true even throughout the official JavaDocs.)
Examples include T for "type", E for "element" and K/V for "key"/"value".

Extending a generic class

public abstract class AbstractParam<T> {
private T value;

public T getValue() {
return value;
}

public void setValue(T value) {

this.value = value;
}

Java® Notes for Professionals 124

}

AbstractParam is an abstract class declared with a type parameter of T. When extending this class, that type
parameter can be replaced by a type argument written inside <>, or the type parameter can remain unchanged. In
the first and second examples below, String and Integer replace the type parameter. In the third example, the
type parameter remains unchanged. The fourth example doesn't use generics at all, so it's similar to if the class had
an Object parameter. The compiler will warn about AbstractParam being a raw type, but it will compile the
ObjectParam class. The fifth example has 2 type parameters (see "multiple type parameters" below), choosing the
second parameter as the type parameter passed to the superclass.

public class Email extends AbstractParam<String> {

// ...
}

public class Age extends AbstractParam<Integer> {

// ...
}

public class Height<T> extends AbstractParam<T> {

// ...
}

public class ObjectParam extends AbstractParam {

// ...
}

public class MultiParam<T, E> extends AbstractParam<E> {

// ...
}

The following is the usage:

Email email = new Email();

email.setValue("[email protected]");
String retrievedEmail = email.getValue();

Age age = new Age();

age.setValue(25);
Integer retrievedAge = age.getValue();
int autounboxedAge = age.getValue();

Height<Integer> heightInInt = new Height<>();

heightInInt.setValue(125);

Height<Float> heightInFloat = new Height<>();

heightInFloat.setValue(120.3f);

MultiParam<String, Double> multiParam = new MultiParam<>();

multiParam.setValue(3.3);

Notice that in the Email class, the T getValue() method acts as if it had a signature of String getValue(), and the
void setValue(T) method acts as if it was declared void setValue(String).

It is also possible to instantiate with anonymous inner class with an empty curly braces ({}):

AbstractParam<Double> height = new AbstractParam<Double>(){};

height.setValue(198.6);

Java® Notes for Professionals 125

Note that using the diamond with anonymous inner classes is not allowed.

Multiple type parameters

Java provides the ability to use more than one type parameter in a generic class or interface. Multiple type
parameters can be used in a class or interface by placing a comma-separated list of types between the angle
brackets. Example:

public class MultiGenericParam<T, S> {

private T firstParam;
private S secondParam;

public MultiGenericParam(T firstParam, S secondParam) {

this.firstParam = firstParam;
this.secondParam = secondParam;
}

public T getFirstParam() {
return firstParam;
}

public void setFirstParam(T firstParam) {

this.firstParam = firstParam;
}

public S getSecondParam() {
return secondParam;
}

public void setSecondParam(S secondParam) {

this.secondParam = secondParam;
}
}

The usage can be done as below:

MultiGenericParam<String, String> aParam = new MultiGenericParam<String, String>("value1",

"value2");
MultiGenericParam<Integer, Double> dayOfWeekDegrees = new MultiGenericParam<Integer, Double>(1,
2.6);

Section 21.2: Deciding between `T`, `? super T`, and `? extends

T`
The syntax for Java generics bounded wildcards, representing the unknown type by ? is:

? extends T represents an upper bounded wildcard. The unknown type represents a type that must be a
subtype of T, or type T itself.

? super T represents a lower bounded wildcard. The unknown type represents a type that must be a
supertype of T, or type T itself.

As a rule of thumb, you should use

? extends T if you only need "read" access ("input")

? super T if you need "write" access ("output")
T if you need both ("modify")

Java® Notes for Professionals 126

Using extends or super is usually better because it makes your code more flexible (as in: allowing the use of
subtypes and supertypes), as you will see below.

class Shoe {}
class IPhone {}
interface Fruit {}
class Apple implements Fruit {}
class Banana implements Fruit {}
class GrannySmith extends Apple {}

public class FruitHelper {

public void eatAll(Collection<? extends Fruit> fruits) {}

public void addApple(Collection<? super Apple> apples) {}

}

The compiler will now be able to detect certain bad usage:

public class GenericsTest {

public static void main(String[] args){
FruitHelper fruitHelper = new FruitHelper() ;
List<Fruit> fruits = new ArrayList<Fruit>();
fruits.add(new Apple()); // Allowed, as Apple is a Fruit
fruits.add(new Banana()); // Allowed, as Banana is a Fruit
fruitHelper.addApple(fruits); // Allowed, as "Fruit super Apple"
fruitHelper.eatAll(fruits); // Allowed

Collection<Banana> bananas = new ArrayList<>();

bananas.add(new Banana()); // Allowed
//fruitHelper.addApple(bananas); // Compile error: may only contain Bananas!
fruitHelper.eatAll(bananas); // Allowed, as all Bananas are Fruits

Collection<Apple> apples = new ArrayList<>();

fruitHelper.addApple(apples); // Allowed
apples.add(new GrannySmith()); // Allowed, as this is an Apple
fruitHelper.eatAll(apples); // Allowed, as all Apples are Fruits.

Collection<GrannySmith> grannySmithApples = new ArrayList<>();

fruitHelper.addApple(grannySmithApples); //Compile error: Not allowed.
// GrannySmith is not a supertype of Apple
apples.add(new GrannySmith()); //Still allowed, GrannySmith is an Apple
fruitHelper.eatAll(grannySmithApples);//Still allowed, GrannySmith is a Fruit

Collection<Object> objects = new ArrayList<>();

fruitHelper.addApple(objects); // Allowed, as Object super Apple
objects.add(new Shoe()); // Not a fruit
objects.add(new IPhone()); // Not a fruit
//fruitHelper.eatAll(objects); // Compile error: may contain a Shoe, too!
}

Choosing the right T, ? super T or ? extends T is necessary to allow the use with subtypes. The compiler can then
ensure type safety; you should not need to cast (which is not type safe, and may cause programming errors) if you
use them properly.

If it is not easy to understand, please remember PECS rule:

Producer uses "Extends" and Consumer uses "Super".

Java® Notes for Professionals 127

(Producer has only write access, and Consumer has only read access)

Section 21.3: The Diamond

Version ≥ Java SE 7

Java 7 introduced the Diamond1 to remove some boiler-plate around generic class instantiation. With Java 7+ you
can write:

List<String> list = new LinkedList<>();

Where you had to write in previous versions, this:

List<String> list = new LinkedList<String>();

One limitation is for Anonymous Classes, where you still must provide the type parameter in the instantiation:

// This will compile:

Comparator<String> caseInsensitiveComparator = new Comparator<String>() {

@Override
public int compare(String s1, String s2) {
return s1.compareToIgnoreCase(s2);
}
};

// But this will not:

Comparator<String> caseInsensitiveComparator = new Comparator<>() {

@Override
public int compare(String s1, String s2) {
return s1.compareToIgnoreCase(s2);
}
};
Version > Java SE 8

Although using the diamond with Anonymous Inner Classes is not supported in Java 7 and 8, it will be included as
a new feature in Java 9.

Footnote:

1 - Some people call the <> usage the "diamond operator". This is incorrect. The diamond does not behave as an
operator, and is not described or listed anywhere in the JLS or the (official) Java Tutorials as an operator. Indeed, <>
is not even a distinct Java token. Rather it is a < token followed by a > token, and it is legal (though bad style) to have
whitespace or comments between the two. The JLS and the Tutorials consistently refer to <> as "the diamond", and
that is therefore the correct term for it.

Section 21.4: Declaring a Generic Method

Methods can also have generic type parameters.

public class Example {

// The type parameter T is scoped to the method

// and is independent of type parameters of other methods.
public <T> List<T> makeList(T t1, T t2) {

Java® Notes for Professionals 128

 List<T> result = new ArrayList<T>();
result.add(t1);
result.add(t2);
return result;
}

public void usage() {

List<String> listString = makeList("Jeff", "Atwood");
List<Integer> listInteger = makeList(1, 2);
}
}

Notice that we don't have to pass an actual type argument to a generic method. The compiler infers the type
argument for us, based on the target type (e.g. the variable we assign the result to), or on the types of the actual
arguments. It will generally infer the most specific type argument that will make the call type-correct.

Sometimes, albeit rarely, it can be necessary to override this type inference with explicit type arguments:

void usage() {
consumeObjects(this.<Object>makeList("Jeff", "Atwood").stream());
}

void consumeObjects(Stream<Object> stream) { ... }

It's necessary in this example because the compiler can't "look ahead" to see that Object is desired for T after
calling stream() and it would otherwise infer String based on the makeList arguments. Note that the Java
language doesn't support omitting the class or object on which the method is called (this in the above example)
when type arguments are explicitly provided.

Section 21.5: Requiring multiple upper bounds ("extends A &

B")
You can require a generic type to extend multiple upper bounds.

Example: we want to sort a list of numbers but Number doesn't implement Comparable.

public <T extends Number & Comparable<T>> void sortNumbers( List<T> n ) {

Collections.sort( n );
}

In this example T must extend Number and implement Comparable<T> which should fit all "normal" built-in number
implementations like Integer or BigDecimal but doesn't fit the more exotic ones like Striped64.

Since multiple inheritance is not allowed, you can use at most one class as a bound and it must be the first listed.
For example, <T extends Comparable<T> & Number> is not allowed because Comparable is an interface, and not a
class.

Section 21.6: Obtain class that satisfies generic parameter at

runtime
Many unbound generic parameters, like those used in a static method, cannot be recovered at runtime (see Other
Threads on Erasure). However there is a common strategy employed for accessing the type satisfying a generic
parameter on a class at runtime. This allows for generic code that depends on access to type without having to
thread type information through every call.

Java® Notes for Professionals 129

Background

Generic parameterization on a class can be inspected by creating an anonymous inner class. This class will capture
the type information. In general this mechanism is referred to as super type tokens, which are detailed in Neal
Gafter's blog post.

Implementations

Three common implementations in Java are:

Guava's TypeToken
Spring's ParameterizedTypeReference
Jackson's TypeReference

Example usage

public class DataService<MODEL_TYPE> {

private final DataDao dataDao = new DataDao();
private final Class<MODEL_TYPE> type = (Class<MODEL_TYPE>) new TypeToken<MODEL_TYPE>
(getClass()){}.getRawType();
public List<MODEL_TYPE> getAll() {
return dataDao.getAllOfType(type);
}
}

// the subclass definitively binds the parameterization to User

// for all instances of this class, so that information can be
// recovered at runtime
public class UserService extends DataService<User> {}

public class Main {

public static void main(String[] args) {
UserService service = new UserService();
List<User> users = service.getAll();
}
}

Section 21.7: Benefits of Generic class and interface

Code that uses generics has many benefits over non-generic code. Below are the main benefits

Stronger type checks at compile time

A Java compiler applies strong type checking to generic code and issues errors if the code violates type safety. Fixing
compile-time errors is easier than fixing runtime errors, which can be difficult to find.

Elimination of casts

The following code snippet without generics requires casting:

List list = new ArrayList();

list.add("hello");
String s = (String) list.get(0);

When re-written to use generics, the code does not require casting:

Java® Notes for Professionals 130

List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0); // no cast

Enabling programmers to implement generic algorithms

By using generics, programmers can implement generic algorithms that work on collections of different types, can
be customized, and are type safe and easier to read.

Section 21.8: Instantiating a generic type

Due to type erasure the following will not work:

public <T> void genericMethod() {

T t = new T(); // Can not instantiate the type T.
}

The type T is erased. Since, at runtime, the JVM does not know what T originally was, it does not know which
constructor to call.

Workarounds

1. Passing T's class when calling genericMethod:

public <T> void genericMethod(Class<T> cls) {

try {
T t = cls.newInstance();
} catch (InstantiationException | IllegalAccessException e) {
System.err.println("Could not instantiate: " + cls.getName());
}
}

genericMethod(String.class);

Which throws exceptions, since there is no way to know if the passed class has an accessible default
constructor.

Version ≥ Java SE 8

2. Passing a reference to T's constructor:

public <T> void genericMethod(Supplier<T> cons) {

T t = cons.get();
}

genericMethod(String::new);

Section 21.9: Creating a Bounded Generic Class

You can restrict the valid types used in a generic class by bounding that type in the class definition. Given the
following simple type hierarchy:

public abstract class Animal {

public abstract String getSound();

Java® Notes for Professionals 131

}

public class Cat extends Animal {

public String getSound() {
return "Meow";
}
}

public class Dog extends Animal {

public String getSound() {
return "Woof";
}
}

Without bounded generics, we cannot make a container class that is both generic and knows that each element is
an animal:

public class AnimalContainer<T> {

private Collection<T> col;

public AnimalContainer() {
col = new ArrayList<T>();
}

public void add(T t) {

col.add(t);
}

public void printAllSounds() {

for (T t : col) {
// Illegal, type T doesn't have makeSound()
// it is used as an java.lang.Object here
System.out.println(t.makeSound());
}
}
}

With generic bound in class definition, this is now possible.

public class BoundedAnimalContainer<T extends Animal> { // Note bound here.

private Collection<T> col;

public BoundedAnimalContainer() {
col = new ArrayList<T>();
}

public void add(T t) {

col.add(t);
}

public void printAllSounds() {

for (T t : col) {
// Now works because T is extending Animal
System.out.println(t.makeSound());
}
}
}

Java® Notes for Professionals 132

This also restricts the valid instantiations of the generic type:

// Legal
AnimalContainer<Cat> a = new AnimalContainer<Cat>();

// Legal
AnimalContainer<String> a = new AnimalContainer<String>();

// Legal because Cat extends Animal

BoundedAnimalContainer<Cat> b = new BoundedAnimalContainer<Cat>();

// Illegal because String doesn't extends Animal

BoundedAnimalContainer<String> b = new BoundedAnimalContainer<String>();

Section 21.10: Referring to the declared generic type within its

own declaration
How do you go about using an instance of a (possibly further) inherited generic type within a method declaration in
the generic type itself being declared? This is one of the problems you will face when you dig a bit deeper into
generics, but still a fairly common one.

Assume we have a DataSeries<T> type (interface here), which defines a generic data series containing values of
type T. It is cumbersome to work with this type directly when we want to perform a lot of operations with e.g.
double values, so we define DoubleSeries extends DataSeries<Double>. Now assume, the original DataSeries<T>
type has a method add(values) which adds another series of the same length and returns a new one. How do we
enforce the type of values and the type of the return to be DoubleSeries rather than DataSeries<Double> in our
derived class?

The problem can be solved by adding a generic type parameter referring back to and extending the type being
declared (applied to an interface here, but the same stands for classes):

public interface DataSeries<T, DS extends DataSeries<T, DS>> {

DS add(DS values);
List<T> data();
}

Here T represents the data type the series holds, e.g. Double and DS the series itself. An inherited type (or types) can
now be easily implemented by substituting the above mentioned parameter by a corresponding derived type, thus,
yielding a concrete Double-based definition of the form:

public interface DoubleSeries extends DataSeries<Double, DoubleSeries> {

static DoubleSeries instance(Collection<Double> data) {
return new DoubleSeriesImpl(data);
}
}

At this moment even an IDE will implement the above interface with correct types in place, which, after a bit of
content filling may look like this:

class DoubleSeriesImpl implements DoubleSeries {

private final List<Double> data;

DoubleSeriesImpl(Collection<Double> data) {
this.data = new ArrayList<>(data);
}

@Override

Java® Notes for Professionals 133

 public DoubleSeries add(DoubleSeries values) {
List<Double> incoming = values != null ? values.data() : null;
if (incoming == null || incoming.size() != data.size()) {
throw new IllegalArgumentException("bad series");
}
List<Double> newdata = new ArrayList<>(data.size());
for (int i = 0; i < data.size(); i++) {
newdata.add(this.data.get(i) + incoming.get(i)); // beware autoboxing
}
return DoubleSeries.instance(newdata);
}

@Override
public List<Double> data() {
return Collections.unmodifiableList(data);
}
}

As you can see the add method is declared as DoubleSeries add(DoubleSeries values) and the compiler is
happy.

The pattern can be further nested if required.

Section 21.11: Binding generic parameter to more than 1 type

Generic parameters can also be bound to more than one type using the T extends Type1 & Type2 & ... syntax.

Let's say you want to create a class whose Generic type should implement both Flushable and Closeable, you can
write

class ExampleClass<T extends Flushable & Closeable> {

}

Now, the ExampleClass only accepts as generic parameters, types which implement both Flushable and
Closeable.

ExampleClass<BufferedWriter> arg1; // Works because BufferedWriter implements both Flushable and

Closeable

ExampleClass<Console> arg4; // Does NOT work because Console only implements Flushable
ExampleClass<ZipFile> arg5; // Does NOT work because ZipFile only implements Closeable

ExampleClass<Flushable> arg2; // Does NOT work because Closeable bound is not satisfied.
ExampleClass<Closeable> arg3; // Does NOT work because Flushable bound is not satisfied.

The class methods can choose to infer generic type arguments as either Closeable or Flushable.

class ExampleClass<T extends Flushable & Closeable> {

/* Assign it to a valid type as you want. */
public void test (T param) {
Flushable arg1 = param; // Works
Closeable arg2 = param; // Works too.
}

/* You can even invoke the methods of any valid type directly. */
public void test2 (T param) {
param.flush(); // Method of Flushable called on T and works fine.
param.close(); // Method of Closeable called on T and works fine too.

Java® Notes for Professionals 134

 }
}

Note:

You cannot bind the generic parameter to either of the type using OR (|) clause. Only the AND (&) clause is
supported. Generic type can extends only one class and many interfaces. Class must be placed at the beginning of
the list.

Section 21.12: Using Generics to auto-cast

With generics, it's possible to return whatever the caller expects:

private Map<String, Object> data;

public <T> T get(String key) {
return (T) data.get(key);
}

The method will compile with a warning. The code is actually more safe than it looks because the Java runtime will
do a cast when you use it:

Bar bar = foo.get("bar");

It's less safe when you use generic types:

List<Bar> bars = foo.get("bars");

Here, the cast will work when the returned type is any kind of List (i.e. returning List<String> would not trigger a
ClassCastException; you'd eventually get it when taking elements out of the list).

To work around this problem, you can create an API which uses typed keys:

public final static Key<List<Bar>> BARS = new Key<>("BARS");

along with this put() method:

public <T> T put(Key<T> key, T value);

With this approach, you can't put the wrong type into the map, so the result will always be correct (unless you
accidentally create two keys with the same name but different types).

Related:

Type-safe Map

Section 21.13: Use of instanceof with Generics

Using generics to define the type in instanceof

Consider the following generic class Example declared with the formal parameter <T>:

class Example<T> {
public boolean isTypeAString(String s) {
return s instanceof T; // Compilation error, cannot use T as class type here
}

Java® Notes for Professionals 135

}

This will always give a Compilation error because as soon as the compiler compiles the Java source into Java
bytecode it applies a process known as type erasure, which converts all generic code into non-generic code, making
impossible to distinguish among T types at runtime. The type used with instanceof has to be reifiable, which
means that all information about the type has to be available at runtime, and this is usually not the case for generic
types.

The following class represents what two different classes of Example, Example<String> and Example<Number>, look
like after generics has stripped off by type erasure:

class Example { // formal parameter is gone

public boolean isTypeAString(String s) {
return s instanceof Object; // Both <String> and <Number> are now Object
}
}

Since types are gone, it's not possible for the JVM to know which type is T.

Exception to the previous rule

You can always use unbounded wildcard (?) for specifying a type in the instanceof as follows:

public boolean isAList(Object obj) {

return obj instanceof List<?>;
}

This can be useful to evaluate whether an instance obj is a List or not:

System.out.println(isAList("foo")); // prints false

System.out.println(isAList(new ArrayList<String>()); // prints true
System.out.println(isAList(new ArrayList<Float>()); // prints true

In fact, unbounded wildcard is considered a reifiable type.

Using a generic instance with instanceof

The other side of the coin is that using an instance t of T with instanceof is legal, as shown in the following
example:

class Example<T> {
public boolean isTypeAString(T t) {
return t instanceof String; // No compilation error this time
}
}

because after the type erasure the class will look like the following:

class Example { // formal parameter is gone

public boolean isTypeAString(Object t) {
return t instanceof String; // No compilation error this time
}
}

Since, even if the type erasure happen anyway, now the JVM can distinguish among different types in memory, even
if they use the same reference type (Object), as the following snippet shows:

Java® Notes for Professionals 136

Object obj1 = new String("foo"); // reference type Object, object type String
Object obj2 = new Integer(11); // reference type Object, object type Integer
System.out.println(obj1 instanceof String); // true
System.out.println(obj2 instanceof String); // false, it's an Integer, not a String

Section 21.14: Dierent ways for implementing a Generic

Interface (or extending a Generic Class)
Suppose the following generic interface has been declared:

public interface MyGenericInterface<T> {

public void foo(T t);
}

Below are listed the possible ways to implement it.

Non-generic class implementation with a specific type

Choose a specific type to replace the formal type parameter <T> of MyGenericClass and implement it, as the
following example does:

public class NonGenericClass implements MyGenericInterface<String> {

public void foo(String t) { } // type T has been replaced by String
}

This class only deals with String, and this means that using MyGenericInterface with different parameters (e.g.
Integer, Object etc.) won't compile, as the following snippet shows:

NonGenericClass myClass = new NonGenericClass();

myClass.foo("foo_string"); // OK, legal
myClass.foo(11); // NOT OK, does not compile
myClass.foo(new Object()); // NOT OK, does not compile

Generic class implementation

Declare another generic interface with the formal type parameter <T> which implements MyGenericInterface, as
follows:

public class MyGenericSubclass<T> implements MyGenericInterface<T> {

public void foo(T t) { } // type T is still the same
// other methods...
}

Note that a different formal type parameter may have been used, as follows:

public class MyGenericSubclass<U> implements MyGenericInterface<U> { // equivalent to the previous

declaration
public void foo(U t) { }
// other methods...
}

Raw type class implementation

Declare a non-generic class which implements MyGenericInteface as a raw type (not using generic at all), as follows:

public class MyGenericSubclass implements MyGenericInterface {

Java® Notes for Professionals 137

 public void foo(Object t) { } // type T has been replaced by Object
// other possible methods
}

This way is not recommended, since it is not 100% safe at runtime because it mixes up raw type (of the subclass)
with generics (of the interface) and it is also confusing. Modern Java compilers will raise a warning with this kind of
implementation, nevertheless the code - for compatibility reasons with older JVM (1.4 or earlier) - will compile.

All the ways listed above are also allowed when using a generic class as a supertype instead of a generic interface.

Java® Notes for Professionals 138

Chapter 22: Classes and Objects
Objects have states and behaviors. Example: A dog has states - color, name, breed as well as behaviors – wagging
the tail, barking, eating. An object is an instance of a class.

Class ? A class can be defined as a template/blueprint that describes the behavior/state that the object of its type
support.

Section 22.1: Overloading Methods

Sometimes the same functionality has to be written for different kinds of inputs. At that time, one can use the same
method name with a different set of parameters. Each different set of parameters is known as a method signature.
As seen per the example, a single method can have multiple signatures.

public class Displayer {

public void displayName(String firstName) {

System.out.println("Name is: " + firstName);
}

public void displayName(String firstName, String lastName) {

System.out.println("Name is: " + firstName + " " + lastName);
}

public static void main(String[] args) {

Displayer displayer = new Displayer();
displayer.displayName("Ram"); //prints "Name is: Ram"
displayer.displayName("Jon", "Skeet"); //prints "Name is: Jon Skeet"
}
}

The advantage is that the same functionality is called with two different numbers of inputs. While invoking the
method according to the input we are passing, (In this case either one string value or two string values) the
corresponding method is executed.

Methods can be overloaded:

1. Based on the number of parameters passed.

Example: method(String s) and method(String s1, String s2).

2. Based on the order of parameters.

Example: method(int i, float f) and method(float f, int i)).

Note: Methods cannot be overloaded by changing just the return type (int method() is considered the same as String
method() and will throw a RuntimeException if attempted). If you change the return type you must also change the
parameters in order to overload.

Java® Notes for Professionals 139

Section 22.2: Explaining what is method overloading and
overriding
Method Overriding and Overloading are two forms of polymorphism supported by Java.

Method Overloading

Method overloading (also known as static Polymorphism) is a way you can have two (or more) methods (functions)
with same name in a single class. Yes its as simple as that.

public class Shape{

//It could be a circle or rectangle or square
private String type;

//To calculate area of rectangle

public Double area(Long length, Long breadth){
return (Double) length * breadth;
}

//To calculate area of a circle

public Double area(Long radius){
return (Double) 3.14 * r * r;
}
}

This way user can call the same method for area depending on the type of shape it has.

But the real question now is, how will java compiler will distinguish which method body is to be executed?

Well Java have made it clear that even though the method names (area() in our case) can be same but the
arguments method is taking should be different.

Overloaded methods must have different arguments list (quantity and types).

That being said we cannot add another method to calculate area of a square like this : public Double area(Long
side) because in this case, it will conflict with area method of circle and will cause ambiguity for java compiler.

Thank god, there are some relaxations while writing overloaded methods like

May have different return types.

May have different access modifiers.

May throw different exceptions.

Why is this called static polymorphism?

Well that's because which overloaded methods is to be invoked is decided at compile time, based on the actual
number of arguments and the compile-time types of the arguments.

Java® Notes for Professionals 140

 One of common reasons of using method overloading is the simplicity of code it provides. For example
remember String.valueOf() which takes almost any type of argument? What is written behind the
scene is probably something like this:

static String valueOf(boolean b)

static String valueOf(char c)
static String valueOf(char[] data)
static String valueOf(char[] data, int offset, int count)
static String valueOf(double d)
static String valueOf(float f)
static String valueOf(int i)
static String valueOf(long l)
static String valueOf(Object obj)

Method Overriding

Well, method overriding (yes you guess it right, it is also known as dynamic polymorphism) is somewhat more
interesting and complex topic.

In method overriding we overwrite the method body provided by the parent class. Got it? No? Let's go through an
example.

public abstract class Shape{

public abstract Double area(){

return 0.0;
}
}

So we have a class called Shape and it has method called area which will probably return the area of the shape.

Let's say now we have two classes called Circle and Rectangle.

public class Circle extends Shape {

private Double radius = 5.0;

// See this annotation @Override, it is telling that this method is from parent
// class Shape and is overridden here
@Override
public Double area(){
return 3.14 * radius * radius;
}
}

Similarly rectangle class:

public class Rectangle extends Shape {

private Double length = 5.0;
private Double breadth= 10.0;

// See this annotation @Override, it is telling that this method is from parent
// class Shape and is overridden here
@Override
public Double area(){
return length * breadth;
}

Java® Notes for Professionals 141

}

So, now both of your children classes have updated method body provided by the parent (Shape) class. Now
question is how to see the result? Well lets do it the old psvm way.

public class AreaFinder{

public static void main(String[] args){

//This will create an object of circle class

Shape circle = new Circle();
//This will create an object of Rectangle class
Shape rectangle = new Rectangle();

// Drumbeats ......
//This should print 78.5
System.out.println("Shape of circle : "+circle.area());

//This should print 50.0

System.out.println("Shape of rectangle: "+rectangle.area());

}
}

Wow! isn't it great? Two objects of same type calling same methods and returning different values. My friend, that's
the power of dynamic polymorphism.

Here's a chart to better compare the differences between these two:

Method Overloading Method Overriding

Method overriding is used to provide the specific
Method overloading is used to increase the readability of
implementation of the method that is already
the program.
provided by its super class.
Method overriding occurs in two classes that have IS-A
Method overloading is performed within class.
(inheritance) relationship.
In case of method overloading, parameter must be In case of method overriding, parameter must be
different. same.
Method overloading is the example of compile time Method overriding is the example of run time
polymorphism. polymorphism.
In java, method overloading can't be performed by
changing return type of the method only. Return type can Return type must be same or covariant in method
be same or different in method overloading. But you must overriding.
have to change the parameter.

Section 22.3: Constructors

Constructors are special methods named after the class and without a return type, and are used to construct
objects. Constructors, like methods, can take input parameters. Constructors are used to initialize objects. Abstract
classes can have constructors also.

public class Hello{

// constructor
public Hello(String wordToPrint){
printHello(wordToPrint);
}
public void printHello(String word){
System.out.println(word);
}
}

Java® Notes for Professionals 142

// instantiates the object during creating and prints out the content
// of wordToPrint

It is important to understand that constructors are different from methods in several ways:

1. Constructors can only take the modifiers public, private, and protected, and cannot be declared abstract,
final, static, or synchronized.

2. Constructors do not have a return type.

3. Constructors MUST be named the same as the class name. In the Hello example, the Hello object's
constructor name is the same as the class name.

4. The this keyword has an additional usage inside constructors. this.method(...) calls a method on the
current instance, while this(...) refers to another constructor in the current class with different signatures.

Constructors also can be called through inheritance using the keyword super.

public class SuperManClass{

public SuperManClass(){
// some implementation
}

// ... methods
}

public class BatmanClass extends SupermanClass{

public BatmanClass(){
super();
}
//... methods...
}

See Java Language Specification #8.8 and #15.9

Section 22.4: Initializing static final fields using a static

initializer
To initialize a static final fields that require using more than a single expression, a static initializer can be used
to assign the value. The following example initializes a unmodifiable set of Strings:

public class MyClass {

public static final Set<String> WORDS;

static {
Set<String> set = new HashSet<>();
set.add("Hello");
set.add("World");
set.add("foo");
set.add("bar");
set.add("42");
WORDS = Collections.unmodifiableSet(set);
}
}

Java® Notes for Professionals 143

Section 22.5: Basic Object Construction and Use
Objects come in their own class, so a simple example would be a car (detailed explanations below):

public class Car {

//Variables describing the characteristics of an individual car, varies per object

private int milesPerGallon;
private String name;
private String color;
public int numGallonsInTank;

public Car(){
milesPerGallon = 0;
name = "";
color = "";
numGallonsInTank = 0;
}

//this is where an individual object is created

public Car(int mpg, int, gallonsInTank, String carName, String carColor){
milesPerGallon = mpg;
name = carName;
color = carColor;
numGallonsInTank = gallonsInTank;
}

//methods to make the object more usable

//Cars need to drive

public void drive(int distanceInMiles){
//get miles left in car
int miles = numGallonsInTank * milesPerGallon;

//check that car has enough gas to drive distanceInMiles

if (miles <= distanceInMiles){
numGallonsInTank = numGallonsInTank - (distanceInMiles / milesPerGallon)
System.out.println("Drove " + numGallonsInTank + " miles!");
} else {
System.out.println("Could not drive!");
}
}

public void paintCar(String newColor){

color = newColor;
}
//set new Miles Per Gallon
public void setMPG(int newMPG){
milesPerGallon = newMPG;
}

//set new number of Gallon In Tank

public void setGallonsInTank(int numGallons){
numGallonsInTank = numGallons;
}

public void nameCar(String newName){

name = newName;
}

//Get the Car color

Java® Notes for Professionals 144

 public String getColor(){
return color;
}

//Get the Car name

public String getName(){
return name;
}

//Get the number of Gallons

public String getGallons(){
return numGallonsInTank;
}

Objects are instances of their class. So, the way you would create an object would be by calling the Car class in
one of two ways in your main class (main method in Java or onCreate in Android).

Option 1

`Car newCar = new Car(30, 10, "Ferrari", "Red");

Option 1 is where you essentially tell the program everything about the Car upon creation of the object. Changing
any property of the car would require calling one of the methods such as the repaintCar method. Example:

newCar.repaintCar("Blue");

Note: Make sure you pass the correct data type to the method. In the example above, you may also pass a variable
to the repaintCar method as long as the data type is correct`.

That was an example of changing properties of an object, receiving properties of an object would require using a
method from the Car class that has a return value (meaning a method that is not void). Example:

String myCarName = newCar.getName(); //returns string "Ferrari"

Option 1 is the best option when you have all the object's data at the time of creation.

Option 2

`Car newCar = new Car();

Option 2 gets the same effect but required more work to create an object correctly. I want to recall this Constructor
in the Car class:

public void Car(){

milesPerGallon = 0;
name = "";
color = "";
numGallonsInTank = 0;
}

Notice that you do not have to actually pass any parameters into the object to create it. This is very useful for when
you do not have all the aspects of the object but you need to use the parts that you do have. This sets generic data
into each of the instance variables of the object so that, if you call for a piece of data that does not exist, no errors
are thrown.

Java® Notes for Professionals 145

Note: Do not forget that you have to set the parts of the object later that you did not initialize it with. For example,

Car myCar = new Car();

String color = Car.getColor(); //returns empty string

This is a common mistake amongst objects that are not initialized with all their data. Errors were avoided because
there is a Constructor that allows an empty Car object to be created with stand-in variables (public Car(){}), but
no part of the myCar was actually customized. Correct example of creating Car Object:

Car myCar = new Car();

myCar.nameCar("Ferrari");
myCar.paintCar("Purple");
myCar.setGallonsInTank(10);
myCar.setMPG(30);

And, as a reminder, get an object's properties by calling a method in your main class. Example:

String myCarName = myCar.getName(); //returns string "Ferrari"

Section 22.6: Simplest Possible Class

class TrivialClass {}

A class consists at a minimum of the class keyword, a name, and a body, which might be empty.

You instantiate a class with the new operator.

TrivialClass tc = new TrivialClass();

Section 22.7: Object Member vs Static Member

With this class:

class ObjectMemberVsStaticMember {

static int staticCounter = 0;

int memberCounter = 0;

void increment() {
staticCounter ++;
memberCounter++;
}
}

the following code snippet:

final ObjectMemberVsStaticMember o1 = new ObjectMemberVsStaticMember();

final ObjectMemberVsStaticMember o2 = new ObjectMemberVsStaticMember();

o1.increment();

o2.increment();
o2.increment();

System.out.println("o1 static counter " + o1.staticCounter);

System.out.println("o1 member counter " + o1.memberCounter);

Java® Notes for Professionals 146

System.out.println();

System.out.println("o2 static counter " + o2.staticCounter);

System.out.println("o2 member counter " + o2.memberCounter);
System.out.println();

System.out.println("ObjectMemberVsStaticMember.staticCounter = " +
ObjectMemberVsStaticMember.staticCounter);

// the following line does not compile. You need an object

// to access its members
//System.out.println("ObjectMemberVsStaticMember.staticCounter = " +
ObjectMemberVsStaticMember.memberCounter);

produces this output:

o1 static counter 3
o1 member counter 1

o2 static counter 3
o2 member counter 2

ObjectMemberVsStaticMember.staticCounter = 3

Note: You should not call static members on objects, but on classes. While it does not make a difference for the
JVM, human readers will appreciate it.

static members are part of the class and exists only once per class. Non-static members exist on instances, there
is an independent copy for each instance. This also means that you need access to an object of that class to access
its members.

Java® Notes for Professionals 147

Chapter 23: Local Inner Class
A class i.e. created inside a method is called local inner class in java. If you want to invoke the methods of local
inner class, you must instantiate this class inside the method.

Section 23.1: Local Inner Class

public class localInner1{
private int data=30;//instance variable
void display(){
class Local{
void msg(){System.out.println(data);}
}
Local l=new Local();
l.msg();
}
public static void main(String args[]){
localInner1 obj=new localInner1();
obj.display();
}
}

Java® Notes for Professionals 148

Chapter 24: Nested and Inner Classes
Using Java, developers have the ability to define a class within another class. Such a class is called a Nested Class.
Nested Classes are called Inner Classes if they were declared as non-static, if not, they are simply called Static
Nested Classes. This page is to document and provide details with examples on how to use Java Nested and Inner
Classes.

Section 24.1: A Simple Stack Using a Nested Class

public class IntStack {

private IntStackNode head;

// IntStackNode is the inner class of the class IntStack

// Each instance of this inner class functions as one link in the
// Overall stack that it helps to represent
private static class IntStackNode {

private int val;

private IntStackNode next;

private IntStackNode(int v, IntStackNode n) {

val = v;
next = n;
}
}

public IntStack push(int v) {

head = new IntStackNode(v, head);
return this;
}

public int pop() {

int x = head.val;
head = head.next;
return x;
}
}

And the use thereof, which (notably) does not at all acknowledge the existence of the nested class.

public class Main {

public static void main(String[] args) {

IntStack s = new IntStack();

s.push(4).push(3).push(2).push(1).push(0);

//prints: 0, 1, 2, 3, 4,
for(int i = 0; i < 5; i++) {
System.out.print(s.pop() + ", ");
}
}
}

Section 24.2: Static vs Non Static Nested Classes

When creating a nested class, you face a choice of having that nested class static:

Java® Notes for Professionals 149

public class OuterClass1 {

private static class StaticNestedClass {

Or non-static:

public class OuterClass2 {

private class NestedClass {

At its core, static nested classes do not have a surrounding instance of the outer class, whereas non-static nested
classes do. This affects both where/when one is allowed to instantiate a nested class, and what instances of those
nested classes are allowed to access. Adding to the above example:

public class OuterClass1 {

private int aField;

public void aMethod(){}

private static class StaticNestedClass {

private int innerField;

private StaticNestedClass() {
innerField = aField; //Illegal, can't access aField from static context
aMethod(); //Illegal, can't call aMethod from static context
}

private StaticNestedClass(OuterClass1 instance) {

innerField = instance.aField; //Legal
}

public static void aStaticMethod() {

StaticNestedClass s = new StaticNestedClass(); //Legal, able to construct in static context
//Do stuff involving s...
}

public class OuterClass2 {

private int aField;

public void aMethod() {}

private class NestedClass {

private int innerField;

private NestedClass() {
innerField = aField; //Legal
aMethod(); //Legal

Java® Notes for Professionals 150

 }
}

public void aNonStaticMethod() {

NestedClass s = new NestedClass(); //Legal
}

public static void aStaticMethod() {

NestedClass s = new NestedClass(); //Illegal. Can't construct without surrounding
OuterClass2 instance.
//As this is a static context, there is no surrounding
OuterClass2 instance
}
}

Thus, your decision of static vs non-static mainly depends on whether or not you need to be able to directly access
fields and methods of the outer class, though it also has consequences for when and where you can construct the
nested class.

As a rule of thumb, make your nested classes static unless you need to access fields and methods of the outer
class. Similar to making your fields private unless you need them public, this decreases the visibility available to the
nested class (by not allowing access to an outer instance), reducing the likelihood of error.

Section 24.3: Access Modifiers for Inner Classes

A full explanation of Access Modifiers in Java can be found here. But how do they interact with Inner classes?

public, as usual, gives unrestricted access to any scope able to access the type.

public class OuterClass {

public class InnerClass {

public int x = 5;

public InnerClass createInner() {

return new InnerClass();
}
}

public class SomeOtherClass {

public static void main(String[] args) {

int x = new OuterClass().createInner().x; //Direct field access is legal
}
}

both protected and the default modifier (of nothing) behave as expected as well, the same as they do for non-
nested classes.

private, interestingly enough, does not restrict to the class it belongs to. Rather, it restricts to the compilation unit -
the .java file. This means that Outer classes have full access to Inner class fields and methods, even if they are
marked private.

public class OuterClass {

Java® Notes for Professionals 151

 public class InnerClass {

private int x;
private void anInnerMethod() {}
}

public InnerClass aMethod() {

InnerClass a = new InnerClass();
a.x = 5; //Legal
a.anInnerMethod(); //Legal
return a;
}
}

The Inner Class itself can have a visibility other than public. By marking it private or another restricted access
modifier, other (external) classes will not be allowed to import and assign the type. They can still get references to
objects of that type, however.

public class OuterClass {

private class InnerClass{}

public InnerClass makeInnerClass() {

return new InnerClass();
}
}

public class AnotherClass {

public static void main(String[] args) {

OuterClass o = new OuterClass();

InnerClass x = o.makeInnerClass(); //Illegal, can't find type

OuterClass.InnerClass x = o.makeInnerClass(); //Illegal, InnerClass has visibility private
Object x = o.makeInnerClass(); //Legal
}
}

Section 24.4: Anonymous Inner Classes

An anonymous inner class is a form of inner class that is declared and instantiated with a single statement. As a
consequence, there is no name for the class that can be used elsewhere in the program; i.e. it is anonymous.

Anonymous classes are typically used in situations where you need to be able to create a light-weight class to be
passed as a parameter. This is typically done with an interface. For example:

public static Comparator<String> CASE_INSENSITIVE =

new Comparator<String>() {
@Override
public int compare(String string1, String string2) {
return string1.toUpperCase().compareTo(string2.toUpperCase());
}
};

This anonymous class defines a Comparator<String> object (CASE_INSENSITIVE) that compares two strings ignoring
differences in case.

Other interfaces that are frequently implemented and instantiated using anonymous classes are Runnable and

Java® Notes for Professionals 152

Callable. For example:

// An anonymous Runnable class is used to provide an instance that the Thread

// will run when started.
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Hello world");
}
});
t.start(); // Prints "Hello world"

Anonymous inner classes can also be based on classes. In this case, the anonymous class implicitly extends the
existing class. If the class being extended is abstract, then the anonymous class must implement all abstract
methods. It may also override non-abstract methods.

Constructors

An anonymous class cannot have an explicit constructor. Instead, an implicit constructor is defined that uses
super(...) to pass any parameters to a constructor in the class that is being extended. For example:

SomeClass anon = new SomeClass(1, "happiness") {

@Override
public int someMethod(int arg) {
// do something
}
};

The implicit constructor for our anonymous subclass of SomeClass will call a constructor of SomeClass that matches
the call signature SomeClass(int, String). If no constructor is available, you will get a compilation error. Any
exceptions that are thrown by the matched constructor are also thrown by the implicit constructor.

Naturally, this does not work when extending an interface. When you create an anonymous class from an interface,
the classes superclass is java.lang.Object which only has a no-args constructor.

Section 24.5: Create instance of non-static inner class from

outside
An inner class which is visible to any outside class can be created from this class as well.

The inner class depends on the outside class and requires a reference to an instance of it. To create an instance of
the inner class, the new operator only needs to be called on an instance of the outer class.

class OuterClass {

class InnerClass {
}
}

class OutsideClass {

OuterClass outer = new OuterClass();

OuterClass.InnerClass createInner() {
return outer.new InnerClass();
}
}

Java® Notes for Professionals 153

Note the usage as outer.new.

Section 24.6: Method Local Inner Classes

A class written within a method called method local inner class. In that case the scope of the inner class is
restricted within the method.

A method-local inner class can be instantiated only within the method where the inner class is defined.

The example of using method local inner class:

public class OuterClass {

private void outerMethod() {
final int outerInt = 1;
// Method Local Inner Class
class MethodLocalInnerClass {
private void print() {
System.out.println("Method local inner class " + outerInt);
}
}
// Accessing the inner class
MethodLocalInnerClass inner = new MethodLocalInnerClass();
inner.print();
}

public static void main(String args[]) {

OuterClass outer = new OuterClass();
outer.outerMethod();
}
}

Executing will give an output:

Method local inner class 1

Section 24.7: Accessing the outer class from a non-static

inner class
The reference to the outer class uses the class name and this

public class OuterClass {

public class InnerClass {
public void method() {
System.out.println("I can access my enclosing class: " + OuterClass.this);
}
}
}

You can access fields and methods of the outer class directly.

public class OuterClass {

private int counter;

public class InnerClass {

public void method() {
System.out.println("I can access " + counter);

Java® Notes for Professionals 154

 }
}
}

But in case of name collision you can use the outer class reference.

public class OuterClass {

private int counter;

public class InnerClass {

private int counter;

public void method() {

System.out.println("My counter: " + counter);
System.out.println("Outer counter: " + OuterClass.this.counter);

// updating my counter
counter = OuterClass.this.counter;
}
}
}

Java® Notes for Professionals 155

Chapter 25: The java.util.Objects Class
Section 25.1: Basic use for object null check
For null check in method
Object nullableObject = methodReturnObject();
if (Objects.isNull(nullableObject)) {
return;
}

For not null check in method

Object nullableObject = methodReturnObject();
if (Objects.nonNull(nullableObject)) {
return;
}

Section 25.2: Objects.nonNull() method reference use in

stream api
In the old fashion way for collection null check

List<Object> someObjects = methodGetList();

for (Object obj : someObjects) {
if (obj == null) {
continue;
}
doSomething(obj);
}

With the Objects.nonNull method and Java8 Stream API, we can do the above in this way:

List<Object> someObjects = methodGetList();

someObjects.stream()
.filter(Objects::nonNull)
.forEach(this::doSomething);

Java® Notes for Professionals 156

Chapter 26: Default Methods
Default Method introduced in Java 8, allows developers to add new methods to an interface without breaking the
existing implementations of this interface. It provides flexibility to allow the interface to define an implementation
which will be used as default when a class which implements that interface fails to provide an implementation of
that method.

Section 26.1: Basic usage of default methods

/**
* Interface with default method
*/
public interface Printable {
default void printString() {
System.out.println( "default implementation" );
}
}

/**
* Class which falls back to default implementation of {@link #printString()}
*/
public class WithDefault
implements Printable
{
}

/**
* Custom implementation of {@link #printString()}
*/
public class OverrideDefault
implements Printable {
@Override
public void printString() {
System.out.println( "overridden implementation" );
}
}

The following statements

new WithDefault().printString();
new OverrideDefault().printString();

Will produce this output:

default implementation

overridden implementation

Section 26.2: Accessing overridden default methods from

implementing class
In classes, super.foo() will look in superclasses only. If you want to call a default implementation from a
superinterface, you need to qualify super with the interface name: Fooable.super.foo().

public interface Fooable {

Java® Notes for Professionals 157

 default int foo() {return 3;}
}

public class A extends Object implements Fooable {

@Override
public int foo() {
//return super.foo() + 1; //error: no method foo() in java.lang.Object
return Fooable.super.foo() + 1; //okay, returns 4
}
}

Section 26.3: Why use Default Methods?

The simple answer is that it allows you to evolve an existing interface without breaking existing implementations.

For example, you have Swim interface that you published 20 years ago.

public interface Swim {

void backStroke();
}

We did a great job, our interface is very popular, there are many implementation on that around the world and you
don't have control over their source code.

public class FooSwimmer implements Swim {

public void backStroke() {
System.out.println("Do backstroke");
}
}

After 20 years, you've decided to add new functionality to the interface, but it looks like our interface is frozen
because it will break existing implementations.

Luckily Java 8 introduces brand new feature called Default method.

We can now add new method to the Swim interface.

public interface Swim {

void backStroke();
default void sideStroke() {
System.out.println("Default sidestroke implementation. Can be overridden");
}
}

Now all existing implementations of our interface can still work. But most importantly they can implement the
newly added method in their own time.

One of the biggest reasons for this change, and one of its biggest uses, is in the Java Collections framework. Oracle
could not add a foreach method to the existing Iterable interface without breaking all existing code which
implemented Iterable. By adding default methods, existing Iterable implementation will inherit the default
implementation.

Section 26.4: Accessing other interface methods within

default method
You can as well access other interface methods from within your default method.

Java® Notes for Professionals 158

public interface Summable {
int getA();

int getB();

default int calculateSum() {

return getA() + getB();
}
}

public class Sum implements Summable {

@Override
public int getA() {
return 1;
}

@Override
public int getB() {
return 2;
}
}

The following statement will print 3:

System.out.println(new Sum().calculateSum());

Default methods could be used along with interface static methods as well:

public interface Summable {

static int getA() {
return 1;
}

static int getB() {

return 2;
}

default int calculateSum() {

return getA() + getB();
}
}

public class Sum implements Summable {}

The following statement will also print 3:

System.out.println(new Sum().calculateSum());

Section 26.5: Default method multiple inheritance collision

Consider next example:

public interface A {
default void foo() { System.out.println("A.foo"); }
}

public interface B {
default void foo() { System.out.println("B.foo"); }

Java® Notes for Professionals 159

}

Here are two interfaces declaring default method foo with the same signature.

If you will try to extend these both interfaces in the new interface you have to make choice of two, because Java
forces you to resolve this collision explicitly.

First, you can declare method foo with the same signature as abstract, which will override A and B behaviour.

public interface ABExtendsAbstract extends A, B {

@Override
void foo();
}

And when you will implement ABExtendsAbstract in the class you will have to provide foo implementation:

public class ABExtendsAbstractImpl implements ABExtendsAbstract {

@Override
public void foo() { System.out.println("ABImpl.foo"); }
}

Or second, you can provide a completely new default implementation. You also may reuse code of A and B foo
methods by Accessing overridden default methods from implementing class.

public interface ABExtends extends A, B {

@Override
default void foo() { System.out.println("ABExtends.foo"); }
}

And when you will implement ABExtends in the class you will not have to provide foo implementation:

public class ABExtendsImpl implements ABExtends {}

Section 26.6: Class, Abstract class and Interface method

precedence
Implementations in classes, including abstract declarations, take precedence over all interface defaults.

Abstract class method takes precedence over Interface Default Method.

public interface Swim {

default void backStroke() {
System.out.println("Swim.backStroke");
}
}

public abstract class AbstractSwimmer implements Swim {

public void backStroke() {
System.out.println("AbstractSwimmer.backStroke");
}
}

public class FooSwimmer extends AbstractSwimmer {

}

The following statement

Java® Notes for Professionals 160

new FooSwimmer().backStroke();

Will produce

AbstractSwimmer.backStroke

Class method takes precedence over Interface Default Method

public interface Swim {

default void backStroke() {
System.out.println("Swim.backStroke");
}
}

public abstract class AbstractSwimmer implements Swim {

}

public class FooSwimmer extends AbstractSwimmer {

public void backStroke() {
System.out.println("FooSwimmer.backStroke");
}
}

The following statement

new FooSwimmer().backStroke();

Will produce

FooSwimmer.backStroke

Java® Notes for Professionals 161

Chapter 27: Packages
package in java is used to group class and interfaces. This helps developer to avoid conflict when there are huge
numbers of classes. If we use this package the classes we can create a class/interface with same name in different
packages. By using packages we can import the piece of again in another class. There many built in packages in java
like > 1.java.util > 2.java.lang > 3.java.io We can define our own user defined packages.

Section 27.1: Using Packages to create classes with the same

name
First Test.class:

package foo.bar

public class Test {

Also Test.class in another package

package foo.bar.baz

public class Test {

The above is fine because the two classes exist in different packages.

Section 27.2: Using Package Protected Scope

In Java if you don't provide an access modifier the default scope for variables is package-protected level. This means
that classes can access the variables of other classes within the same package as if those variables were publicly
available.

package foo.bar

public class ExampleClass {

double exampleNumber;
String exampleString;

public ExampleClass() {
exampleNumber = 3;
exampleString = "Test String";
}
//No getters or setters
}

package foo.bar

public class AnotherClass {

ExampleClass clazz = new ExampleClass();

System.out.println("Example Number: " + clazz.exampleNumber);

//Prints Example Number: 3
System.out.println("Example String: " + clazz.exampleString);
//Prints Example String: Test String

Java® Notes for Professionals 162

}

This method will not work for a class in another package:

package baz.foo

public class ThisShouldNotWork {

ExampleClass clazz = new ExampleClass();

System.out.println("Example Number: " + clazz.exampleNumber);

//Throws an exception
System.out.println("Example String: " + clazz.exampleString);
//Throws an exception
}

Java® Notes for Professionals 163

Chapter 28: Inheritance
Inheritance is a basic object oriented feature in which one class acquires and extends upon the properties of
another class, using the keyword extends. For Interfaces and the keyword implements, see interfaces.

Section 28.1: Inheritance

With the use of the extends keyword among classes, all the properties of the superclass (also known as the Parent
Class or Base Class) are present in the subclass (also known as the Child Class or Derived Class)

public class BaseClass {

public void baseMethod(){

System.out.println("Doing base class stuff");
}
}

public class SubClass extends BaseClass {

Instances of SubClass have inherited the method baseMethod():

SubClass s = new SubClass();

s.baseMethod(); //Valid, prints "Doing base class stuff"

Additional content can be added to a subclass. Doing so allows for additional functionality in the subclass without
any change to the base class or any other subclasses from that same base class:

public class Subclass2 extends BaseClass {

public void anotherMethod() {

System.out.println("Doing subclass2 stuff");
}
}

Subclass2 s2 = new Subclass2();

s2.baseMethod(); //Still valid , prints "Doing base class stuff"
s2.anotherMethod(); //Also valid, prints "Doing subclass2 stuff"

Fields are also inherited:

public class BaseClassWithField {

public int x;

public class SubClassWithField extends BaseClassWithField {

public SubClassWithField(int x) {
this.x = x; //Can access fields
}
}

private fields and methods still exist within the subclass, but are not accessible:

Java® Notes for Professionals 164

public class BaseClassWithPrivateField {

private int x = 5;

public int getX() {

return x;
}
}

public class SubClassInheritsPrivateField extends BaseClassWithPrivateField {

public void printX() {

System.out.println(x); //Illegal, can't access private field x
System.out.println(getX()); //Legal, prints 5
}
}

SubClassInheritsPrivateField s = new SubClassInheritsPrivateField();

int x = s.getX(); //x will have a value of 5.

In Java, each class may extend at most one other class.

public class A{}

public class B{}
public class ExtendsTwoClasses extends A, B {} //Illegal

This is known as multiple inheritance, and while it is legal in some languages, Java does not permit it with classes.

As a result of this, every class has an unbranching ancestral chain of classes leading to Object, from which all
classes descend.

Section 28.2: Abstract Classes

An abstract class is a class marked with the abstract keyword. It, contrary to non-abstract class, may contain
abstract - implementation-less - methods. It is, however, valid to create an abstract class without abstract methods.

An abstract class cannot be instantiated. It can be sub-classed (extended) as long as the sub-class is either also
abstract, or implements all methods marked as abstract by super classes.

An example of an abstract class:

public abstract class Component {

private int x, y;

public setPosition(int x, int y) {

this.x = x;
this.y = y;
}

public abstract void render();

}

The class must be marked abstract, when it has at least one abstract method. An abstract method is a method that
has no implementation. Other methods can be declared within an abstract class that have implementation in order
to provide common code for any sub-classes.

Attempting to instantiate this class will provide a compile error:

Java® Notes for Professionals 165

//error: Component is abstract; cannot be instantiated
Component myComponent = new Component();

However a class that extends Component, and provides an implementation for all of its abstract methods and can be
instantiated.

public class Button extends Component {

@Override
public void render() {
//render a button
}
}

public class TextBox extends Component {

@Override
public void render() {
//render a textbox
}
}

Instances of inheriting classes also can be cast as the parent class (normal inheritance) and they provide a
polymorphic effect when the abstract method is called.

Component myButton = new Button();

Component myTextBox = new TextBox();

myButton.render(); //renders a button

myTextBox.render(); //renders a text box

Abstract classes vs Interfaces

Abstract classes and interfaces both provide a way to define method signatures while requiring the
extending/implementing class to provide the implementation.

There are two key differences between abstract classes and interfaces:

A class may only extend a single class, but may implement many interfaces.
An abstract class can contain instance (non-static) fields, but interfaces may only contain static fields.

Version < Java SE 8

Methods declared in interfaces could not contain implementations, so abstract classes were used when it was
useful to provide additional methods which implementations called the abstract methods.

Version ≥ Java SE 8

Java 8 allows interfaces to contain default methods, usually implemented using the other methods of the interface,
making interfaces and abstract classes equally powerful in this regard.

Anonymous subclasses of Abstract Classes

As a convenience java allows for instantiation of anonymous instances of subclasses of abstract classes, which
provide implementations for the abstract methods upon creating the new object. Using the above example this
could look like this:

Java® Notes for Professionals 166

Component myAnonymousComponent = new Component() {
@Override
public void render() {
// render a quick 1-time use component
}
}

Section 28.3: Using 'final' to restrict inheritance and overriding

Final classes

When used in a class declaration, the final modifier prevents other classes from being declared that extend the
class. A final class is a "leaf" class in the inheritance class hierarchy.

// This declares a final class

final class MyFinalClass {
/* some code */
}

// Compilation error: cannot inherit from final MyFinalClass

class MySubClass extends MyFinalClass {
/* more code */
}

Use-cases for final classes

Final classes can be combined with a private constructor to control or prevent the instantiation of a class. This can
be used to create a so-called "utility class" that only defines static members; i.e. constants and static methods.

public final class UtilityClass {

// Private constructor to replace the default visible constructor

private UtilityClass() {}

// Static members can still be used as usual

public static int doSomethingCool() {
return 123;
}

Immutable classes should also be declared as final. (An immutable class is one whose instances cannot be
changed after they have been created; see the Immutable Objects topic. ) By doing this, you make it impossible to
create a mutable subclass of an immutable class. That would violate the Liskov Substitution Principle which
requires that a subtype should obey the "behavioral contract" of its supertypes.

From a practical perspective, declaring an immutable class to be final makes it easier to reason about program
behavior. It also addresses security concerns in the scenario where untrusted code is executed in a security
sandbox. (For instance, since String is declared as final, a trusted class does not need to worry that it might be
tricked into accepting mutable subclass, which the untrusted caller could then surreptitiously change.)

One disadvantage of final classes is that they do not work with some mocking frameworks such as Mockito.
Update: Mockito version 2 now support mocking of final classes.

Final methods

The final modifier can also be applied to methods to prevent them being overridden in sub-classes:

Java® Notes for Professionals 167

public class MyClassWithFinalMethod {

public final void someMethod() {

}
}

public class MySubClass extends MyClassWithFinalMethod {

@Override
public void someMethod() { // Compiler error (overridden method is final)
}
}

Final methods are typically used when you want to restrict what a subclass can change in a class without forbidding
subclasses entirely.

The final modifier can also be applied to variables, but the meaning of final for variables is unrelated to
inheritance.

Section 28.4: The Liskov Substitution Principle

Substitutability is a principle in object-oriented programming introduced by Barbara Liskov in a 1987 conference
keynote stating that, if class B is a subclass of class A, then wherever A is expected, B can be used instead:

class A {...}
class B extends A {...}

public void method(A obj) {...}

A a = new B(); // Assignment OK

method(new B()); // Passing as parameter OK

This also applies when the type is an interface, where there doesn't need to any hierarchical relationship between
the objects:

interface Foo {
void bar();
}

class A implements Foo {

void bar() {...}
}

class B implements Foo {

void bar() {...}
}

List<Foo> foos = new ArrayList<>();

foos.add(new A()); // OK
foos.add(new B()); // OK

Now the list contains objects that are not from the same class hierarchy.

Section 28.5: Abstract class and Interface usage: "Is-a"

relation vs "Has-a" capability
When to use abstract classes: To implement the same or different behaviour among multiple related objects

Java® Notes for Professionals 168

When to use interfaces: to implement a contract by multiple unrelated objects

Abstract classes create "is a" relations while interfaces provide "has a" capability.

This can be seen in the code below:

public class InterfaceAndAbstractClassDemo{

public static void main(String args[]){

Dog dog = new Dog("Jack",16);

Cat cat = new Cat("Joe",20);

System.out.println("Dog:"+dog);
System.out.println("Cat:"+cat);

dog.remember();
dog.protectOwner();
Learn dl = dog;
dl.learn();

cat.remember();
cat.protectOwner();

Climb c = cat;
c.climb();

Man man = new Man("Ravindra",40);

System.out.println(man);

Climb cm = man;
cm.climb();
Think t = man;
t.think();
Learn l = man;
l.learn();
Apply a = man;
a.apply();
}
}

abstract class Animal{

String name;
int lifeExpentency;
public Animal(String name,int lifeExpentency ){
this.name = name;
this.lifeExpentency=lifeExpentency;
}
public abstract void remember();
public abstract void protectOwner();

public String toString(){

return this.getClass().getSimpleName()+":"+name+":"+lifeExpentency;
}
}
class Dog extends Animal implements Learn{

public Dog(String name,int age){

super(name,age);
}
public void remember(){
System.out.println(this.getClass().getSimpleName()+" can remember for 5 minutes");

Java® Notes for Professionals 169

 }
public void protectOwner(){
System.out.println(this.getClass().getSimpleName()+ " will protect owner");
}
public void learn(){
System.out.println(this.getClass().getSimpleName()+ " can learn:");
}
}
class Cat extends Animal implements Climb {
public Cat(String name,int age){
super(name,age);
}
public void remember(){
System.out.println(this.getClass().getSimpleName() + " can remember for 16 hours");
}
public void protectOwner(){
System.out.println(this.getClass().getSimpleName()+ " won't protect owner");
}
public void climb(){
System.out.println(this.getClass().getSimpleName()+ " can climb");
}
}
interface Climb{
void climb();
}
interface Think {
void think();
}

interface Learn {
void learn();
}
interface Apply{
void apply();
}

class Man implements Think,Learn,Apply,Climb{

String name;
int age;

public Man(String name,int age){

this.name = name;
this.age = age;
}
public void think(){
System.out.println("I can think:"+this.getClass().getSimpleName());
}
public void learn(){
System.out.println("I can learn:"+this.getClass().getSimpleName());
}
public void apply(){
System.out.println("I can apply:"+this.getClass().getSimpleName());
}
public void climb(){
System.out.println("I can climb:"+this.getClass().getSimpleName());
}
public String toString(){
return "Man :"+name+":Age:"+age;
}
}

output:

Java® Notes for Professionals 170

Dog:Dog:Jack:16
Cat:Cat:Joe:20
Dog can remember for 5 minutes
Dog will protect owner
Dog can learn:
Cat can remember for 16 hours
Cat won't protect owner
Cat can climb
Man :Ravindra:Age:40
I can climb:Man
I can think:Man
I can learn:Man
I can apply:Man

Key notes:

1. Animal is an abstract class with shared attributes: name and lifeExpectancy and abstract methods:
remember() and protectOwner(). Dog and Cat are Animals that have implemented the remember() and
protectOwner() methods.

2. Cat can climb() but Dog cannot. Dog can think() but Cat cannot. These specific capabilities are added to Cat
and Dog by implementation.

3. Man is not an Animal but he can Think , Learn, Apply, and Climb.

4. Cat is not a Man but it can Climb.

5. Dog is not a Man but it can Learn

6. Man is neither a Cat nor a Dog but can have some of the capabilities of the latter two without extending
Animal, Cat, or Dog. This is done with Interfaces.

7. Even though Animal is an abstract class, it has a constructor, unlike an interface.

TL;DR:

Unrelated classes can have capabilities through interfaces, but related classes change the behaviour through extension of
base classes.

Refer to the Java documentation page to understand which one to use in a specific use case.

Consider using abstract classes if...

1. You want to share code among several closely related classes.

2. You expect that classes that extend your abstract class have many common methods or fields, or require
access modifiers other than public (such as protected and private).
3. You want to declare non-static or non-final fields.

Consider using interfaces if...

1. You expect that unrelated classes would implement your interface. For example, many unrelated objects can
implement the Serializable interface.
2. You want to specify the behaviour of a particular data type but are not concerned about who implements its
behaviour.
3. You want to take advantage of multiple inheritance of type.

Java® Notes for Professionals 171

Section 28.6: Static Inheritance
Static method can be inherited similar to normal methods, however unlike normal methods it is impossible to
create "abstract" methods in order to force static method overriding. Writing a method with the same signature as
a static method in a super class appears to be a form of overriding, but really this simply creates a new function
hides the other.

public class BaseClass {

public static int num = 5;

public static void sayHello() {

System.out.println("Hello");
}

public static void main(String[] args) {

BaseClass.sayHello();
System.out.println("BaseClass's num: " + BaseClass.num);

SubClass.sayHello();
//This will be different than the above statement's output, since it runs
//A different method
SubClass.sayHello(true);

StaticOverride.sayHello();
System.out.println("StaticOverride's num: " + StaticOverride.num);
}
}

public class SubClass extends BaseClass {

//Inherits the sayHello function, but does not override it

public static void sayHello(boolean test) {
System.out.println("Hey");
}
}

public static class StaticOverride extends BaseClass {

//Hides the num field from BaseClass

//You can even change the type, since this doesn't affect the signature
public static String num = "test";

//Cannot use @Override annotation, since this is static

//This overrides the sayHello method from BaseClass
public static void sayHello() {
System.out.println("Static says Hi");
}

Running any of these classes produces the output:

Hello
BaseClass's num: 5
Hello
Hey
Static says Hi
StaticOverride's num: test

Java® Notes for Professionals 172

Note that unlike normal inheritance, in static inheritance methods are not hidden. You can always call the base
sayHello method by using BaseClass.sayHello(). But classes do inherit static methods if no methods with the
same signature are found in the subclass. If two method's signatures vary, both methods can be run from the
subclass, even if the name is the same.

Static fields hide each other in a similar way.

Section 28.7: Programming to an interface

The idea behind programming to an interface is to base the code primarily on interfaces and only use concrete
classes at the time of instantiation. In this context, good code dealing with e.g. Java collections will look something
like this (not that the method itself is of any use at all, just illustration):

public <T> Set<T> toSet(Collection<T> collection) {

return Sets.newHashSet(collection);
}

while bad code might look like this:

public <T> HashSet<T> toSet(ArrayList<T> collection) {

return Sets.newHashSet(collection);
}

Not only the former can be applied to a wider choice of arguments, its results will be more compatible with code
provided by other developers that generally adhere to the concept of programming to an interface. However, the
most important reasons to use the former are:

most of the time the context, in which the result is used, does not and should not need that many details as
the concrete implementation provides;
adhering to an interface forces cleaner code and less hacks such as yet another public method gets added to
a class serving some specific scenario;
the code is more testable as interfaces are easily mockable;
finally, the concept helps even if only one implementation is expected (at least for testability).

So how can one easily apply the concept of programming to an interface when writing new code having in mind
one particular implementation? One option that we commonly use is a combination of the following patterns:

programming to an interface
factory
builder

The following example based on these principles is a simplified and truncated version of an RPC implementation
written for a number of different protocols:

public interface RemoteInvoker {

<RQ, RS> CompletableFuture<RS> invoke(RQ request, Class<RS> responseClass);
}

The above interface is not supposed to be instantiated directly via a factory, instead we derive further more
concrete interfaces, one for HTTP invocation and one for AMQP, each then having a factory and a builder to
construct instances, which in turn are also instances of the above interface:

public interface AmqpInvoker extends RemoteInvoker {

Java® Notes for Professionals 173

 static AmqpInvokerBuilder with(String instanceId, ConnectionFactory factory) {
return new AmqpInvokerBuilder(instanceId, factory);
}
}

Instances of RemoteInvoker for the use with AMQP can now be constructed as easy as (or more involved depending
on the builder):

RemoteInvoker invoker = AmqpInvoker.with(instanceId, factory)

.requestRouter(router)
.build();

And an invocation of a request is as easy as:

Response res = invoker.invoke(new Request(data), Response.class).get();

Due to Java 8 permitting placing of static methods directly into interfaces, the intermediate factory has become
implicit in the above code replaced with AmqpInvoker.with(). In Java prior to version 8, the same effect can be
achieved with an inner Factory class:

public interface AmqpInvoker extends RemoteInvoker {

class Factory {
public static AmqpInvokerBuilder with(String instanceId, ConnectionFactory factory) {
return new AmqpInvokerBuilder(instanceId, factory);
}
}
}

The corresponding instantiation would then turn into:

RemoteInvoker invoker = AmqpInvoker.Factory.with(instanceId, factory)

.requestRouter(router)
.build();

The builder used above could look like this (although this is a simplification as the actual one permits defining of up
to 15 parameters deviating from defaults). Note that the construct is not public, so it is specifically usable only from
the above AmqpInvoker interface:

public class AmqpInvokerBuilder {

...
AmqpInvokerBuilder(String instanceId, ConnectionFactory factory) {
this.instanceId = instanceId;
this.factory = factory;
}

public AmqpInvokerBuilder requestRouter(RequestRouter requestRouter) {

this.requestRouter = requestRouter;
return this;
}

public AmqpInvoker build() throws TimeoutException, IOException {

return new AmqpInvokerImpl(instanceId, factory, requestRouter);
}
}

Generally, a builder can also be generated using a tool like FreeBuilder.

Java® Notes for Professionals 174

Finally, the standard (and the only expected) implementation of this interface is defined as a package-local class to
enforce the use of the interface, the factory and the builder:

class AmqpInvokerImpl implements AmqpInvoker {

AmqpInvokerImpl(String instanceId, ConnectionFactory factory, RequestRouter requestRouter) {
...
}

@Override
public <RQ, RS> CompletableFuture<RS> invoke(final RQ request, final Class<RS> respClass) {
...
}
}

Meanwhile, this pattern proved to be very efficient in developing all our new code not matter how simple or
complex the functionality is.

Section 28.8: Overriding in Inheritance

Overriding in Inheritance is used when you use a already defined method from a super class in a sub class, but in a
different way than how the method was originally designed in the super class. Overriding allows the user to reuse
code by using existing material and modifying it to suit the user's needs better.

The following example demonstrates how ClassB overrides the functionality of ClassA by changing what gets sent
out through the printing method:

Example:

public static void main(String[] args) {

ClassA a = new ClassA();
ClassA b = new ClassB();
a.printing();
b.printing();
}

class ClassA {
public void printing() {
System.out.println("A");
}
}

class ClassB extends ClassA {

public void printing() {
System.out.println("B");
}
}

Output:

Java® Notes for Professionals 175

Section 28.9: Variable shadowing
Variables are SHADOWED and methods are OVERRIDDEN. Which variable will be used depends on the class that the
variable is declared of. Which method will be used depends on the actual class of the object that is referenced by
the variable.

class Car {
public int gearRatio = 8;

public String accelerate() {

return "Accelerate : Car";
}
}

class SportsCar extends Car {

public int gearRatio = 9;

public String accelerate() {

return "Accelerate : SportsCar";
}

public void test() {

public static void main(String[] args) {

Car car = new SportsCar();

System.out.println(car.gearRatio + " " + car.accelerate());
// will print out 8 Accelerate : SportsCar
}
}

Section 28.10: Narrowing and Widening of object references

Casting an instance of a base class to a subclass as in : b = (B) a; is called narrowing (as you are trying to narrow
the base class object to a more specific class object) and needs an explicit type-cast.

Casting an instance of a subclass to a base class as in: A a = b; is called widening and does not need a type-cast.

To illustrate, consider the following class declarations, and test code:

class Vehicle {
}

class Car extends Vehicle {

}

class Truck extends Vehicle {

}

class MotorCycle extends Vehicle {

}

class Test {

public static void main(String[] args) {

Java® Notes for Professionals 176

 Vehicle vehicle = new Car();
Car car = new Car();

vehicle = car; // is valid, no cast needed

Car c = vehicle // not valid

Car c = (Car) vehicle; //valid
}
}

The statement Vehicle vehicle = new Car(); is a valid Java statement. Every instance of Car is also a Vehicle.
Therefore, the assignment is legal without the need for an explicit type-cast.

On the other hand, Car c = vehicle; is not valid. The static type of the vehicle variable is Vehicle which means
that it could refer to an instance of Car, Truck,MotorCycle, or any other current or future subclass
ofVehicle. (Or indeed, an instance ofVehicleitself, since we did not declare it as anabstractclass.)
The assignment cannot be allowed, since that might lead tocarreferring to aTruck` instance.

To prevent this situation, we need to add an explicit type-cast:

Car c = (Car) vehicle;

The type-cast tells the compiler that we expect the value of vehicle to be a Car or a subclass of Car. If necessary,
compiler will insert code to perform a run-time type check. If the check fails, then a ClassCastException will be
thrown when the code is executed.

Note that not all type-casts are valid. For example:

String s = (String) vehicle; // not valid

The Java compiler knows that an instance that is type compatible with Vehicle cannot ever be type compatible with
String. The type-cast could never succeed, and the JLS mandates that this gives in a compilation error.

Section 28.11: Inheritance and Static Methods

In Java, parent and child class both can have static methods with the same name. But in such cases implementation
of static method in child is hiding parent class' implementation, it's not method overriding. For example:

class StaticMethodTest {

// static method and inheritance

public static void main(String[] args) {
Parent p = new Child();
p.staticMethod(); // prints Inside Parent
((Child) p).staticMethod(); // prints Inside Child
}

static class Parent {

public static void staticMethod() {
System.out.println("Inside Parent");
}
}

static class Child extends Parent {

public static void staticMethod() {
System.out.println("Inside Child");
}

Java® Notes for Professionals 177

 }
}

Static methods are bind to a class not to an instance and this method binding happens at compile time. Since in the
first call to staticMethod(), parent class reference p was used, Parent's version of staticMethod() is invoked. In
second case, we did cast p into Child class, Child's staticMethod() executed.

Java® Notes for Professionals 178

Chapter 29: Reference Types
Section 29.1: Dierent Reference Types
java.lang.ref package provides reference-object classes, which support a limited degree of interaction with the
garbage collector.

Java has four main different reference types. They are:

Strong Reference
Weak Reference
Soft Reference
Phantom Reference

1. Strong Reference

This is the usual form of creating objects.

MyObject myObject = new MyObject();

The variable holder is holding a strong reference to the object created. As long as this variable is live and holds this
value, the MyObject instance will not be collected by the garbage collector.

2. Weak Reference

When you do not want to keep an object longer, and you need to clear/free the memory allocated for an object as
soon as possible, this is the way to do so.

WeakReference myObjectRef = new WeakReference(MyObject);

Simply, a weak reference is a reference that isn't strong enough to force an object to remain in memory. Weak
references allow you to leverage the garbage collector's ability to determine reachability for you, so you don't have
to do it yourself.

When you need the object you created, just use .get() method:

myObjectRef.get();

Following code will exemplify this:

WeakReference myObjectRef = new WeakReference(MyObject);

System.out.println(myObjectRef.get()); // This will print the object reference address
System.gc();
System.out.println(myObjectRef.get()); // This will print 'null' if the GC cleaned up the object

3. Soft Reference

Soft references are slightly stronger than weak references. You can create a soft referenced object as following:

SoftReference myObjectRef = new SoftReference(MyObject);

They can hold onto the memory more strongly than the weak reference. If you have enough memory
supply/resources, garbage collector will not clean the soft references as enthusiastically as weak references.

Java® Notes for Professionals 179

Soft references are handy to use in caching. You can create soft referenced objects as a cache, where they kept
until your memory runs out. When your memory can't supply enough resources, garbage collector will remove soft
references.

SoftReference myObjectRef = new SoftReference(MyObject);

System.out.println(myObjectRef.get()); // This will print the reference address of the Object
System.gc();
System.out.println(myObjectRef.get()); // This may or may not print the reference address of the
Object

4. Phantom Reference

This is the weakest referencing type. If you created an object reference using Phantom Reference, the get()
method will always return null!

The use of this referencing is that "Phantom reference objects, which are enqueued after the collector determines
that their referents may otherwise be reclaimed. Phantom references are most often used for scheduling pre-
mortem cleanup actions in a more flexible way than is possible with the Java finalization mechanism." - From
Phantom Reference Javadoc from Oracle.

You can create an object of Phantom Reference as following:

PhantomReference myObjectRef = new PhantomReference(MyObject);

Java® Notes for Professionals 180

Chapter 30: Strings
Strings (java.lang.String) are pieces of text stored in your program. Strings are not a primitive data type in Java,
however, they are very common in Java programs.

In Java, Strings are immutable, meaning that they cannot be changed. (Click here for a more thorough explanation
of immutability.)

Section 30.1: Comparing Strings

In order to compare Strings for equality, you should use the String object's equals or equalsIgnoreCase methods.

For example, the following snippet will determine if the two instances of String are equal on all characters:

String firstString = "Test123";

String secondString = "Test" + 123;

if (firstString.equals(secondString)) {
// Both Strings have the same content.
}

Live demo

This example will compare them, independent of their case:

String firstString = "Test123";

String secondString = "TEST123";

if (firstString.equalsIgnoreCase(secondString)) {
// Both Strings are equal, ignoring the case of the individual characters.
}

Live demo

Note that equalsIgnoreCase does not let you specify a Locale. For instance, if you compare the two words "Taki"
and "TAKI" in English they are equal; however, in Turkish they are different (in Turkish, the lowercase I is ?). For
cases like this, converting both strings to lowercase (or uppercase) with Locale and then comparing with equals is
the solution.

String firstString = "Taki";

String secondString = "TAKI";

System.out.println(firstString.equalsIgnoreCase(secondString)); //prints true

Locale locale = Locale.forLanguageTag("tr-TR");

System.out.println(firstString.toLowerCase(locale).equals(
secondString.toLowerCase(locale))); //prints false

Live demo

Do not use the == operator to compare Strings

Unless you can guarantee that all strings have been interned (see below), you should not use the

==

Java® Notes for Professionals 181

or != operators to compare Strings. These operators actually test references, and since multiple String objects can
represent the same String, this is liable to give the wrong answer.

Instead, use the String.equals(Object) method, which will compare the String objects based on their values. For a
detailed explanation, please refer to Pitfall: using == to compare strings.

Comparing Strings in a switch statement

Version ≥ Java SE 7

As of Java 1.7, it is possible to compare a String variable to literals in a switch statement. Make sure that the String
is not null, otherwise it will always throw a NullPointerException. Values are compared using String.equals, i.e.
case sensitive.

String stringToSwitch = "A";

switch (stringToSwitch) {
case "a":
System.out.println("a");
break;
case "A":
System.out.println("A"); //the code goes here
break;
case "B":
System.out.println("B");
break;
default:
break;
}

Live demo

Comparing Strings with constant values

When comparing a String to a constant value, you can put the constant value on the left side of equals to ensure
that you won't get a NullPointerException if the other String is null.

"baz".equals(foo)

While foo.equals("baz") will throw a NullPointerException if foo is null, "baz".equals(foo) will evaluate to
false.

Version ≥ Java SE 7

A more readable alternative is to use Objects.equals(), which does a null check on both parameters:
Objects.equals(foo, "baz").

(Note: It is debatable as to whether it is better to avoid NullPointerExceptions in general, or let them happen and
then fix the root cause; see here and here. Certainly, calling the avoidance strategy "best practice" is not justifiable.)

String orderings

The String class implements Comparable<String> with the String.compareTo method (as described at the start of
this example). This makes the natural ordering of String objects case-sensitive order. The String class provide a
Comparator<String> constant called CASE_INSENSITIVE_ORDER suitable for case-insensitive sorting.

Comparing with interned Strings

Java® Notes for Professionals 182

The Java Language Specification (JLS 3.10.6) states the following:

"Moreover, a string literal always refers to the same instance of class String. This is because string literals
- or, more generally, strings that are the values of constant expressions - are interned so as to share
unique instances, using the method String.intern."

This means it is safe to compare references to two string literals using

==

. Moreover, the same is true for references to String objects that have been produced using the String.intern()
method.

For example:

String strObj = new String("Hello!");

String str = "Hello!";

// The two string references point two strings that are equal
if (strObj.equals(str)) {
System.out.println("The strings are equal");
}

// The two string references do not point to the same object

if (strObj != str) {
System.out.println("The strings are not the same object");
}

// If we intern a string that is equal to a given literal, the result is

// a string that has the same reference as the literal.
String internedStr = strObj.intern();

if (internedStr == str) {
System.out.println("The interned string and the literal are the same object");
}

Behind the scenes, the interning mechanism maintains a hash table that contains all interned strings that are still
reachable. When you call intern() on a String, the method looks up the object in the hash table:

If the string is found, then that value is returned as the interned string.
Otherwise, a copy of the string is added to the hash table and that string is returned as the interned string.

It is possible to use interning to allow strings to be compared using

==

. However, there are significant problems with doing this; see Pitfall - Interning strings so that you can use == is a
bad idea for details. It is not recommended in most cases.

Section 30.2: Changing the case of characters within a String

The String type provides two methods for converting strings between upper case and lower case:

toUpperCase to convert all characters to upper case

toLowerCase to convert all characters to lower case

Java® Notes for Professionals 183

These methods both return the converted strings as new String instances: the original String objects are not
modified because String is immutable in Java. See this for more on immutability : Immutability of Strings in Java

String string = "This is a Random String";

String upper = string.toUpperCase();
String lower = string.toLowerCase();

System.out.println(string); // prints "This is a Random String"

System.out.println(lower); // prints "this is a random string"
System.out.println(upper); // prints "THIS IS A RANDOM STRING"

Non-alphabetic characters, such as digits and punctuation marks, are unaffected by these methods. Note that these
methods may also incorrectly deal with certain Unicode characters under certain conditions.

Note: These methods are locale-sensitive, and may produce unexpected results if used on strings that are intended
to be interpreted independent of the locale. Examples are programming language identifiers, protocol keys, and
HTML tags.

For instance, "TITLE".toLowerCase() in a Turkish locale returns "t?tle", where ? (\u0131) is the LATIN SMALL
LETTER DOTLESS I character. To obtain correct results for locale insensitive strings, pass Locale.ROOT as a
parameter to the corresponding case converting method (e.g. toLowerCase(Locale.ROOT) or
toUpperCase(Locale.ROOT)).

Although using Locale.ENGLISH is also correct for most cases, the language invariant way is Locale.ROOT.

A detailed list of Unicode characters that require special casing can be found on the Unicode Consortium website.

Changing case of a specific character within an ASCII string:

To change the case of a specific character of an ASCII string following algorithm can be used:

Steps:

1. Declare a string.
2. Input the string.
3. Convert the string into a character array.
4. Input the character that is to be searched.
5. Search for the character into the character array.
6. If found,check if the character is lowercase or uppercase.
If Uppercase, add 32 to the ASCII code of the character.
If Lowercase, subtract 32 from the ASCII code of the character.
7. Change the original character from the Character array.
8. Convert the character array back into the string.

Voila, the Case of the character is changed.

An example of the code for the algorithm is:

Scanner scanner = new Scanner(System.in);

System.out.println("Enter the String");
String s = scanner.next();
char[] a = s.toCharArray();
System.out.println("Enter the character you are looking for");
System.out.println(s);
String c = scanner.next();
char d = c.charAt(0);

Java® Notes for Professionals 184

for (int i = 0; i <= s.length(); i++) {
if (a[i] == d) {
if (d >= 'a' && d <= 'z') {
d -= 32;
} else if (d >= 'A' && d <= 'Z') {
d += 32;
}
a[i] = d;
break;
}
}
s = String.valueOf(a);
System.out.println(s);

Section 30.3: Finding a String Within Another String

To check whether a particular String a is being contained in a String b or not, we can use the method
String.contains() with the following syntax:

b.contains(a); // Return true if a is contained in b, false otherwise

The String.contains() method can be used to verify if a CharSequence can be found in the String. The method
looks for the String a in the String b in a case-sensitive way.

String str1 = "Hello World";

String str2 = "Hello";
String str3 = "helLO";

System.out.println(str1.contains(str2)); //prints true

System.out.println(str1.contains(str3)); //prints false

Live Demo on Ideone

To find the exact position where a String starts within another String, use String.indexOf():

String s = "this is a long sentence";

int i = s.indexOf('i'); // the first 'i' in String is at index 2
int j = s.indexOf("long"); // the index of the first occurrence of "long" in s is 10
int k = s.indexOf('z'); // k is -1 because 'z' was not found in String s
int h = s.indexOf("LoNg"); // h is -1 because "LoNg" was not found in String s

Live Demo on Ideone

The String.indexOf() method returns the first index of a char or String in another String. The method returns
-1 if it is not found.

Note: The String.indexOf() method is case sensitive.

Example of search ignoring the case:

String str1 = "Hello World";

String str2 = "wOr";
str1.indexOf(str2); // -1
str1.toLowerCase().contains(str2.toLowerCase()); // true
str1.toLowerCase().indexOf(str2.toLowerCase()); // 6

Live Demo on Ideone

Java® Notes for Professionals 185

Section 30.4: String pool and heap storage
Like many Java objects, all String instances are created on the heap, even literals. When the JVM finds a String
literal that has no equivalent reference in the heap, the JVM creates a corresponding String instance on the heap
and it also stores a reference to the newly created String instance in the String pool. Any other references to the
same String literal are replaced with the previously created String instance in the heap.

Let's look at the following example:

class Strings
{
public static void main (String[] args)
{
String a = "alpha";
String b = "alpha";
String c = new String("alpha");

//All three strings are equivalent

System.out.println(a.equals(b) && b.equals(c));

//Although only a and b reference the same heap object

System.out.println(a == b);
System.out.println(a != c);
System.out.println(b != c);
}
}

The output of the above is:

true
true
true
true

Java® Notes for Professionals 186

When we use double quotes to create a String, it first looks for String with same value in the String pool, if found it
just returns the reference else it creates a new String in the pool and then returns the reference.

However using new operator, we force String class to create a new String object in heap space. We can use intern()
method to put it into the pool or refer to other String object from string pool having same value.

The String pool itself is also created on the heap.

Version < Java SE 7

Before Java 7, String literals were stored in the runtime constant pool in the method area of PermGen, that had a
fixed size.

The String pool also resided in PermGen.

Version ≥ Java SE 7

RFC: 6962931

In JDK 7, interned strings are no longer allocated in the permanent generation of the Java heap, but are
instead allocated in the main part of the Java heap (known as the young and old generations), along with
the other objects created by the application. This change will result in more data residing in the main Java
heap, and less data in the permanent generation, and thus may require heap sizes to be adjusted. Most
applications will see only relatively small differences in heap usage due to this change, but larger
applications that load many classes or make heavy use of the String.intern() method will see more
significant differences.

Section 30.5: Splitting Strings

You can split a String on a particular delimiting character or a Regular Expression, you can use the String.split()
method that has the following signature:

public String[] split(String regex)

Note that delimiting character or regular expression gets removed from the resulting String Array.

Example using delimiting character:

String lineFromCsvFile = "Mickey;Bolton;12345;121216";

String[] dataCells = lineFromCsvFile.split(";");
// Result is dataCells = { "Mickey", "Bolton", "12345", "121216"};

Example using regular expression:

String lineFromInput = "What do you need from me?";

String[] words = lineFromInput.split("\\s+"); // one or more space chars
// Result is words = {"What", "do", "you", "need", "from", "me?"};

You can even directly split a String literal:

String[] firstNames = "Mickey, Frank, Alicia, Tom".split(", ");

// Result is firstNames = {"Mickey", "Frank", "Alicia", "Tom"};

Java® Notes for Professionals 187

Warning: Do not forget that the parameter is always treated as a regular expression.

"aaa.bbb".split("."); // This returns an empty array

In the previous example . is treated as the regular expression wildcard that matches any character, and since every
character is a delimiter, the result is an empty array.

Splitting based on a delimiter which is a regex meta-character

The following characters are considered special (aka meta-characters) in regex

< > - = ! ( ) [ ] { } \ ^ $ | ? * + .

To split a string based on one of the above delimiters, you need to either escape them using \\ or use
Pattern.quote():

Using Pattern.quote():

String s = "a|b|c";
String regex = Pattern.quote("|");
String[] arr = s.split(regex);

Escaping the special characters:

String s = "a|b|c";
String[] arr = s.split("\\|");

Split removes empty values

split(delimiter) by default removes trailing empty strings from result array. To turn this mechanism off we need
to use overloaded version of split(delimiter, limit) with limit set to negative value like

String[] split = data.split("\\|", -1);

split(regex) internally returns result of split(regex, 0).

The limit parameter controls the number of times the pattern is applied and therefore affects the length of the
resulting array.
If the limit n is greater than zero then the pattern will be applied at most n - 1 times, the array's length will be no
greater than n, and the array's last entry will contain all input beyond the last matched delimiter.
If n is negative, then the pattern will be applied as many times as possible and the array can have any length.
If n is zero then the pattern will be applied as many times as possible, the array can have any length, and trailing
empty strings will be discarded.

Splitting with a StringTokenizer

Besides the split() method Strings can also be split using a StringTokenizer.

StringTokenizer is even more restrictive than String.split(), and also a bit harder to use. It is essentially
designed for pulling out tokens delimited by a fixed set of characters (given as a String). Each character will act as a
separator. Because of this restriction, it's about twice as fast as String.split().

Default set of characters are empty spaces (\t\n\r\f). The following example will print out each word separately.

Java® Notes for Professionals 188

String str = "the lazy fox jumped over the brown fence";
StringTokenizer tokenizer = new StringTokenizer(str);
while (tokenizer.hasMoreTokens()) {
System.out.println(tokenizer.nextToken());
}

This will print out:

the
lazy
fox
jumped
over
the
brown
fence

You can use different character sets for separation.

String str = "jumped over";

// In this case character `u` and `e` will be used as delimiters
StringTokenizer tokenizer = new StringTokenizer(str, "ue");
while (tokenizer.hasMoreTokens()) {
System.out.println(tokenizer.nextToken());
}

This will print out:

j
mp
d ov
r

Section 30.6: Joining Strings with a delimiter

Version ≥ Java SE 8

An array of strings can be joined using the static method String.join():

String[] elements = { "foo", "bar", "foobar" };

String singleString = String.join(" + ", elements);

System.out.println(singleString); // Prints "foo + bar + foobar"

Similarly, there's an overloaded String.join() method for Iterables.

To have a fine-grained control over joining, you may use StringJoiner class:

StringJoiner sj = new StringJoiner(", ", "[", "]");

// The last two arguments are optional,
// they define prefix and suffix for the result string

sj.add("foo");
sj.add("bar");
sj.add("foobar");

System.out.println(sj); // Prints "[foo, bar, foobar]"

Java® Notes for Professionals 189

To join a stream of strings, you may use the joining collector:

Stream<String> stringStream = Stream.of("foo", "bar", "foobar");

String joined = stringStream.collect(Collectors.joining(", "));
System.out.println(joined); // Prints "foo, bar, foobar"

There's an option to define prefix and suffix here as well:

Stream<String> stringStream = Stream.of("foo", "bar", "foobar");

String joined = stringStream.collect(Collectors.joining(", ", "{", "}"));
System.out.println(joined); // Prints "{foo, bar, foobar}"

Section 30.7: String concatenation and StringBuilders

String concatenation can be performed using the + operator. For example:

String s1 = "a";
String s2 = "b";
String s3 = "c";
String s = s1 + s2 + s3; // abc

Normally a compiler implementation will perform the above concatenation using methods involving a
StringBuilder under the hood. When compiled, the code would look similar to the below:

StringBuilder sb = new StringBuilder("a");

String s = sb.append("b").append("c").toString();

StringBuilder has several overloaded methods for appending different types, for example, to append an int
instead of a String. For example, an implementation can convert:

String s1 = "a";
String s2 = "b";
String s = s1 + s2 + 2; // ab2

to the following:

StringBuilder sb = new StringBuilder("a");

String s = sb.append("b").append(2).toString();

The above examples illustrate a simple concatenation operation that is effectively done in a single place in the code.
The concatenation involves a single instance of the StringBuilder. In some cases, a concatenation is carried out in
a cumulative way such as in a loop:

String result = "";

for(int i = 0; i < array.length; i++) {
result += extractElement(array[i]);
}
return result;

In such cases, the compiler optimization is usually not applied, and each iteration will create a new StringBuilder
object. This can be optimized by explicitly transforming the code to use a single StringBuilder:

StringBuilder result = new StringBuilder();

for(int i = 0; i < array.length; i++) {
result.append(extractElement(array[i]));

Java® Notes for Professionals 190

}
return result.toString();

A StringBuilder will be initialized with an empty space of only 16 characters. If you know in advance that you will
be building larger strings, it can be beneficial to initialize it with sufficient size in advance, so that the internal buffer
does not need to be resized:

StringBuilder buf = new StringBuilder(30); // Default is 16 characters

buf.append("0123456789");
buf.append("0123456789"); // Would cause a reallocation of the internal buffer otherwise
String result = buf.toString(); // Produces a 20-chars copy of the string

If you are producing many strings, it is advisable to reuse StringBuilders:

StringBuilder buf = new StringBuilder(100);

for (int i = 0; i < 100; i++) {
buf.setLength(0); // Empty buffer
buf.append("This is line ").append(i).append('\n');
outputfile.write(buf.toString());
}

If (and only if) multiple threads are writing to the same buffer, use StringBuffer, which is a synchronized version of
StringBuilder. But because usually only a single thread writes to a buffer, it is usually faster to use StringBuilder
without synchronization.

Using concat() method:

String string1 = "Hello ";

String string2 = "world";
String string3 = string1.concat(string2); // "Hello world"

This returns a new string that is string1 with string2 added to it at the end. You can also use the concat() method
with string literals, as in:

"My name is ".concat("Buyya");

Section 30.8: Substrings

String s = "this is an example";
String a = s.substring(11); // a will hold the string starting at character 11 until the end
("example")
String b = s.substring(5, 10); // b will hold the string starting at character 5 and ending right
before character 10 ("is an")
String b = s.substring(5, b.length()-3); // b will hold the string starting at character 5 ending
right before b' s lenght is out of 3 ("is an exam")

Substrings may also be applied to slice and add/replace character into its original String. For instance, you faced a
Chinese date containing Chinese characters but you want to store it as a well format Date String.

String datestring = "2015?11?17?"

datestring = datestring.substring(0, 4) + "-" + datestring.substring(5,7) + "-" +
datestring.substring(8,10);
//Result will be 2015-11-17

The substring method extracts a piece of a String. When provided one parameter, the parameter is the start and
the piece extends until the end of the String. When given two parameters, the first parameter is the starting

Java® Notes for Professionals 191

character and the second parameter is the index of the character right after the end (the character at the index is
not included). An easy way to check is the subtraction of the first parameter from the second should yield the
expected length of the string.

Version < Java SE 7

In JDK <7u6 versions the substring method instantiates a String that shares the same backing char[] as the
original String and has the internal offset and count fields set to the result start and length. Such sharing may
cause memory leaks, that can be prevented by calling new String(s.substring(...)) to force creation of a copy,
after which the char[] can be garbage collected.

Version ≥ Java SE 7

From JDK 7u6 the substring method always copies the entire underlying char[] array, making the complexity
linear compared to the previous constant one but guaranteeing the absence of memory leaks at the same time.

Section 30.9: Platform independent new line separator

Since the new line separator varies from platform to platform (e.g. \n on Unix-like systems or \r\n on Windows) it is
often necessary to have a platform-independent way of accessing it. In Java it can be retrieved from a system
property:

System.getProperty("line.separator")
Version ≥ Java SE 7

Because the new line separator is so commonly needed, from Java 7 on a shortcut method returning exactly the
same result as the code above is available:

System.lineSeparator()

Note: Since it is very unlikely that the new line separator changes during the program's execution, it is a good idea
to store it in in a static final variable instead of retrieving it from the system property every time it is needed.

When using String.format, use %n rather than \n or '\r\n' to output a platform independent new line separator.

System.out.println(String.format('line 1: %s.%nline 2: %s%n', lines[0],lines[1]));

Section 30.10: Reversing Strings

There are a couple ways you can reverse a string to make it backwards.

1. StringBuilder/StringBuffer:

String code = "code";

System.out.println(code);

StringBuilder sb = new StringBuilder(code);

code = sb.reverse().toString();

System.out.println(code);

2. Char array:

String code = "code";

Java® Notes for Professionals 192

 System.out.println(code);

char[] array = code.toCharArray();

for (int index = 0, mirroredIndex = array.length - 1; index < mirroredIndex; index++,
mirroredIndex--) {
char temp = array[index];
array[index] = array[mirroredIndex];
array[mirroredIndex] = temp;
}

// print reversed
System.out.println(new String(array));

Section 30.11: Adding toString() method for custom objects

Suppose you have defined the following Person class:

public class Person {

String name;
int age;

public Person (int age, String name) {

this.age = age;
this.name = name;
}
}

If you instantiate a new Person object:

Person person = new Person(25, "John");

and later in your code you use the following statement in order to print the object:

System.out.println(person.toString());

Live Demo on Ideone

you'll get an output similar to the following:

Person@7ab89d

This is the result of the implementation of the toString() method defined in the Object class, a superclass of
Person. The documentation of Object.toString() states:

The toString method for class Object returns a string consisting of the name of the class of which the
object is an instance, the at-sign character `@', and the unsigned hexadecimal representation of the hash
code of the object. In other words, this method returns a string equal to the value of:

getClass().getName() + '@' + Integer.toHexString(hashCode())

So, for meaningful output, you'll have to override the toString() method:

@Override
public String toString() {

Java® Notes for Professionals 193

 return "My name is " + this.name + " and my age is " + this.age;
}

Now the output will be:

My name is John and my age is 25

You can also write

System.out.println(person);

Live Demo on Ideone

In fact, println() implicitly invokes the toString method on the object.

Section 30.12: Remove Whitespace from the Beginning and

End of a String
The trim() method returns a new String with the leading and trailing whitespace removed.

String s = new String(" Hello World!! ");

String t = s.trim(); // t = "Hello World!!"

If you trim a String that doesn't have any whitespace to remove, you will be returned the same String instance.

Note that the trim() method has its own notion of whitespace, which differs from the notion used by the
Character.isWhitespace() method:

All ASCII control characters with codes U+0000 to U+0020 are considered whitespace and are removed by
trim(). This includes U+0020 'SPACE', U+0009 'CHARACTER TABULATION', U+000A 'LINE FEED' and U+000D
'CARRIAGE RETURN' characters, but also the characters like U+0007 'BELL'.

Unicode whitespace like U+00A0 'NO-BREAK SPACE' or U+2003 'EM SPACE' are not recognized by trim().

Section 30.13: Case insensitive switch

Version ≥ Java SE 7

switch itself can not be parameterised to be case insensitive, but if absolutely required, can behave insensitive to
the input string by using toLowerCase() or toUpperCase:

switch (myString.toLowerCase()) {
case "case1" :
...
break;
case "case2" :
...
break;
}

Beware

Locale might affect how changing cases happen!

Care must be taken not to have any uppercase characters in the labels - those will never get executed!

Java® Notes for Professionals 194

Section 30.14: Replacing parts of Strings
Two ways to replace: by regex or by exact match.

Note: the original String object will be unchanged, the return value holds the changed String.

Exact match
Replace single character with another single character:
String replace(char oldChar, char newChar)

Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar.

String s = "popcorn";
System.out.println(s.replace('p','W'));

Result:

WoWcorn

Replace sequence of characters with another sequence of characters:

String replace(CharSequence target, CharSequence replacement)

Replaces each substring of this string that matches the literal target sequence with the specified literal
replacement sequence.

String s = "metal petal et al.";

System.out.println(s.replace("etal","etallica"));

Result:

metallica petallica et al.

Regex

Note: the grouping uses the $ character to reference the groups, like $1.

Replace all matches:

String replaceAll(String regex, String replacement)

Replaces each substring of this string that matches the given regular expression with the given
replacement.

String s = "spiral metal petal et al.";

System.out.println(s.replaceAll("(\\w*etal)","$1lica"));

Result:

spiral metallica petallica et al.

Replace first match only:

String replaceFirst(String regex, String replacement)

Java® Notes for Professionals 195

 Replaces the first substring of this string that matches the given regular expression with the given
replacement

String s = "spiral metal petal et al.";

System.out.println(s.replaceAll("(\\w*etal)","$1lica"));

Result:

spiral metallica petal et al.

Section 30.15: Getting the length of a String

In order to get the length of a String object, call the length() method on it. The length is equal to the number of
UTF-16 code units (chars) in the string.

String str = "Hello, World!";

System.out.println(str.length()); // Prints out 13

Live Demo on Ideone

A char in a String is UTF-16 value. Unicode codepoints whose values are ? 0x1000 (for example, most emojis) use
two char positions. To count the number of Unicode codepoints in a String, regardless of whether each codepoint
fits in a UTF-16 char value, you can use the codePointCount method:

int length = str.codePointCount(0, str.length());

You can also use a Stream of codepoints, as of Java 8:

int length = str.codePoints().count();

Section 30.16: Getting the nth character in a String

String str = "My String";

System.out.println(str.charAt(0)); // "M"
System.out.println(str.charAt(1)); // "y"
System.out.println(str.charAt(2)); // " "
System.out.println(str.charAt(str.length-1)); // Last character "g"

To get the nth character in a string, simply call charAt(n) on a String, where n is the index of the character you
would like to retrieve

NOTE: index n is starting at 0, so the first element is at n=0.

Section 30.17: Counting occurrences of a substring or

character in a string
countMatches method from org.apache.commons.lang3.StringUtils is typically used to count occurences of a
substring or character in a String:

import org.apache.commons.lang3.StringUtils;

String text = "One fish, two fish, red fish, blue fish";

Java® Notes for Professionals 196

// count occurrences of a substring
String stringTarget = "fish";
int stringOccurrences = StringUtils.countMatches(text, stringTarget); // 4

// count occurrences of a char

char charTarget = ',';
int charOccurrences = StringUtils.countMatches(text, charTarget); // 3

Otherwise for does the same with standard Java API's you could use Regular Expressions:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

String text = "One fish, two fish, red fish, blue fish";
System.out.println(countStringInString("fish", text)); // prints 4
System.out.println(countStringInString(",", text)); // prints 3

public static int countStringInString(String search, String text) {

Pattern pattern = Pattern.compile(search);
Matcher matcher = pattern.matcher(text);

int stringOccurrences = 0;
while (matcher.find()) {
stringOccurrences++;
}
return stringOccurrences;
}

Java® Notes for Professionals 197

Chapter 31: StringBuer
Introduction to Java StringBuffer class.

Section 31.1: String Buer class

Key Points:

used to created mutable (modifiable) string.

Mutable: Which can be changed.

is thread-safe i.e. multiple threads cannot access it simultaneously.

Methods:

public synchronized StringBuffer append(String s)

public synchronized StringBuffer insert(int offset, String s)

public synchronized StringBuffer replace(int startIndex, int endIndex, String str)

public synchronized StringBuffer delete(int startIndex, int endIndex)

public synchronized StringBuffer reverse()

public int capacity()

public void ensureCapacity(int minimumCapacity)

public char charAt(int index)

public int length()

public String substring(int beginIndex)

public String substring(int beginIndex, int endIndex)

Example Showing difference between String and String Buffer implementation:

class Test {
public static void main(String args[])
{
String str = "study";
str.concat("tonight");
System.out.println(str); // Output: study

StringBuffer strB = new StringBuffer("study");

strB.append("tonight");
System.out.println(strB); // Output: studytonight
}
}

Java® Notes for Professionals 198

Chapter 32: StringBuilder
Java StringBuilder class is used to create mutable (modifiable) string. The Java StringBuilder class is same as
StringBuffer class except that it is non-synchronized. It is available since JDK 1.5.

Section 32.1: Comparing StringBuer, StringBuilder,

Formatter and StringJoiner
The StringBuffer, StringBuilder, Formatter and StringJoiner classes are Java SE utility classes that are primarily
used for assembling strings from other information:

The StringBuffer class has been present since Java 1.0, and provides a variety of methods for building and
modifying a "buffer" containing a sequence of characters.

The StringBuilder class was added in Java 5 to address performance issues with the original StringBuffer
class. The APIs for the two clases are essentially the same. The main difference between StringBuffer and
StringBuilder is that the former is thread-safe and synchronized and the latter is not.

This example shows how StringBuilder is can be used:

int one = 1;
String color = "red";
StringBuilder sb = new StringBuilder();
sb.append("One=").append(one).append(", Color=").append(color).append('\n');
System.out.print(sb);
// Prints "One=1, Colour=red" followed by an ASCII newline.

(The StringBuffer class is used the same way: just change StringBuilder to StringBuffer in the above)

The StringBuffer and StringBuilder classes are suitable for both assembling and modifying strings; i.e they
provide methods for replacing and removing characters as well as adding them in various. The remining two
classes are specific to the task of assembling strings.

The Formatter class was added in Java 5, and is loosely modeled on the sprintf function in the C standard
library. It takes a format string with embedded format specifiers and a sequences of other arguments, and
generates a string by converting the arguments into text and substituting them in place of the format
specifiers. The details of the format specifiers say how the arguments are converted into text.

The StringJoiner class was added in Java 8. It is a special purpose formatter that succinctly formats a
sequence of strings with separators between them. It is designed with a fluent API, and can be used with Java
8 streams.

Here are some typical examples of Formatter usage:

// This does the same thing as the StringBuilder example above

int one = 1;
String color = "red";
Formatter f = new Formatter();
System.out.print(f.format("One=%d, colour=%s%n", one, color));
// Prints "One=1, Colour=red" followed by the platform's line separator

// The same thing using the `String.format` convenience method

System.out.print(String.format("One=%d, color=%s%n", one, color));

Java® Notes for Professionals 199

The StringJoiner class is not ideal for the above task, so here is an example of a formatting an array of strings.

StringJoiner sj = new StringJoiner(", ", "[", "]");

for (String s : new String[]{"A", "B", "C"}) {
sj.add(s);
}
System.out.println(sj);
// Prints "[A, B, C]"

The use-cases for the 4 classes can be summarized:

StringBuilder suitable for any string assembly OR string modification task.

StringBuffer use (only) when you require a thread-safe version of StringBuilder.
Formatter provides much richer string formatting functionality, but is not as efficient as StringBuilder. This
is because each call to Formatter.format(...) entails:
parsing the format string,
creating and populate a varargs array, and
autoboxing any primitive type arguments.
StringJoiner provides succinct and efficient formatting of a sequence of strings with separators, but is not
suitable for other formatting tasks.

Section 32.2: Repeat a String n times

Problem: Create a String containing n repetitions of a String s.

The trivial approach would be repeatedly concatenating the String

final int n = ...

final String s = ...
String result = "";

for (int i = 0; i < n; i++) {

result += s;
}

This creates n new string instances containing 1 to n repetitions of s resulting in a runtime of O(s.length() * n²) =
O(s.length() * (1+2+...+(n-1)+n)).

To avoid this StringBuilder should be used, which allows creating the String in O(s.length() * n) instead:

final int n = ...

final String s = ...

StringBuilder builder = new StringBuilder();

for (int i = 0; i < n; i++) {

builder.append(s);
}

String result = builder.toString();

Java® Notes for Professionals 200

Chapter 33: String Tokenizer
The java.util.StringTokenizer class allows you to break a string into tokens. It is simple way to break string.

The set of delimiters (the characters that separate tokens) may be specified either at creation time or on a per-
token basis.

Section 33.1: StringTokenizer Split by space

import java.util.StringTokenizer;
public class Simple{
public static void main(String args[]){
StringTokenizer st = new StringTokenizer("apple ball cat dog"," ");
while (st.hasMoreTokens()) {
System.out.println(st.nextToken());
}
}
}

Output:

apple

ball

cat

dog

Section 33.2: StringTokenizer Split by comma ','

public static void main(String args[]) {
StringTokenizer st = new StringTokenizer("apple,ball cat,dog", ",");
while (st.hasMoreTokens()) {
System.out.println(st.nextToken());
}
}

Output:

apple

ball cat

dog

Java® Notes for Professionals 201

Chapter 34: Splitting a string into fixed
length parts
Section 34.1: Break a string up into substrings all of a known
length
The trick is to use a look-behind with the regex \G, which means "end of previous match":

String[] parts = str.split("(?<=\\G.{8})");

The regex matches 8 characters after the end of the last match. Since in this case the match is zero-width, we could
more simply say "8 characters after the last match".

Conveniently, \G is initialized to start of input, so it works for the first part of the input too.

Section 34.2: Break a string up into substrings all of variable

length
Same as the known length example, but insert the length into regex:

int length = 5;
String[] parts = str.split("(?<=\\G.{" + length + "})");

Java® Notes for Professionals 202

Chapter 35: BigInteger
The BigInteger class is used for mathematical operations involving large integers with magnitudes too large for
primitive data types. For example 100-factorial is 158 digits - much larger than a long can represent. BigInteger
provides analogues to all of Java's primitive integer operators, and all relevant methods from java.lang.Math as
well as few other operations.

Section 35.1: Initialization

The java.math.BigInteger class provides operations analogues to all of Java's primitive integer operators and for
all relevant methods from java.lang.Math. As the java.math package is not automatically made available you may
have to import java.math.BigInteger before you can use the simple class name.

To convert long or int values to BigInteger use:

long longValue = Long.MAX_VALUE;

BigInteger valueFromLong = BigInteger.valueOf(longValue);

or, for integers:

int intValue = Integer.MIN_VALUE; // negative

BigInteger valueFromInt = BigInteger.valueOf(intValue);

which will widen the intValue integer to long, using sign bit extension for negative values, so that negative values
will stay negative.

To convert a numeric String to BigInteger use:

String decimalString = "-1";

BigInteger valueFromDecimalString = new BigInteger(decimalString);

Following constructor is used to translate the String representation of a BigInteger in the specified radix into a
BigInteger.

String binaryString = "10";

int binaryRadix = 2;
BigInteger valueFromBinaryString = new BigInteger(binaryString , binaryRadix);

Java also supports direct conversion of bytes to an instance of BigInteger. Currently only signed and unsigned big
endian encoding may be used:

byte[] bytes = new byte[] { (byte) 0x80 };

BigInteger valueFromBytes = new BigInteger(bytes);

This will generate a BigInteger instance with value -128 as the first bit is interpreted as the sign bit.

byte[] unsignedBytes = new byte[] { (byte) 0x80 };

int sign = 1; // positive
BigInteger valueFromUnsignedBytes = new BigInteger(sign, unsignedBytes);

This will generate a BigInteger instance with value 128 as the bytes are interpreted as unsigned number, and the
sign is explicitly set to 1, a positive number.

There are predefined constants for common values:

Java® Notes for Professionals 203

 BigInteger.ZERO — value of "0".
BigInteger.ONE — value of "1".
BigInteger.TEN — value of "10".

There's also BigInteger.TWO (value of "2"), but you can't use it in your code because it's private.

Section 35.2: BigInteger Mathematical Operations Examples

BigInteger is in an immutable object, so you need to assign the results of any mathematical operation, to a new
BigInteger instance.

Addition: 10 + 10 = 20

BigInteger value1 = new BigInteger("10");

BigInteger value2 = new BigInteger("10");

BigInteger sum = value1.add(value2);

System.out.println(sum);

output: 20

Substraction: 10 - 9 = 1

BigInteger value1 = new BigInteger("10");

BigInteger value2 = new BigInteger("9");

BigInteger sub = value1.subtract(value2);

System.out.println(sub);

output: 1

Division: 10 / 5 = 2

BigInteger value1 = new BigInteger("10");

BigInteger value2 = new BigInteger("5");

BigInteger div = value1.divide(value2);

System.out.println(div);

output: 2

Division: 17/4 = 4

BigInteger value1 = new BigInteger("17");

BigInteger value2 = new BigInteger("4");

BigInteger div = value1.divide(value2);

System.out.println(div);

output: 4

Java® Notes for Professionals 204

Multiplication: 10 * 5 = 50

BigInteger value1 = new BigInteger("10");

BigInteger value2 = new BigInteger("5");

BigInteger mul = value1.multiply(value2);

System.out.println(mul);

output: 50

Power: 10 ^ 3 = 1000

BigInteger value1 = new BigInteger("10");

BigInteger power = value1.pow(3);
System.out.println(power);

output: 1000

Remainder: 10 % 6 = 4

BigInteger value1 = new BigInteger("10");

BigInteger value2 = new BigInteger("6");

BigInteger power = value1.remainder(value2);

System.out.println(power);

output: 4

GCD: Greatest Common Divisor (GCD) for 12and 18 is 6.

BigInteger value1 = new BigInteger("12");

BigInteger value2 = new BigInteger("18");

System.out.println(value1.gcd(value2));

Output: 6

Maximum of two BigIntegers:

BigInteger value1 = new BigInteger("10");

BigInteger value2 = new BigInteger("11");

System.out.println(value1.max(value2));

Output: 11

Minimum of two BigIntegers:

Java® Notes for Professionals 205

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("11");

System.out.println(value1.min(value2));

Output: 10

Section 35.3: Comparing BigIntegers

You can compare BigIntegers same as you compare String or other objects in Java.

For example:

BigInteger one = BigInteger.valueOf(1);

BigInteger two = BigInteger.valueOf(2);

if(one.equals(two)){
System.out.println("Equal");
}
else{
System.out.println("Not Equal");
}

Output:

Not Equal

Note:

In general, do not use use the

==

operator to compare BigIntegers

==

operator: compares references; i.e. whether two values refer to the same object
equals() method: compares the content of two BigIntegers.

For example, BigIntegers should not be compared in the following way:

if (firstBigInteger == secondBigInteger) {
// Only checks for reference equality, not content equality!
}

Doing so may lead to unexpected behavior, as the

==

operator only checks for reference equality. If both BigIntegers contain the same content, but do not refer to the
same object, this will fail. Instead, compare BigIntegers using the equals methods, as explained above.

You can also compare your BigInteger to constant values like 0,1,10.

for example:

Java® Notes for Professionals 206

BigInteger reallyBig = BigInteger.valueOf(1);
if(BigInteger.ONE.equals(reallyBig)){
//code when they are equal.
}

You can also compare two BigIntegers by using compareTo() method, as following: compareTo() returns 3 values.

0: When both are equal.

1: When first is greater than second (the one in brackets).
-1: When first is less than second.

BigInteger reallyBig = BigInteger.valueOf(10);

BigInteger reallyBig1 = BigInteger.valueOf(100);

if(reallyBig.compareTo(reallyBig1) == 0){
//code when both are equal.
}
else if(reallyBig.compareTo(reallyBig1) == 1){
//code when reallyBig is greater than reallyBig1.
}
else if(reallyBig.compareTo(reallyBig1) == -1){
//code when reallyBig is less than reallyBig1.
}

Section 35.4: Binary Logic Operations on BigInteger

BigInteger supports the binary logic operations that are available to Number types as well. As with all operations
they are implemented by calling a method.

Binary Or:

BigInteger val1 = new BigInteger("10");

BigInteger val2 = new BigInteger("9");

val1.or(val2);

Output: 11 (which is equivalent to 10 | 9)

Binary And:

BigInteger val1 = new BigInteger("10");

BigInteger val2 = new BigInteger("9");

val1.and(val2);

Output: 8 (which is equivalent to 10 & 9)

Binary Xor:

BigInteger val1 = new BigInteger("10");

BigInteger val2 = new BigInteger("9");

val1.xor(val2);

Java® Notes for Professionals 207

 Output: 3 (which is equivalent to 10 ^ 9)

RightShift:

BigInteger val1 = new BigInteger("10");

val1.shiftRight(1); // the argument be an Integer

Output: 5 (equivalent to 10 >> 1)

LeftShift:

BigInteger val1 = new BigInteger("10");

val1.shiftLeft(1); // here parameter should be Integer

Output: 20 (equivalent to 10 << 1)

Binary Inversion (Not)?:

BigInteger val1 = new BigInteger("10");

val1.not();

Output: 5

NAND (And-Not):*

BigInteger val1 = new BigInteger("10");

BigInteger val2 = new BigInteger("9");

val1.andNot(val2);

Output: 7

Section 35.5: Generating random BigIntegers

The BigInteger class has a constructor dedicated to generate random BigIntegers, given an instance of
java.util.Random and an int that specifies how many bits will the BigInteger have. Its usage is quite simple -
when you call the constructor BigInteger(int, Random) like this:

BigInteger randomBigInt = new BigInteger(bitCount, sourceOfRandomness);

then you'll end up with a BigInteger whose value is between 0 (inclusive) and 2bitCount (exclusive).

This also means that new BigInteger(2147483647, sourceOfRandomness) may return all positive BigIntegers
given enough time.

Java® Notes for Professionals 208

What will the sourceOfRandomness be is up to you. For example, a new Random() is good enough in most cases:

new BigInteger(32, new Random());

If you're willing to give up speed for higher-quality random numbers, you can use a new
="https://docs.oracle.com/javase/8/docs/api/java/security/SecureRandom.html" rel="nofollow
noreferrer">SecureRandom() instead:

import java.security.SecureRandom;

// somewhere in th