Contents

About ............................................................................................................................................... 1
Chapter 1: Getting started with Java Language .......................................................................... 2
Section 1.1: Creating Your First Java Program .......................................................................................................... 2
Chapter 2: Type Conversion .......................................................................................................... 8
Section 2.1: Numeric primitive casting........................................................................................................................ 8
Section 2.2: Basic Numeric Promotion ....................................................................................................................... 8
Section 2.3: Non-numeric primitive casting ................................................................................................................ 8
Section 2.4: Object casting ......................................................................................................................................... 9
Section 2.5: Testing if an object can be cast using instanceof ................................................................................... 9
Chapter 3: Getters and Setters.....................................................................................................10
Section 3.1: Using a setter or getter to implement a constraint ................................................................................10
Section 3.2: Why Use Getters and Setters? .............................................................................................................10
Section 3.3: Adding Getters and Setters ..................................................................................................................11
Chapter 4: Reference Data Types ................................................................................................13
Section 4.1: Dereferencing .......................................................................................................................................13
Section 4.2: Instantiating a reference type ...............................................................................................................13
Chapter 5: Java Compiler - 'javac' ...............................................................................................14
Section 5.1: The 'javac' command - getting started ..................................................................................................14
Section 5.2: Compiling for a di erent version of Java ..............................................................................................16
Chapter 6: Documenting Java Code ............................................................................................18
Section 6.1: Building Javadocs From the Command Line ........................................................................................18
Section 6.2: Class Documentation ............................................................................................................................18
Section 6.3: Method Documentation.........................................................................................................................19
Section 6.4: Package Documentation.......................................................................................................................20
Section 6.5: Links......................................................................................................................................................20
Section 6.6: Code snippets inside documentation ....................................................................................................21
Section 6.7: Field Documentation .............................................................................................................................22
Section 6.8: Inline Code Documentation ..................................................................................................................22
Chapter 7: Command line Argument Processing .......................................................................24
Section 7.1: Argument processing using GWT ToolBase ........................................................................................24
Section 7.2: Processing arguments by hand ............................................................................................................24
Chapter 8: The Java Command - 'java' and 'javaw' ....................................................................27
Section 8.1: Entry point classes ................................................................................................................................27
Section 8.2: Troubleshooting the 'java' command ....................................................................................................27
Section 8.3: Running a Java application with library dependencies .........................................................................29
Section 8.4: Java Options .........................................................................................................................................30
Section 8.5: Spaces and other special characters in arguments .............................................................................31
Section 8.6: Running an executable JAR file ...........................................................................................................33
Section 8.7: Running a Java applications via a "main" class ...................................................................................33
Chapter 9: Literals .........................................................................................................................35
Section 9.1: Using underscore to improve readability ..............................................................................................35
Section 9.2: Hexadecimal, Octal and Binary literals .................................................................................................35
Section 9.3: Boolean literals .....................................................................................................................................36
Section 9.4: String literals .........................................................................................................................................36
Section 9.5: The Null literal .......................................................................................................................................37
Section 9.6: Escape sequences in literals ................................................................................................................37
 Section 9.7: Character literals ...................................................................................................................................38
Section 9.8: Decimal Integer literals .........................................................................................................................38
Section 9.9: Floating-point literals.............................................................................................................................39
Chapter 10: Primitive Data Types ................................................................................................42
Section 10.1: The char primitive ...............................................................................................................................42
Section 10.2: Primitive Types Cheatsheet ................................................................................................................42
Section 10.3: The float primitive ...............................................................................................................................43
Section 10.4: The int primitive ..................................................................................................................................44
Section 10.5: Converting Primitives ..........................................................................................................................45
Section 10.6: Memory consumption of primitives vs. boxed primitives ....................................................................45
Section 10.7: The double primitive ...........................................................................................................................46
Section 10.8: The long primitive ...............................................................................................................................47
Section 10.9: The boolean primitive .........................................................................................................................48
Section 10.10: The byte primitive .............................................................................................................................48
Section 10.11: Negative value representation ..........................................................................................................49
Section 10.12: The short primitive ............................................................................................................................50
Chapter 11: Strings .......................................................................................................................51
Section 11.1: Comparing Strings ..............................................................................................................................51
Section 11.2: Changing the case of characters within a String ................................................................................53
Section 11.3: Finding a String Within Another String ...............................................................................................55
Section 11.4: String pool and heap storage .............................................................................................................56
Section 11.5: Splitting Strings ...................................................................................................................................57
Section 11.6: Joining Strings with a delimiter ...........................................................................................................59
Section 11.7: String concatenation and StringBuilders ............................................................................................60
Section 11.8: Substrings ...........................................................................................................................................61
Section 11.9: Platform independent new line separator ...........................................................................................62
Section 11.10: Reversing Strings .............................................................................................................................62
Section 11.11: Adding toString() method for custom objects ...................................................................................63
Section 11.12: Remove Whitespace from the Beginning and End of a String .........................................................64
Section 11.13: Case insensitive switch ....................................................................................................................64
Section 11.14: Replacing parts of Strings ................................................................................................................65
Section 11.15: Getting the length of a String ............................................................................................................66
Section 11.16: Getting the nth character in a String .................................................................................................66
Section 11.17: Counting occurrences of a substring or character in a string ...........................................................66
Chapter 12: StringBu er ...............................................................................................................68
Section 12.1: String Bu er class ...............................................................................................................................68
Chapter 13: StringBuilder .............................................................................................................69
Section 13.1: Comparing StringBu er, StringBuilder, Formatter and StringJoiner ..................................................69
Section 13.2: Repeat a String n times ......................................................................................................................70
Chapter 14: String Tokenizer........................................................................................................71
Section 14.1: StringTokenizer Split by space ...........................................................................................................71
Section 14.2: StringTokenizer Split by comma ',' .....................................................................................................71
Chapter 15: Splitting a string into fixed length parts .................................................................72
Section 15.1: Break a string up into substrings all of a known length ......................................................................72
Section 15.2: Break a string up into substrings all of variable length .......................................................................72
Chapter 16: Date Class .................................................................................................................73
Section 16.1: Convert java.util.Date to java.sql.Date ...............................................................................................73
Section 16.2: A basic date output .............................................................................................................................73
Section 16.3: Java 8 LocalDate and LocalDateTime objects ...................................................................................74
 Section 16.4: Creating a Specific Date .....................................................................................................................75
Section 16.5: Converting Date to a certain String format .........................................................................................75
Section 16.6: LocalTime ...........................................................................................................................................76
Section 16.7: Convert formatted string representation of date to Date object..........................................................76
Section 16.8: Creating Date objects .........................................................................................................................77
Section 16.9: Comparing Date objects .....................................................................................................................77
Section 16.10: Converting String into Date ..............................................................................................................80
Section 16.11: Time Zones and java.util.Date ..........................................................................................................80
Chapter 17: Dates and Time (java.time.*) ....................................................................................82
Section 17.1: Calculate Di erence between 2 LocalDates ......................................................................................82
Section 17.2: Date and time .....................................................................................................................................82
Section 17.3: Operations on dates and times ...........................................................................................................82
Section 17.4: Instant .................................................................................................................................................82
Section 17.5: Usage of various classes of Date Time API .......................................................................................83
Section 17.6: Date Time Formatting .........................................................................................................................85
Section 17.7: Simple Date Manipulations .................................................................................................................85
Chapter 18: LocalTime ..................................................................................................................87
Section 18.1: Amount of time between two LocalTime.............................................................................................87
Section 18.2: Intro .....................................................................................................................................................88
Section 18.3: Time Modification ................................................................................................................................88
Section 18.4: Time Zones and their time di erence .................................................................................................88
Chapter 19: BigDecimal ................................................................................................................90
Section 19.1: Comparing BigDecimals .....................................................................................................................90
Section 19.2: Using BigDecimal instead of float .......................................................................................................90
Section 19.3: BigDecimal.valueOf() ..........................................................................................................................91
Section 19.4: Mathematical operations with BigDecimal ..........................................................................................91
Section 19.5: Initialization of BigDecimals with value zero, one or ten ....................................................................94
Section 19.6: BigDecimal objects are immutable .....................................................................................................94
Chapter 20: BigInteger ..................................................................................................................96
Section 20.1: Initialization .........................................................................................................................................96
Section 20.2: BigInteger Mathematical Operations Examples .................................................................................97
Section 20.3: Comparing BigIntegers .......................................................................................................................99
Section 20.4: Binary Logic Operations on BigInteger ............................................................................................ 100
Section 20.5: Generating random BigIntegers ...................................................................................................... 101
Chapter 21: NumberFormat ........................................................................................................ 103
Section 21.1: NumberFormat ................................................................................................................................. 103
Chapter 22: Bit Manipulation ...................................................................................................... 104
Section 22.1: Checking, setting, clearing, and toggling individual bits. Using long as bit mask ........................... 104
Section 22.2: java.util.BitSet class ......................................................................................................................... 104
Section 22.3: Checking if a number is a power of 2 .............................................................................................. 105
Section 22.4: Signed vs unsigned shift .................................................................................................................. 107
Section 22.5: Expressing the power of 2 ............................................................................................................... 107
Section 22.6: Packing / unpacking values as bit fragments .................................................................................. 108
Chapter 23: Arrays ...................................................................................................................... 109
Section 23.1: Creating and Initializing Arrays ........................................................................................................ 109
Section 23.2: Creating a List from an Array ........................................................................................................... 115
Section 23.3: Creating an Array from a Collection ................................................................................................ 117
Section 23.4: Multidimensional and Jagged Arrays ............................................................................................... 117
Section 23.5: ArrayIndexOutOfBoundsException .................................................................................................. 119
 Section 23.6: Array Covariance ............................................................................................................................. 120
Section 23.7: Arrays to Stream .............................................................................................................................. 121
Section 23.8: Iterating over arrays ......................................................................................................................... 121
Section 23.9: Arrays to a String ............................................................................................................................. 123
Section 23.10: Sorting arrays ................................................................................................................................ 124
Section 23.11: Getting the Length of an Array ...................................................................................................... 126
Section 23.12: Finding an element in an array ...................................................................................................... 126
Section 23.13: How do you change the size of an array? ..................................................................................... 127
Section 23.14: Converting arrays between primitives and boxed types ................................................................ 128
Section 23.15: Remove an element from an array ................................................................................................ 129
Section 23.16: Comparing arrays for equality ....................................................................................................... 130
Section 23.17: Copying arrays ............................................................................................................................... 130
Section 23.18: Casting Arrays ............................................................................................................................... 131
Chapter 24: Collections .............................................................................................................. 133
Section 24.1: Removing items from a List within a loop ........................................................................................ 133
Section 24.2: Constructing collections from existing data ..................................................................................... 135
Section 24.3: Declaring an ArrayList and adding objects ...................................................................................... 137
Section 24.4: Iterating over Collections ................................................................................................................. 137
Section 24.5: Immutable Empty Collections .......................................................................................................... 139
Section 24.6: Sub Collections ................................................................................................................................ 139
Section 24.7: Unmodifiable Collection ................................................................................................................... 140
Section 24.8: Pitfall: concurrent modification exceptions ...................................................................................... 141
Section 24.9: Removing matching items from Lists using Iterator ........................................................................ 141
Section 24.10: Join lists ......................................................................................................................................... 142
Section 24.11: Creating your own Iterable structure for use with Iterator or for-each loop ................................... 142
Section 24.12: Collections and Primitive Values ................................................................................................... 144
Chapter 25: Lists ......................................................................................................................... 146
Section 25.1: Sorting a generic list ........................................................................................................................ 146
Section 25.2: Convert a list of integers to a list of strings ...................................................................................... 147
Section 25.3: Classes implementing List - Pros and Cons .................................................................................... 147
Section 25.4: Finding common elements between 2 lists...................................................................................... 150
Section 25.5: In-place replacement of a List element............................................................................................ 150
Section 25.6: Making a list unmodifiable ............................................................................................................... 151
Section 25.7: Moving objects around in the list ..................................................................................................... 151
Section 25.8: Creating, Adding and Removing element from an ArrayList ........................................................... 152
Section 25.9: Creating a List .................................................................................................................................. 152
Section 25.10: Positional Access Operations ........................................................................................................ 153
Section 25.11: Iterating over elements in a list ...................................................................................................... 155
Section 25.12: Removing elements from list B that are present in the list A ......................................................... 155
Chapter 26: Sets .......................................................................................................................... 157
Section 26.1: Initialization ...................................................................................................................................... 157
Section 26.2: Basics of Set .................................................................................................................................... 157
Section 26.3: Types and Usage of Sets ................................................................................................................ 158
Section 26.4: Create a list from an existing Set ..................................................................................................... 159
Section 26.5: Eliminating duplicates using Set ...................................................................................................... 159
Section 26.6: Declaring a HashSet with values ..................................................................................................... 160
Chapter 27: List vs Set ................................................................................................................ 161
Section 27.1: List vs Set ........................................................................................................................................ 161
Chapter 28: Maps ........................................................................................................................ 162
Section 28.1: Iterating Map Entries E ciently ....................................................................................................... 162
 Section 28.2: Usage of HashMap .......................................................................................................................... 164
Section 28.3: Using Default Methods of Map from Java 8 .................................................................................... 165
Section 28.4: Iterating through the contents of a Map ........................................................................................... 167
Section 28.5: Merging, combine and composing Maps ......................................................................................... 168
Section 28.6: Add multiple items ........................................................................................................................... 169
Section 28.7: Creating and Initializing Maps ......................................................................................................... 171
Section 28.8: Check if key exists ........................................................................................................................... 172
Section 28.9: Add an element ................................................................................................................................ 172
Section 28.10: Clear the map ................................................................................................................................ 173
Section 28.11: Use custom object as key .............................................................................................................. 173
Chapter 29: LinkedHashMap ...................................................................................................... 175
Section 29.1: Java LinkedHashMap class ............................................................................................................. 175
Chapter 30: WeakHashMap ........................................................................................................ 176
Section 30.1: Concepts of WeakHashmap ............................................................................................................ 176
Chapter 31: SortedMap ............................................................................................................... 177
Section 31.1: Introduction to sorted Map ............................................................................................................... 177
Chapter 32: TreeMap and TreeSet ............................................................................................. 178
Section 32.1: TreeMap of a simple Java type ....................................................................................................... 178
Section 32.2: TreeSet of a simple Java Type ........................................................................................................ 178
Section 32.3: TreeMap/TreeSet of a custom Java type ........................................................................................ 179
Section 32.4: TreeMap and TreeSet Thread Safety .............................................................................................. 180
Chapter 33: Queues and Deques ............................................................................................... 182
Section 33.1: The usage of the PriorityQueue ....................................................................................................... 182
Section 33.2: Deque .............................................................................................................................................. 182
Section 33.3: Stacks .............................................................................................................................................. 183
Section 33.4: BlockingQueue ................................................................................................................................ 184
Section 33.5: LinkedList as a FIFO Queue ............................................................................................................ 185
Section 33.6: Queue Interface ............................................................................................................................... 186
Chapter 34: Dequeue Interface................................................................................................... 187
Section 34.1: Adding Elements to Deque .............................................................................................................. 187
Section 34.2: Removing Elements from Deque ..................................................................................................... 187
Section 34.3: Retrieving Element without Removing ............................................................................................. 187
Section 34.4: Iterating through Deque ................................................................................................................... 187
Chapter 35: Enums ...................................................................................................................... 189
Section 35.1: Declaring and using a basic enum .................................................................................................. 189
Section 35.2: Enums with constructors.................................................................................................................. 192
Section 35.3: Enums with Abstract Methods ......................................................................................................... 193
Section 35.4: Implements Interface ....................................................................................................................... 194
Section 35.5: Implement Singleton pattern with a single-element enum............................................................... 195
Section 35.6: Using methods and static blocks ..................................................................................................... 196
Section 35.7: Zero instance enum ......................................................................................................................... 196
Section 35.8: Enum as a bounded type parameter ............................................................................................... 197
Section 35.9: Documenting enums ........................................................................................................................ 197
Section 35.10: Enum constant specific body ......................................................................................................... 198
Section 35.11: Getting the values of an enum ....................................................................................................... 199
Section 35.12: Enum Polymorphism Pattern ......................................................................................................... 200
Section 35.13: Compare and Contains for Enum values ...................................................................................... 201
Section 35.14: Get enum constant by name ......................................................................................................... 201
Section 35.15: Enum with properties (fields) ......................................................................................................... 202
 Section 35.16: Convert enum to String .................................................................................................................. 203
Section 35.17: Enums with static fields ................................................................................................................. 203
Chapter 36: Enum Map................................................................................................................ 205
Section 36.1: Enum Map Book Example ............................................................................................................... 205
Chapter 37: EnumSet class ........................................................................................................ 206
Section 37.1: Enum Set Example .......................................................................................................................... 206
Chapter 38: Enum starting with number ................................................................................... 207
Section 38.1: Enum with name at beginning ......................................................................................................... 207
Chapter 39: Hashtable ................................................................................................................ 208
Section 39.1: Hashtable ......................................................................................................................................... 208
Chapter 40: Operators ................................................................................................................ 209
Section 40.1: The Increment/Decrement Operators (++/--) ................................................................................... 209
Section 40.2: The Conditional Operator (? :) ......................................................................................................... 209
Section 40.3: The Bitwise and Logical Operators (~, &, |, ^) ................................................................................. 211
Section 40.4: The String Concatenation Operator (+) ........................................................................................... 212
Section 40.5: The Arithmetic Operators (+, -, *, /, %) ............................................................................................ 214
Section 40.6: The Shift Operators (<<, >> and >>>) ............................................................................................. 216
Section 40.7: The Instanceof Operator .................................................................................................................. 217
Section 40.8: The Assignment Operators (=, +=, -=, *=, /=, %=, <<=, >>= , >>>=, &=, |= and ^=) ....................... 218
Section 40.9: The conditional-and and conditional-or Operators ( && and || ) ...................................................... 220
Section 40.10: The Relational Operators (<, <=, >, >=) ........................................................................................ 221
Section 40.11: The Equality Operators (==, !=) ..................................................................................................... 222
Section 40.12: The Lambda operator ( -> ) ........................................................................................................... 224
Chapter 41: Constructors ........................................................................................................... 225
Section 41.1: Default Constructor .......................................................................................................................... 225
Section 41.2: Call parent constructor..................................................................................................................... 226
Section 41.3: Constructor with Arguments ............................................................................................................ 227
Chapter 42: Object Class Methods and Constructor ............................................................... 229
Section 42.1: hashCode() method ......................................................................................................................... 229
Section 42.2: toString() method ............................................................................................................................. 231
Section 42.3: equals() method ............................................................................................................................... 232
Section 42.4: wait() and notify() methods .............................................................................................................. 234
Section 42.5: getClass() method ........................................................................................................................... 236
Section 42.6: clone() method ................................................................................................................................. 237
Section 42.7: Object constructor ............................................................................................................................ 238
Section 42.8: finalize() method .............................................................................................................................. 239
Chapter 43: Annotations ............................................................................................................. 241
Section 43.1: The idea behind Annotations ........................................................................................................... 241
Section 43.2: Defining annotation types ................................................................................................................ 241
Section 43.3: Runtime annotation checks via reflection ........................................................................................ 243
Section 43.4: Built-in annotations .......................................................................................................................... 243
Section 43.5: Compile time processing using annotation processor ..................................................................... 246
Section 43.6: Repeating Annotations .................................................................................................................... 250
Section 43.7: Inherited Annotations ....................................................................................................................... 251
Section 43.8: Getting Annotation values at run-time ............................................................................................. 252
Section 43.9: Annotations for 'this' and receiver parameters ................................................................................ 253
Section 43.10: Add multiple annotation values ...................................................................................................... 254
Chapter 44: Immutable Class ..................................................................................................... 255
Section 44.1: Example without mutable refs ......................................................................................................... 255
 Section 44.2: What is the advantage of immutability? ........................................................................................... 255
Section 44.3: Rules to define immutable classes .................................................................................................. 255
Section 44.4: Example with mutable refs .............................................................................................................. 256
Chapter 45: Immutable Objects .................................................................................................. 257
Section 45.1: Creating an immutable version of a type using defensive copying ................................................. 257
Section 45.2: The recipe for an immutable class ................................................................................................... 257
Section 45.3: Typical design flaws which prevent a class from being immutable ................................................. 258
Chapter 46: Visibility (controlling access to members of a class) .......................................... 262
Section 46.1: Private Visibility ................................................................................................................................ 262
Section 46.2: Public Visibility ................................................................................................................................. 262
Section 46.3: Package Visibility ............................................................................................................................. 263
Section 46.4: Protected Visibility ........................................................................................................................... 263
Section 46.5: Summary of Class Member Access Modifiers ................................................................................. 264
Section 46.6: Interface members ........................................................................................................................... 264
Chapter 47: Generics .................................................................................................................. 265
Section 47.1: Creating a Generic Class ................................................................................................................ 265
Section 47.2: Deciding between `T`, `? super T`, and `? extends T` .................................................................... 267
Section 47.3: The Diamond ................................................................................................................................... 269
Section 47.4: Declaring a Generic Method ............................................................................................................ 269
Section 47.5: Requiring multiple upper bounds ("extends A & B") ........................................................................ 270
Section 47.6: Obtain class that satisfies generic parameter at runtime ................................................................ 270
Section 47.7: Benefits of Generic class and interface ........................................................................................... 271
Section 47.8: Instantiating a generic type .............................................................................................................. 272
Section 47.9: Creating a Bounded Generic Class ................................................................................................. 272
Section 47.10: Referring to the declared generic type within its own declaration ................................................. 274
Section 47.11: Binding generic parameter to more than 1 type ............................................................................ 275
Section 47.12: Using Generics to auto-cast .......................................................................................................... 276
Section 47.13: Use of instanceof with Generics .................................................................................................... 276
Section 47.14: Di erent ways for implementing a Generic Interface (or extending a Generic Class) .................. 278
Chapter 48: Classes and Objects ............................................................................................... 280
Section 48.1: Overloading Methods....................................................................................................................... 280
Section 48.2: Explaining what is method overloading and overriding ................................................................... 281
Section 48.3: Constructors .................................................................................................................................... 283
Section 48.4: Initializing static final fields using a static initializer ......................................................................... 284
Section 48.5: Basic Object Construction and Use ................................................................................................. 285
Section 48.6: Simplest Possible Class .................................................................................................................. 287
Section 48.7: Object Member vs Static Member ................................................................................................... 287
Chapter 49: Local Inner Class .................................................................................................... 289
Section 49.1: Local Inner Class ............................................................................................................................. 289
Chapter 50: Nested and Inner Classes ...................................................................................... 290
Section 50.1: A Simple Stack Using a Nested Class ............................................................................................. 290
Section 50.2: Static vs Non Static Nested Classes ............................................................................................... 290
Section 50.3: Access Modifiers for Inner Classes ................................................................................................. 292
Section 50.4: Anonymous Inner Classes ............................................................................................................... 293
Section 50.5: Create instance of non-static inner class from outside .................................................................... 294
Section 50.6: Method Local Inner Classes ............................................................................................................ 295
Section 50.7: Accessing the outer class from a non-static inner class.................................................................. 295
Chapter 51: The java.util.Objects Class .................................................................................... 297
Section 51.1: Basic use for object null check ........................................................................................................ 297
 Section 51.2: Objects.nonNull() method reference use in stream api ................................................................... 297
Chapter 52: Default Methods ...................................................................................................... 298
Section 52.1: Basic usage of default methods ...................................................................................................... 298
Section 52.2: Accessing overridden default methods from implementing class ................................................... 298
Section 52.3: Why use Default Methods? ............................................................................................................. 299
Section 52.4: Accessing other interface methods within default method .............................................................. 299
Section 52.5: Default method multiple inheritance collision .................................................................................. 300
Section 52.6: Class, Abstract class and Interface method precedence ................................................................ 301
Chapter 53: Packages ................................................................................................................. 303
Section 53.1: Using Packages to create classes with the same name ................................................................. 303
Section 53.2: Using Package Protected Scope ..................................................................................................... 303
Chapter 54: Inheritance............................................................................................................... 305
Section 54.1: Inheritance ....................................................................................................................................... 305
Section 54.2: Abstract Classes .............................................................................................................................. 306
Section 54.3: Using 'final' to restrict inheritance and overriding ............................................................................ 308
Section 54.4: The Liskov Substitution Principle ..................................................................................................... 309
Section 54.5: Abstract class and Interface usage: "Is-a" relation vs "Has-a" capability ........................................ 310
Section 54.6: Static Inheritance ............................................................................................................................. 313
Section 54.7: Programming to an interface ........................................................................................................... 314
Section 54.8: Overriding in Inheritance.................................................................................................................. 316
Section 54.9: Variable shadowing ......................................................................................................................... 317
Section 54.10: Narrowing and Widening of object references .............................................................................. 317
Section 54.11: Inheritance and Static Methods ..................................................................................................... 318
Chapter 55: Reference Types ..................................................................................................... 320
Section 55.1: Di erent Reference Types ............................................................................................................... 320
Chapter 56: Console I/O .............................................................................................................. 322
Section 56.1: Reading user input from the console ............................................................................................... 322
Section 56.2: Aligning strings in console ............................................................................................................... 323
Section 56.3: Implementing Basic Command-Line Behavior ................................................................................ 324
Chapter 57: Streams ................................................................................................................... 326
Section 57.1: Using Streams ................................................................................................................................. 326
Section 57.2: Consuming Streams ........................................................................................................................ 328
Section 57.3: Creating a Frequency Map .............................................................................................................. 330
Section 57.4: Infinite Streams ................................................................................................................................ 330
Section 57.5: Collect Elements of a Stream into a Collection ............................................................................... 331
Section 57.6: Using Streams to Implement Mathematical Functions .................................................................... 334
Section 57.7: Flatten Streams with flatMap() ......................................................................................................... 334
Section 57.8: Parallel Stream ................................................................................................................................ 335
Section 57.9: Creating a Stream ............................................................................................................................ 336
Section 57.10: Finding Statistics about Numerical Streams .................................................................................. 337
Section 57.11: Converting an iterator to a stream ................................................................................................. 337
Section 57.12: Using IntStream to iterate over indexes ........................................................................................ 337
Section 57.13: Concatenate Streams .................................................................................................................... 338
Section 57.14: Reduction with Streams ................................................................................................................. 338
Section 57.15: Using Streams of Map.Entry to Preserve Initial Values after Mapping ......................................... 341
Section 57.16: IntStream to String ......................................................................................................................... 341
Section 57.17: Finding the First Element that Matches a Predicate ...................................................................... 341
Section 57.18: Using Streams and Method References to Write Self-Documenting Processes .......................... 342
Section 57.19: Converting a Stream of Optional to a Stream of Values ............................................................... 343
Section 57.20: Get a Slice of a Stream ................................................................................................................. 343
 Section 57.21: Create a Map based on a Stream ................................................................................................. 343
Section 57.22: Joining a stream to a single String ................................................................................................ 344
Section 57.23: Sort Using Stream ......................................................................................................................... 345
Section 57.24: Streams of Primitives ..................................................................................................................... 346
Section 57.25: Stream operations categories ........................................................................................................ 346
Section 57.26: Collect Results of a Stream into an Array...................................................................................... 347
Section 57.27: Generating random Strings using Streams ................................................................................... 347
Chapter 58: InputStreams and OutputStreams ......................................................................... 349
Section 58.1: Closing Streams .............................................................................................................................. 349
Section 58.2: Reading InputStream into a String .................................................................................................. 349
Section 58.3: Wrapping Input/Output Streams ...................................................................................................... 350
Section 58.4: DataInputStream Example .............................................................................................................. 351
Section 58.5: Writing bytes to an OutputStream ................................................................................................... 351
Section 58.6: Copying Input Stream to Output Stream ......................................................................................... 351
Chapter 59: Readers and Writers ............................................................................................... 353
Section 59.1: Bu eredReader ............................................................................................................................... 353
Section 59.2: StringWriter Example ....................................................................................................................... 354
Chapter 60: Preferences ............................................................................................................. 355
Section 60.1: Using preferences ............................................................................................................................ 355
Section 60.2: Adding event listeners ..................................................................................................................... 355
Section 60.3: Getting sub-nodes of Preferences ................................................................................................... 356
Section 60.4: Coordinating preferences access across multiple application instances ........................................ 357
Section 60.5: Exporting preferences...................................................................................................................... 357
Section 60.6: Importing preferences ...................................................................................................................... 358
Section 60.7: Removing event listeners ................................................................................................................ 359
Section 60.8: Getting preferences values .............................................................................................................. 360
Section 60.9: Setting preferences values .............................................................................................................. 360
Chapter 61: Collection Factory Methods ................................................................................... 361
Section 61.1: List<E> Factory Method Examples .................................................................................................. 361
Section 61.2: Set<E> Factory Method Examples .................................................................................................. 361
Section 61.3: Map<K, V> Factory Method Examples ............................................................................................ 361
Chapter 62: Alternative Collections ........................................................................................... 362
Section 62.1: Multimap in Guava, Apache and Eclipse Collections ...................................................................... 362
Section 62.2: Apache HashBag, Guava HashMultiset and Eclipse HashBag ...................................................... 364
Section 62.3: Compare operation with collections - Create collections ................................................................. 366
Chapter 63: Concurrent Collections .......................................................................................... 371
Section 63.1: Thread-safe Collections ................................................................................................................... 371
Section 63.2: Insertion into ConcurrentHashMap .................................................................................................. 371
Section 63.3: Concurrent Collections .................................................................................................................... 372
Chapter 64: Choosing Collections ............................................................................................. 374
Section 64.1: Java Collections Flowchart .............................................................................................................. 374
Chapter 65: super keyword ........................................................................................................ 375
Section 65.1: Super keyword use with examples .................................................................................................. 375
Chapter 66: Serialization............................................................................................................. 378
Section 66.1: Basic Serialization in Java ............................................................................................................... 378
Section 66.2: Custom Serialization ........................................................................................................................ 379
Section 66.3: Versioning and serialVersionUID ..................................................................................................... 382
Section 66.4: Serialization with Gson .................................................................................................................... 383
Section 66.5: Custom JSON Deserialization with Jackson ................................................................................... 384
Chapter 67: Optional ................................................................................................................... 387
Section 67.1: Map .................................................................................................................................................. 387
Section 67.2: Return default value if Optional is empty ......................................................................................... 388
Section 67.3: Throw an exception, if there is no value .......................................................................................... 388
Section 67.4: Lazily provide a default value using a Supplier ............................................................................... 388
Section 67.5: Filter ................................................................................................................................................. 389
Section 67.6: Using Optional containers for primitive number types ..................................................................... 389
Section 67.7: Run code only if there is a value present ........................................................................................ 390
Section 67.8: FlatMap ............................................................................................................................................ 390
Chapter 68: Object References .................................................................................................. 391
Section 68.1: Object References as method parameters ...................................................................................... 391
Chapter 69: Exceptions and exception handling ...................................................................... 394
Section 69.1: Catching an exception with try-catch ............................................................................................... 394
Section 69.2: The try-with-resources statement .................................................................................................... 395
Section 69.3: Custom Exceptions .......................................................................................................................... 398
Section 69.4: Handling InterruptedException ........................................................................................................ 400
Section 69.5: Return statements in try catch block ............................................................................................... 401
Section 69.6: Introduction ...................................................................................................................................... 402
Section 69.7: The Java Exception Hierarchy - Unchecked and Checked Exceptions .......................................... 403
Section 69.8: Creating and reading stacktraces .................................................................................................... 406
Section 69.9: Throwing an exception..................................................................................................................... 409
Section 69.10: Advanced features of Exceptions .................................................................................................. 411
Section 69.11: The try-finally and try-catch-finally statements .............................................................................. 412
Section 69.12: The 'throws' clause in a method declaration.................................................................................. 414
Chapter 70: Calendar and its Subclasses ................................................................................. 416
Section 70.1: Creating Calendar objects ............................................................................................................... 416
Section 70.2: Increasing / Decreasing calendar fields........................................................................................... 416
Section 70.3: Subtracting calendars ...................................................................................................................... 416
Section 70.4: Finding AM/PM ................................................................................................................................ 416
Chapter 71: Using the static keyword ....................................................................................... 418
Section 71.1: Reference to non-static member from static context ....................................................................... 418
Section 71.2: Using static to declare constants ..................................................................................................... 418
Chapter 72: Properties Class ..................................................................................................... 420
Section 72.1: Loading properties ........................................................................................................................... 420
Section 72.2: Saving Properties as XML ............................................................................................................... 420
Section 72.3: Property files caveat: trailing whitespace ........................................................................................ 421
Chapter 73: Lambda Expressions .............................................................................................. 424
Section 73.1: Introduction to Java lambdas ........................................................................................................... 424
Section 73.2: Using Lambda Expressions to Sort a Collection ............................................................................. 427
Section 73.3: Method References ......................................................................................................................... 428
Section 73.4: Implementing multiple interfaces ..................................................................................................... 430
Section 73.5: Lambda - Listener Example ............................................................................................................. 430
Section 73.6: Java Closures with lambda expressions ......................................................................................... 431
Section 73.7: Lambdas and memory utilization ..................................................................................................... 432
Section 73.8: Using lambda expression with your own functional interface .......................................................... 433
Section 73.9: Traditional style to Lambda style ..................................................................................................... 433
Section 73.10: `return` only returns from the lambda, not the outer method ........................................................ 434
Section 73.11: Lambdas and Execute-around Pattern .......................................................................................... 436
Section 73.12: Using lambda expressions & predicates to get a certain value(s) from a list ................................ 436
Chapter 74: Basic Control Structures ....................................................................................... 438
Section 74.1: Switch statement ............................................................................................................................. 438
Section 74.2: do while Loop .................................................................................................................................. 439
Section 74.3: For Each .......................................................................................................................................... 440
Section 74.4: Continue Statement in Java ............................................................................................................ 441
Section 74.5: If / Else If / Else Control ................................................................................................................... 441
Section 74.6: For Loops ......................................................................................................................................... 441
Section 74.7: Ternary Operator ............................................................................................................................. 442
Section 74.8: Try ... Catch ... Finally ........................................................................................................................ 443
Section 74.9: Break................................................................................................................................................ 443
Section 74.10: While Loops ................................................................................................................................... 444
Section 74.11: If / Else ........................................................................................................................................... 444
Section 74.12: Nested break / continue ................................................................................................................. 444
Chapter 75: Bu eredWriter ........................................................................................................ 446
Section 75.1: Write a line of text to File ................................................................................................................. 446
Chapter 76: New File I/O ............................................................................................................. 447
Section 76.1: Creating paths ................................................................................................................................. 447
Section 76.2: Manipulating paths ........................................................................................................................... 447
Section 76.3: Retrieving information about a path ................................................................................................. 447
Section 76.4: Retrieving information using the filesystem ..................................................................................... 448
Section 76.5: Reading files .................................................................................................................................... 449
Section 76.6: Writing files ...................................................................................................................................... 449
Chapter 77: File I/O ...................................................................................................................... 450
Section 77.1: Migrating from java.io.File to Java 7 NIO (java.nio.file.Path) .......................................................... 450
Section 77.2: Reading an image from a file ........................................................................................................... 452
Section 77.3: File Read/Write Using FileInputStream/FileOutputStream .............................................................. 452
Section 77.4: Reading all bytes to a byte[] ............................................................................................................ 453
Section 77.5: Copying a file using Channel ........................................................................................................... 454
Section 77.6: Writing a byte[] to a file .................................................................................................................... 454
Section 77.7: Stream vs Writer/Reader API .......................................................................................................... 455
Section 77.8: Reading a file with a Scanner .......................................................................................................... 456
Section 77.9: Copying a file using InputStream and OutputStream ...................................................................... 457
Section 77.10: Reading from a binary file .............................................................................................................. 457
Section 77.11: Reading a file using Channel and Bu er ....................................................................................... 457
Section 77.12: Adding Directories ......................................................................................................................... 458
Section 77.13: Blocking or redirecting standard output / error .............................................................................. 459
Section 77.14: Reading a whole file at once ......................................................................................................... 460
Section 77.15: Locking .......................................................................................................................................... 460
Section 77.16: Reading a file using Bu eredInputStream ..................................................................................... 460
Section 77.17: Iterate over a directory printing subdirectories in it ........................................................................ 461
Section 77.18: Writing a file using Channel and Bu er ......................................................................................... 461
Section 77.19: Writing a file using PrintStream ..................................................................................................... 462
Section 77.20: Iterating over a directory and filter by file extension ...................................................................... 462
Section 77.21: Accessing the contents of a ZIP file .............................................................................................. 463
Chapter 78: Scanner ................................................................................................................... 464
Section 78.1: General Pattern that does most commonly asked about tasks ....................................................... 464
Section 78.2: Using custom delimiters................................................................................................................... 466
Section 78.3: Reading system input using Scanner .............................................................................................. 466
Section 78.4: Reading file input using Scanner ..................................................................................................... 466
Section 78.5: Read the entire input as a String using Scanner ............................................................................. 467
 Section 78.6: Carefully Closing a Scanner ............................................................................................................ 467
Section 78.7: Read an int from the command line ................................................................................................. 468
Chapter 79: Interfaces ................................................................................................................. 469
Section 79.1: Implementing multiple interfaces ..................................................................................................... 469
Section 79.2: Declaring and Implementing an Interface ........................................................................................ 470
Section 79.3: Extending an interface ..................................................................................................................... 470
Section 79.4: Usefulness of interfaces .................................................................................................................. 471
Section 79.5: Default methods ............................................................................................................................... 473
Section 79.6: Modifiers in Interfaces...................................................................................................................... 475
Section 79.7: Using Interfaces with Generics ........................................................................................................ 475
Section 79.8: Strengthen bounded type parameters ............................................................................................. 478
Section 79.9: Implementing interfaces in an abstract class .................................................................................. 478
Chapter 80: Regular Expressions .............................................................................................. 480
Section 80.1: Using capture groups ....................................................................................................................... 480
Section 80.2: Using regex with custom behaviour by compiling the Pattern with flags ......................................... 481
Section 80.3: Escape Characters .......................................................................................................................... 481
Section 80.4: Not matching a given string ............................................................................................................. 482
Section 80.5: Matching with a regex literal ............................................................................................................ 482
Section 80.6: Matching a backslash ...................................................................................................................... 482
Chapter 81: Comparable and Comparator ................................................................................ 484
Section 81.1: Sorting a List using Comparable<T> or a Comparator<T> ............................................................. 484
Section 81.2: The compareTo and compare Methods .......................................................................................... 487
Section 81.3: Natural (comparable) vs explicit (comparator) sorting ..................................................................... 488
Section 81.4: Creating a Comparator using comparing method ........................................................................... 489
Section 81.5: Sorting Map entries .......................................................................................................................... 489
Chapter 82: Java Floating Point Operations ............................................................................. 491
Section 82.1: Comparing floating point values ...................................................................................................... 491
Section 82.2: OverFlow and UnderFlow ................................................................................................................ 493
Section 82.3: Formatting the floating point values ................................................................................................. 494
Section 82.4: Strict Adherence to the IEEE Specification ..................................................................................... 494
Chapter 83: Currency and Money .............................................................................................. 496
Section 83.1: Add custom currency ....................................................................................................................... 496
Chapter 84: Object Cloning ........................................................................................................ 497
Section 84.1: Cloning performing a deep copy ...................................................................................................... 497
Section 84.2: Cloning using a copy factory ........................................................................................................... 498
Section 84.3: Cloning using a copy constructor .................................................................................................... 498
Section 84.4: Cloning by implementing Clonable interface ................................................................................... 498
Section 84.5: Cloning performing a shallow copy .................................................................................................. 499
Chapter 85: Recursion ................................................................................................................ 501
Section 85.1: The basic idea of recursion ............................................................................................................. 501
Section 85.2: Deep recursion is problematic in Java ............................................................................................. 501
Section 85.3: Types of Recursion .......................................................................................................................... 503
Section 85.4: Computing the Nth Fibonacci Number ............................................................................................ 503
Section 85.5: StackOverflowError & recursion to loop .......................................................................................... 504
Section 85.6: Computing the Nth power of a number............................................................................................ 506
Section 85.7: Traversing a Tree data structure with recursion .............................................................................. 506
Section 85.8: Reverse a string using Recursion .................................................................................................... 507
Section 85.9: Computing the sum of integers from 1 to N ..................................................................................... 507
Chapter 86: Converting to and from Strings ............................................................................. 508
 Section 86.1: Converting String to other datatypes ............................................................................................... 508
Section 86.2: Conversion to / from bytes ............................................................................................................... 509
Section 86.3: Base64 Encoding / Decoding .......................................................................................................... 509
Section 86.4: Converting other datatypes to String ............................................................................................... 510
Section 86.5: Getting a `String` from an `InputStream` ......................................................................................... 511
Chapter 87: Random Number Generation ................................................................................. 512
Section 87.1: Pseudo Random Numbers .............................................................................................................. 512
Section 87.2: Pseudo Random Numbers in Specific Range ................................................................................. 512
Section 87.3: Generating cryptographically secure pseudorandom numbers ....................................................... 513
Section 87.4: Generating Random Numbers with a Specified Seed ..................................................................... 513
Section 87.5: Select random numbers without duplicates ..................................................................................... 514
Section 87.6: Generating Random number using apache-common lang3............................................................ 515
Chapter 88: Singletons ............................................................................................................... 516
Section 88.1: Enum Singleton ............................................................................................................................... 516
Section 88.2: Singleton without use of Enum (eager initialization) ........................................................................ 516
Section 88.3: Thread-safe lazy initialization using holder class | Bill Pugh Singleton implementation ................. 517
Section 88.4: Thread safe Singleton with double checked locking ....................................................................... 517
Section 88.5: Extending singleton (singleton inheritance) ..................................................................................... 518
Chapter 89: Autoboxing .............................................................................................................. 521
Section 89.1: Using int and Integer interchangeably ............................................................................................. 521
Section 89.2: Auto-unboxing may lead to NullPointerException ........................................................................... 522
Section 89.3: Using Boolean in if statement .......................................................................................................... 522
Section 89.4: Di erent Cases When Integer and int can be used interchangeably .............................................. 522
Section 89.5: Memory and Computational Overhead of Autoboxing .................................................................... 524
Chapter 90: 2D Graphics in Java ............................................................................................... 525
Section 90.1: Example 1: Draw and Fill a Rectangle Using Java ......................................................................... 525
Section 90.2: Example 2: Drawing and Filling Oval ............................................................................................... 527
Chapter 91: JAXB ........................................................................................................................ 528
Section 91.1: Reading an XML file (unmarshalling) .............................................................................................. 528
Section 91.2: Writing an XML file (marshalling an object) ..................................................................................... 528
Section 91.3: Manual field/property XML mapping configuration .......................................................................... 529
Section 91.4: Binding an XML namespace to a serializable Java class ................................................................ 530
Section 91.5: Using XmlAdapter to generate desired xml format .......................................................................... 530
Section 91.6: Using XmlAdapter to trim string ....................................................................................................... 532
Section 91.7: Automatic field/property XML mapping configuration (@XmlAccessorType).................................. 532
Section 91.8: Specifying a XmlAdapter instance to (re)use existing data ............................................................. 534
Chapter 92: Class - Java Reflection ........................................................................................... 537
Section 92.1: getClass() method of Object class ................................................................................................... 537
Chapter 93: Networking .............................................................................................................. 538
Section 93.1: Basic Client and Server Communication using a Socket ................................................................ 538
Section 93.2: Basic Client/Server Communication using UDP (Datagram) .......................................................... 540
Section 93.3: Loading TrustStore and KeyStore from InputStream ...................................................................... 541
Section 93.4: Socket example - reading a web page using a simple socket......................................................... 542
Section 93.5: Temporarily disable SSL verification (for testing purposes) ............................................................ 543
Section 93.6: Downloading a file using Channel ................................................................................................... 543
Section 93.7: Multicasting ...................................................................................................................................... 544
Chapter 94: NIO - Networking..................................................................................................... 547
Section 94.1: Using Selector to wait for events (example with OP_CONNECT) .................................................. 547
Chapter 95: HttpURLConnection ............................................................................................... 549
 Section 95.1: Get response body from a URL as a String .................................................................................... 549
Section 95.2: POST data ....................................................................................................................................... 550
Section 95.3: Delete resource ............................................................................................................................... 550
Section 95.4: Check if resource exists................................................................................................................... 551
Chapter 96: JAX-WS .................................................................................................................... 553
Section 96.1: Basic Authentication ........................................................................................................................ 553
Chapter 97: Nashorn JavaScript engine.................................................................................... 554
Section 97.1: Execute JavaScript file .................................................................................................................... 554
Section 97.2: Intercept script output ...................................................................................................................... 554
Section 97.3: Hello Nashorn .................................................................................................................................. 555
Section 97.4: Evaluate Arithmetic Strings ............................................................................................................. 555
Section 97.5: Set global variables ......................................................................................................................... 555
Section 97.6: Set and get global variables ............................................................................................................ 556
Section 97.7: Usage of Java objects in JavaScript in Nashorn ............................................................................. 556
Section 97.8: Implementing an interface from script ............................................................................................. 557
Chapter 98: Java Native Interface .............................................................................................. 558
Section 98.1: Calling C++ methods from Java ...................................................................................................... 558
Section 98.2: Calling Java methods from C++ (callback) ...................................................................................... 559
Section 98.3: Loading native libraries .................................................................................................................... 561
Chapter 99: Functional Interfaces .............................................................................................. 563
Section 99.1: List of standard Java Runtime Library functional interfaces by signature ....................................... 563
Chapter 100: Fluent Interface ..................................................................................................... 565
Section 100.1: Fluent programming style .............................................................................................................. 565
Section 100.2: Truth - Fluent Testing Framework ................................................................................................. 566
Chapter 101: Remote Method Invocation (RMI) ........................................................................ 567
Section 101.1: Callback: invoking methods on a "client" ....................................................................................... 567
Section 101.2: Simple RMI example with Client and Server implementation ....................................................... 571
Section 101.3: Client-Server: invoking methods in one JVM from another ........................................................... 573
Chapter 102: Iterator and Iterable .............................................................................................. 576
Section 102.1: Removing elements using an iterator ............................................................................................ 576
Section 102.2: Creating your own Iterable ............................................................................................................ 576
Section 102.3: Using Iterable in for loop ................................................................................................................ 577
Section 102.4: Using the raw iterator..................................................................................................................... 578
Chapter 103: Reflection API ....................................................................................................... 579
Section 103.1: Dynamic Proxies ............................................................................................................................ 579
Section 103.2: Introduction .................................................................................................................................... 580
Section 103.3: Evil Java hacks with Reflection ..................................................................................................... 581
Section 103.4: Misuse of Reflection API to change private and final variables .................................................... 583
Section 103.5: Getting and Setting fields .............................................................................................................. 584
Section 103.6: Call constructor .............................................................................................................................. 585
Section 103.7: Call constructor of nested class ..................................................................................................... 586
Section 103.8: Invoking a method ......................................................................................................................... 586
Section 103.9: Get Class given its (fully qualified) name ...................................................................................... 587
Section 103.10: Getting the Constants of an Enumeration ................................................................................... 587
Section 103.11: Call overloaded constructors using reflection .............................................................................. 588
Chapter 104: ByteBu er ............................................................................................................. 590
Section 104.1: Basic Usage - Using DirectByteBu er ........................................................................................... 590
Section 104.2: Basic Usage - Creating a ByteBu er ............................................................................................. 590
Section 104.3: Basic Usage - Write Data to the Bu er .......................................................................................... 591
Chapter 105: Applets .................................................................................................................. 592
Section 105.1: Minimal Applet ............................................................................................................................... 592
Section 105.2: Creating a GUI ............................................................................................................................... 593
Section 105.3: Open links from within the applet .................................................................................................. 593
Section 105.4: Loading images, audio and other resources ................................................................................. 594
Chapter 106: Expressions .......................................................................................................... 596
Section 106.1: Operator Precedence .................................................................................................................... 596
Section 106.2: Expression Basics ......................................................................................................................... 597
Section 106.3: Expression evaluation order .......................................................................................................... 598
Section 106.4: Constant Expressions .................................................................................................................... 599
Chapter 107: JSON in Java ......................................................................................................... 601
Section 107.1: Using Jackson Object Mapper ....................................................................................................... 601
Section 107.2: JSON To Object (Gson Library) .................................................................................................... 602
Section 107.3: JSONObject.NULL ......................................................................................................................... 602
Section 107.4: JSON Builder - chaining methods ................................................................................................. 603
Section 107.5: Object To JSON (Gson Library) .................................................................................................... 603
Section 107.6: JSON Iteration ............................................................................................................................... 603
Section 107.7: optXXX vs getXXX methods .......................................................................................................... 604
Section 107.8: Extract single element from JSON ................................................................................................ 604
Section 107.9: JsonArray to Java List (Gson Library) ........................................................................................... 604
Section 107.10: Encoding data as JSON .............................................................................................................. 605
Section 107.11: Decoding JSON data ................................................................................................................... 605
Chapter 108: XML Parsing using the JAXP APIs ...................................................................... 607
Section 108.1: Parsing a document using the StAX API ....................................................................................... 607
Section 108.2: Parsing and navigating a document using the DOM API .............................................................. 608
Chapter 109: XML XPath Evaluation .......................................................................................... 610
Section 109.1: Parsing multiple XPath Expressions in a single XML .................................................................... 610
Section 109.2: Parsing single XPath Expression multiple times in an XML .......................................................... 610
Section 109.3: Evaluating a NodeList in an XML document ................................................................................. 611
Chapter 110: XOM - XML Object Model ..................................................................................... 612
Section 110.1: Reading a XML file ........................................................................................................................ 612
Section 110.2: Writing to a XML File ..................................................................................................................... 614
Chapter 111: Polymorphism ....................................................................................................... 617
Section 111.1: Method Overriding ......................................................................................................................... 617
Section 111.2: Method Overloading ...................................................................................................................... 618
Section 111.3: Polymorphism and di erent types of overriding ............................................................................ 619
Section 111.4: Virtual functions ............................................................................................................................. 622
Section 111.5: Adding behaviour by adding classes without touching existing code ............................................ 623
Chapter 112: Encapsulation ....................................................................................................... 625
Section 112.1: Encapsulation to maintain invariants ............................................................................................. 625
Section 112.2: Encapsulation to reduce coupling .................................................................................................. 626
Chapter 113: Java Agents........................................................................................................... 627
Section 113.1: Modifying classes with agents ....................................................................................................... 627
Section 113.2: Adding an agent at runtime ........................................................................................................... 627
Section 113.3: Setting up a basic agent ................................................................................................................ 628
Chapter 114: Varargs (Variable Argument) ............................................................................... 629
Section 114.1: Working with Varargs parameters ................................................................................................. 629
Section 114.2: Specifying a varargs parameter ..................................................................................................... 629
Chapter 115: Logging (java.util.logging) ................................................................................... 630
 Section 115.1: Logging complex messages (e ciently) ......................................................................................... 630
Section 115.2: Using the default logger ................................................................................................................. 631
Section 115.3: Logging levels ................................................................................................................................ 632
Chapter 116: log4j / log4j2 .......................................................................................................... 634
Section 116.1: Properties-File to log to DB ........................................................................................................... 634
Section 116.2: How to get Log4j ............................................................................................................................ 634
Section 116.3: Setting up property file ................................................................................................................... 635
Section 116.4: Basic log4j2.xml configuration file ................................................................................................. 636
Section 116.5: How to use Log4j in Java code ...................................................................................................... 636
Section 116.6: Migrating from log4j 1.x to 2.x ....................................................................................................... 637
Section 116.7: Filter Logoutput by level (log4j 1.x) ................................................................................................ 638
Chapter 117: Oracle O cial Code Standard .............................................................................. 639
Section 117.1: Naming Conventions ..................................................................................................................... 639
Section 117.2: Class Structure .............................................................................................................................. 640
Section 117.3: Annotations .................................................................................................................................... 641
Section 117.4: Import statements .......................................................................................................................... 641
Section 117.5: Braces ............................................................................................................................................ 642
Section 117.6: Redundant Parentheses ................................................................................................................ 643
Section 117.7: Modifiers ........................................................................................................................................ 643
Section 117.8: Indentation ..................................................................................................................................... 644
Section 117.9: Literals ........................................................................................................................................... 644
Section 117.10: Package declaration .................................................................................................................... 644
Section 117.11: Lambda Expressions ................................................................................................................... 644
Section 117.12: Java Source Files ........................................................................................................................ 645
Section 117.13: Wrapping statements ................................................................................................................... 645
Section 117.14: Wrapping Method Declarations ................................................................................................... 646
Section 117.15: Wrapping Expressions ................................................................................................................. 646
Section 117.16: Whitespace .................................................................................................................................. 647
Section 117.17: Special Characters ...................................................................................................................... 647
Section 117.18: Variable Declarations................................................................................................................... 648
Chapter 118: Character encoding .............................................................................................. 649
Section 118.1: Reading text from a file encoded in UTF-8 .................................................................................... 649
Section 118.2: Writing text to a file in UTF-8 ......................................................................................................... 649
Section 118.3: Getting byte representation of a string in UTF-8 ........................................................................... 650
Chapter 119: Apache Commons Lang ....................................................................................... 651
Section 119.1: Implement equals() method ........................................................................................................... 651
Section 119.2: Implement hashCode() method ..................................................................................................... 651
Section 119.3: Implement toString() method ......................................................................................................... 652
Chapter 120: Localization and Internationalization .................................................................. 654
Section 120.1: Locale ............................................................................................................................................ 654
Section 120.2: Automatically formatted Dates using "locale" ................................................................................ 655
Section 120.3: String Comparison ......................................................................................................................... 655
Chapter 121: Parallel programming with Fork/Join framework............................................... 656
Section 121.1: Fork/Join Tasks in Java ................................................................................................................. 656
Chapter 122: Non-Access Modifiers .......................................................................................... 658
Section 122.1: final ................................................................................................................................................ 658
Section 122.2: static .............................................................................................................................................. 659
Section 122.3: abstract .......................................................................................................................................... 660
Section 122.4: strictfp ............................................................................................................................................ 661
 Section 122.5: volatile ............................................................................................................................................ 661
Section 122.6: synchronized .................................................................................................................................. 662
Section 122.7: transient ......................................................................................................................................... 663
Chapter 123: Process .................................................................................................................. 664
Section 123.1: Pitfall: Runtime.exec, Process and ProcessBuilder don't understand shell syntax ....................... 664
Section 123.2: Simple example (Java version < 1.5) ............................................................................................ 666
Chapter 124: Java Native Access .............................................................................................. 667
Section 124.1: Introduction to JNA ........................................................................................................................ 667
Chapter 125: Modules ................................................................................................................. 668
Section 125.1: Defining a basic module ................................................................................................................ 668
Chapter 126: Concurrent Programming (Threads) ................................................................... 669
Section 126.1: Callable and Future ....................................................................................................................... 669
Section 126.2: CountDownLatch ........................................................................................................................... 670
Section 126.3: Basic Multithreading ...................................................................................................................... 672
Section 126.4: Locks as Synchronisation aids ...................................................................................................... 673
Section 126.5: Semaphore .................................................................................................................................... 674
Section 126.6: Synchronization ............................................................................................................................. 675
Section 126.7: Runnable Object ............................................................................................................................ 676
Section 126.8: Creating basic deadlocked system ................................................................................................ 677
Section 126.9: Creating a java.lang.Thread instance ............................................................................................ 679
Section 126.10: Atomic operations ........................................................................................................................ 680
Section 126.11: Exclusive write / Concurrent read access.................................................................................... 681
Section 126.12: Producer-Consumer .................................................................................................................... 682
Section 126.13: Visualizing read/write barriers while using synchronized / volatile .............................................. 684
Section 126.14: Get status of all threads started by your program excluding system threads ............................. 685
Section 126.15: Using ThreadLocal....................................................................................................................... 686
Section 126.16: Multiple producer/consumer example with shared global queue ................................................ 687
Section 126.17: Add two `int` arrays using a Threadpool...................................................................................... 688
Section 126.18: Pausing Execution ....................................................................................................................... 689
Section 126.19: Thread Interruption / Stopping Threads ...................................................................................... 690
Chapter 127: Executor, ExecutorService and Thread pools.................................................... 693
Section 127.1: ThreadPoolExecutor ...................................................................................................................... 693
Section 127.2: Retrieving value from computation - Callable ................................................................................ 694
Section 127.3: submit() vs execute() exception handling di erences ................................................................... 695
Section 127.4: Handle Rejected Execution ........................................................................................................... 697
Section 127.5: Fire and Forget - Runnable Tasks ................................................................................................. 697
Section 127.6: Use cases for di erent types of concurrency constructs ............................................................... 698
Section 127.7: Wait for completion of all tasks in ExecutorService ....................................................................... 699
Section 127.8: Use cases for di erent types of ExecutorService .......................................................................... 701
Section 127.9: Scheduling tasks to run at a fixed time, after a delay or repeatedly .............................................. 703
Section 127.10: Using Thread Pools ..................................................................................................................... 704
Chapter 128: ThreadLocal .......................................................................................................... 705
Section 128.1: Basic ThreadLocal usage .............................................................................................................. 705
Section 128.2: ThreadLocal Java 8 functional initialization ................................................................................... 706
Section 128.3: Multiple threads with one shared object ........................................................................................ 707
Chapter 129: Using ThreadPoolExecutor in MultiThreaded applications. ............................. 709
Section 129.1: Performing Asynchronous Tasks Where No Return Value Is Needed Using a Runnable Class
Instance .......................................................................................................................................................... 709
Section 129.2: Performing Asynchronous Tasks Where a Return Value Is Needed Using a Callable Class
Instance .......................................................................................................................................................... 710
 Section 129.3: Defining Asynchronous Tasks Inline using Lambdas .................................................................... 713
Chapter 130: Common Java Pitfalls .......................................................................................... 715
Section 130.1: Pitfall: using == to compare primitive wrappers objects such as Integer ...................................... 715
Section 130.2: Pitfall: using == to compare strings ............................................................................................... 715
Section 130.3: Pitfall: forgetting to free resources ................................................................................................. 717
Section 130.4: Pitfall: testing a file before attempting to open it ............................................................................ 718
Section 130.5: Pitfall: thinking of variables as objects ........................................................................................... 719
Section 130.6: Pitfall: memory leaks...................................................................................................................... 722
Section 130.7: Pitfall: Not understanding that String is an immutable class ......................................................... 723
Section 130.8: Pitfall: combining assignment and side-e ects ............................................................................. 724
Chapter 131: Java Pitfalls - Exception usage ........................................................................... 725
Section 131.1: Pitfall - Catching Throwable, Exception, Error or RuntimeException ............................................ 725
Section 131.2: Pitfall - Ignoring or squashing exceptions ...................................................................................... 726
Section 131.3: Pitfall - Throwing Throwable, Exception, Error or RuntimeException ........................................... 727
Section 131.4: Pitfall - Using exceptions for normal flowcontrol ............................................................................ 728
Section 131.5: Pitfall - Directly subclassing `Throwable`....................................................................................... 729
Section 131.6: Pitfall - Catching InterruptedException .......................................................................................... 729
Section 131.7: Pitfall - Excessive or inappropriate stacktraces ............................................................................. 731
Chapter 132: Java Pitfalls - Language syntax........................................................................... 732
Section 132.1: Pitfall - Missing a ‘break’ in a 'switch' case .................................................................................... 732
Section 132.2: Pitfall - Declaring classes with the same names as standard classes .......................................... 732
Section 132.3: Pitfall - Leaving out braces: the "dangling if" and "dangling else" problems ................................. 733
Section 132.4: Pitfall - Octal literals ....................................................................................................................... 735
Section 132.5: Pitfall - Using '==' to test a boolean ............................................................................................... 735
Section 132.6: Pitfall - Ignoring method visibility ................................................................................................... 736
Section 132.7: Pitfall: Using 'assert' for argument or user input validation............................................................ 736
Section 132.8: Pitfall - Wildcard imports can make your code fragile ................................................................... 737
Section 132.9: Pitfall - Misplaced semicolons and missing braces ....................................................................... 738
Section 132.10: Pitfall - Overloading instead of overriding .................................................................................... 739
Section 132.11: Pitfall of Auto-Unboxing Null Objects into Primitives ................................................................... 740
Chapter 133: Java Pitfalls - Threads and Concurrency ........................................................... 741
Section 133.1: Pitfall - Extending 'java.lang.Thread' ............................................................................................. 741
Section 133.2: Pitfall - Too many threads makes an application slower ............................................................... 742
Section 133.3: Pitfall: incorrect use of wait() / notify() ........................................................................................... 743
Section 133.4: Pitfall: Shared variables require proper synchronization ............................................................... 743
Section 133.5: Pitfall - Thread creation is relatively expensive ............................................................................. 746
Chapter 134: Java Pitfalls - Nulls and NullPointerException................................................... 749
Section 134.1: Pitfall - "Making good" unexpected nulls ....................................................................................... 749
Section 134.2: Pitfall - Using null to represent an empty array or collection ......................................................... 750
Section 134.3: Pitfall - Not checking if an I/O stream isn't even initialized when closing it ................................... 751
Section 134.4: Pitfall - Returning null instead of throwing an exception................................................................ 751
Section 134.5: Pitfall - Unnecessary use of Primitive Wrappers can lead to NullPointerExceptions .................... 752
Section 134.6: Pitfall - Using "Yoda notation" to avoid NullPointerException ....................................................... 753
Chapter 135: Java Pitfalls - Performance Issues ...................................................................... 754
Section 135.1: Pitfall - String concatenation in a loop does not scale ................................................................... 754
Section 135.2: Pitfall - Using size() to test if a collection is empty is ine cient ................................................... 755
Section 135.3: Pitfall - Interning strings so that you can use == is a bad idea ...................................................... 755
Section 135.4: Pitfall - Using 'new' to create primitive wrapper instances is ine cient ...................................... 757
Section 135.5: Pitfall - E ciency concerns with regular expressions ..................................................................... 757
Section 135.6: Pitfall - Small reads / writes on unbu ered streams are ine cient ............................................ 760
 Section 135.7: Pitfall - Over-use of primitive wrapper types is ine cient............................................................ 762
Section 135.8: Pitfall - The overheads of creating log messages ......................................................................... 763
Section 135.9: Pitfall - Iterating a Map's keys can be ine cient .......................................................................... 764
Section 135.10: Pitfall - Calling System.gc() is ine cient ...................................................................................... 764
Section 135.11: Pitfall - Calling 'new String(String)' is ine cient ........................................................................... 765
Chapter 136: ServiceLoader ....................................................................................................... 766
Section 136.1: Simple ServiceLoader Example .................................................................................................... 766
Section 136.2: Logger Service ............................................................................................................................... 767
Chapter 137: Classloaders ......................................................................................................... 769
Section 137.1: Implementing a custom classLoader ............................................................................................. 769
Section 137.2: Loading an external .class file ....................................................................................................... 769
Section 137.3: Instantiating and using a classloader ............................................................................................ 770
Chapter 138: Creating Images Programmatically ..................................................................... 772
Section 138.1: Creating a simple image programmatically and displaying it ........................................................ 772
Section 138.2: Save an Image to disk ................................................................................................................... 773
Section 138.3: Setting individual pixel's color in Bu eredImage ........................................................................... 773
Section 138.4: Specifying image rendering quality................................................................................................ 774
Section 138.5: Creating an image with Bu eredImage class ................................................................................ 776
Section 138.6: Editing and re-using image with Bu eredImage ............................................................................ 777
Section 138.7: How to scale a Bu eredImage ...................................................................................................... 778
Chapter 139: Atomic Types ........................................................................................................ 779
Section 139.1: Creating Atomic Types .................................................................................................................. 779
Section 139.2: Motivation for Atomic Types .......................................................................................................... 779
Chapter 140: RSA Encryption .................................................................................................... 783
Section 140.1: An example using a hybrid cryptosystem consisting of OAEP and GCM ..................................... 783
Chapter 141: Secure objects ...................................................................................................... 788
Section 141.1: SealedObject (javax.crypto.SealedObject) .................................................................................... 788
Section 141.2: SignedObject (java.security.SignedObject) ................................................................................... 788
Chapter 142: Security & Cryptography ..................................................................................... 790
Section 142.1: Compute Cryptographic Hashes ................................................................................................... 790
Section 142.2: Encrypt and Decrypt Data with Public / Private Keys .................................................................... 790
Section 142.3: Generate Cryptographically Random Data ................................................................................... 791
Section 142.4: Generate Public / Private Key Pairs .............................................................................................. 791
Section 142.5: Compute and Verify Digital Signatures.......................................................................................... 792
Chapter 143: Security & Cryptography ..................................................................................... 793
Section 143.1: The JCE ......................................................................................................................................... 793
Section 143.2: Keys and Key Management .......................................................................................................... 793
Section 143.3: Common Java vulnerabilities ......................................................................................................... 793
Section 143.4: Networking Concerns .................................................................................................................... 793
Section 143.5: Randomness and You ................................................................................................................... 793
Section 143.6: Hashing and Validation .................................................................................................................. 793
Chapter 144: SecurityManager ................................................................................................... 795
Section 144.1: Sandboxing classes loaded by a ClassLoader .............................................................................. 795
Section 144.2: Enabling the SecurityManager ...................................................................................................... 796
Section 144.3: Implementing policy deny rules ..................................................................................................... 796
Chapter 145: JNDI ....................................................................................................................... 804
Section 145.1: RMI through JNDI .......................................................................................................................... 804
Chapter 146: sun.misc.Unsafe ................................................................................................... 808
Section 146.1: Instantiating sun.misc.Unsafe via reflection .................................................................................. 808
 Section 146.2: Instantiating sun.misc.Unsafe via bootclasspath ........................................................................... 808
Section 146.3: Getting Instance of Unsafe ............................................................................................................ 808
Section 146.4: Uses of Unsafe .............................................................................................................................. 809
Chapter 147: Java Memory Model .............................................................................................. 810
Section 147.1: Motivation for the Memory Model .................................................................................................. 810
Section 147.2: Happens-before relationships ........................................................................................................ 812
Section 147.3: How to avoid needing to understand the Memory Model .............................................................. 813
Section 147.4: Happens-before reasoning applied to some examples ................................................................. 814
Chapter 148: Java deployment ................................................................................................... 817
Section 148.1: Making an executable JAR from the command line ...................................................................... 817
Section 148.2: Creating an UberJAR for an application and its dependencies ..................................................... 818
Section 148.3: Creating JAR, WAR and EAR files ................................................................................................ 819
Section 148.4: Introduction to Java Web Start ...................................................................................................... 820
Chapter 149: Java plugin system implementations ................................................................. 823
Section 149.1: Using URLClassLoader ................................................................................................................. 823
Chapter 150: JavaBean ............................................................................................................... 827
Section 150.1: Basic Java Bean ............................................................................................................................ 827
Chapter 151: Java SE 7 Features ............................................................................................... 828
Section 151.1: New Java SE 7 programming language features .......................................................................... 828
Section 151.2: Binary Literals ................................................................................................................................ 828
Section 151.3: The try-with-resources statement .................................................................................................. 828
Section 151.4: Underscores in Numeric Literals ................................................................................................... 829
Section 151.5: Type Inference for Generic Instance Creation .............................................................................. 829
Section 151.6: Strings in switch Statements ......................................................................................................... 829
Chapter 152: Java SE 8 Features ............................................................................................... 831
Section 152.1: New Java SE 8 programming language features .......................................................................... 831
Chapter 153: Dynamic Method Dispatch ................................................................................... 832
Section 153.1: Dynamic Method Dispatch - Example Code .................................................................................. 832
Chapter 154: Generating Java Code .......................................................................................... 835
Section 154.1: Generate POJO From JSON ......................................................................................................... 835
Chapter 155: JShell ..................................................................................................................... 836
Section 155.1: Editting Snippets ............................................................................................................................ 836
Section 155.2: Entering and Exiting JShell ............................................................................................................ 837
Section 155.3: Expressions ................................................................................................................................... 837
Section 155.4: Methods and Classes .................................................................................................................... 838
Section 155.5: Variables ........................................................................................................................................ 838
Chapter 156: Stack-Walking API ................................................................................................ 839
Section 156.1: Print all stack frames of the current thread .................................................................................... 839
Section 156.2: Print current caller class ................................................................................................................ 840
Section 156.3: Showing reflection and other hidden frames ................................................................................. 840
Chapter 157: Sockets .................................................................................................................. 842
Section 157.1: Read from socket........................................................................................................................... 842
Chapter 158: Java Sockets ......................................................................................................... 843
Section 158.1: A simple TCP echo back server .................................................................................................... 843
Chapter 159: FTP (File Transfer Protocol)................................................................................. 846
Section 159.1: Connecting and Logging Into a FTP Server .................................................................................. 846
Chapter 160: Using Other Scripting Languages in Java .......................................................... 851
Section 160.1: Evaluating A JavaScript file in -scripting mode of nashorn ........................................................... 851
Chapter 161: C++ Comparison ................................................................................................... 854
Section 161.1: Static Class Members .................................................................................................................... 854
Section 161.2: Classes Defined within Other Constructs ...................................................................................... 854
Section 161.3: Pass-by-value & Pass-by-reference .............................................................................................. 856
Section 161.4: Inheritance vs Composition ........................................................................................................... 857
Section 161.5: Outcast Downcasting ..................................................................................................................... 857
Section 161.6: Abstract Methods & Classes ......................................................................................................... 857
Chapter 162: Audio ..................................................................................................................... 859
Section 162.1: Play a MIDI file ............................................................................................................................... 859
Section 162.2: Play an Audio file Looped .............................................................................................................. 860
Section 162.3: Basic audio output ......................................................................................................................... 860
Section 162.4: Bare metal sound ........................................................................................................................... 861
Chapter 163: Java Print Service ................................................................................................. 863
Section 163.1: Building the Doc that will be printed .............................................................................................. 863
Section 163.2: Discovering the available print services ........................................................................................ 863
Section 163.3: Defining print request attributes ..................................................................................................... 864
Section 163.4: Listening print job request status change ...................................................................................... 864
Section 163.5: Discovering the default print service.............................................................................................. 866
Section 163.6: Creating a print job from a print service......................................................................................... 866
Chapter 164: CompletableFuture ............................................................................................... 868
Section 164.1: Simple Example of CompletableFuture ......................................................................................... 868
Chapter 165: Runtime Commands ............................................................................................. 869
Section 165.1: Adding shutdown hooks ................................................................................................................ 869
Chapter 166: Unit Testing ........................................................................................................... 870
Section 166.1: What is Unit Testing?..................................................................................................................... 870
Chapter 167: Asserting ............................................................................................................... 873
Section 167.1: Checking arithmetic with assert ..................................................................................................... 873
Chapter 168: Multi-Release JAR Files ....................................................................................... 874
Section 168.1: Example of a multi-release Jar file's contents ............................................................................... 874
Section 168.2: Creating a multi-release Jar using the jar tool ............................................................................... 874
Section 168.3: URL of a loaded class inside a multi-release Jar .......................................................................... 875
Chapter 169: Just in Time (JIT) compiler .................................................................................. 877
Section 169.1: Overview ........................................................................................................................................ 877
Chapter 170: Bytecode Modification ......................................................................................... 879
Section 170.1: What is Bytecode? ......................................................................................................................... 879
Section 170.2: How to edit jar files with ASM ........................................................................................................ 880
Section 170.3: How to load a ClassNode as a Class ............................................................................................ 882
Section 170.4: How to rename classes in a jar file ................................................................................................ 883
Section 170.5: Javassist Basic .............................................................................................................................. 883
Chapter 171: Disassembling and Decompiling......................................................................... 885
Section 171.1: Viewing bytecode with javap ......................................................................................................... 885
Chapter 172: JMX ........................................................................................................................ 892
Section 172.1: Simple example with Platform MBean Server ............................................................................... 892
Chapter 173: Java Virtual Machine (JVM).................................................................................. 896
Section 173.1: These are the basics ..................................................................................................................... 896
Chapter 174: XJC......................................................................................................................... 897
Section 174.1: Generating Java code from simple XSD file .................................................................................. 897
Chapter 175: JVM Flags .............................................................................................................. 900
 Section 175.1: -XXaggressive ............................................................................................................................... 900
Section 175.2: -XXallocClearChunks..................................................................................................................... 900
Section 175.3: -XXallocClearChunkSize ............................................................................................................... 900
Section 175.4: -XXcallProfiling .............................................................................................................................. 900
Section 175.5: -XXdisableFatSpin ......................................................................................................................... 901
Section 175.6: -XXdisableGCHeuristics ................................................................................................................ 901
Section 175.7: -XXdumpSize ................................................................................................................................. 901
Section 175.8: -XXexitOnOutOfMemory ................................................................................................................ 902
Chapter 176: JVM Tool Interface ................................................................................................ 903
Section 176.1: Iterate over objects reachable from object (Heap 1.0) .................................................................. 903
Section 176.2: Get JVMTI environment ................................................................................................................. 905
Section 176.3: Example of initialization inside of Agent_OnLoad method ............................................................ 905
Chapter 177: Java Memory Management .................................................................................. 907
Section 177.1: Setting the Heap, PermGen and Stack sizes ................................................................................ 907
Section 177.2: Garbage collection ......................................................................................................................... 908
Section 177.3: Memory leaks in Java .................................................................................................................... 910
Section 177.4: Finalization ..................................................................................................................................... 911
Section 177.5: Manually triggering GC .................................................................................................................. 912
Chapter 178: Java Performance Tuning .................................................................................... 913
Section 178.1: An evidence-based approach to Java performance tuning ........................................................... 913
Section 178.2: Reducing amount of Strings .......................................................................................................... 914
Section 178.3: General approach .......................................................................................................................... 914
Chapter 179: Benchmarks .......................................................................................................... 916
Section 179.1: Simple JMH example ..................................................................................................................... 916
Chapter 180: FileUpload to AWS ................................................................................................ 919
Section 180.1: Upload file to s3 bucket ................................................................................................................. 919
Chapter 181: AppDynamics and TIBCO BusinessWorks Instrumentation for Easy
Integration .................................................................................................................................... 921
Section 181.1: Example of Instrumentation of all BW Applications in a Single Step for Appdynamics ................ 921
Appendix A: Installing Java (Standard Edition) ........................................................................ 922
Section A.1: Setting %PATH% and %JAVA_HOME% after installing on Windows .............................................. 922
Section A.2: Installing a Java JDK on Linux .......................................................................................................... 923
Section A.3: Installing a Java JDK on macOS....................................................................................................... 925
Section A.4: Installing a Java JDK or JRE on Windows ........................................................................................ 926
Section A.5: Configuring and switching Java versions on Linux using alternatives .............................................. 927
Section A.6: What do I need for Java Development .............................................................................................. 928
Section A.7: Selecting an appropriate Java SE release ........................................................................................ 928
Section A.8: Java release and version naming ..................................................................................................... 929
Section A.9: Installing Oracle Java on Linux with latest tar file ............................................................................. 929
Section A.10: Post-installation checking and configuration on Linux .................................................................... 930
Appendix B: Java Editions, Versions, Releases and Distributions ........................................ 933
Section B.1: Di erences between Java SE JRE or Java SE JDK distributions .................................................... 933
Section B.2: Java SE Versions .............................................................................................................................. 934
Section B.3: Di erences between Java EE, Java SE, Java ME and JavaFX ....................................................... 935
Appendix C: The Classpath ........................................................................................................ 937
Section C.1: Di erent ways to specify the classpath ............................................................................................. 937
Section C.2: Adding all JARs in a directory to the classpath ................................................................................. 937
Section C.3: Load a resource from the classpath .................................................................................................. 938
Section C.4: Classpath path syntax ....................................................................................................................... 938
 Section C.5: Dynamic Classpath ........................................................................................................................... 939
Section C.6: Mapping classnames to pathnames ................................................................................................. 939
Section C.7: The bootstrap classpath .................................................................................................................... 939
Section C.8: What the classpath means: how searches work ............................................................................... 940
Appendix D: Resources (on classpath) ..................................................................................... 941
Section D.1: Loading default configuration ............................................................................................................ 941
Section D.2: Loading an image from a resource ................................................................................................... 941
Section D.3: Finding and reading resources using a classloader ......................................................................... 941
Section D.4: Loading same-name resource from multiple JARs ........................................................................... 943
1
Chapter 1: Getting started with Java
Language
Java SE Version Code Name End-of-life (free1) Release Date
Java SE 10 (Early Access) None future 2018-03-20
Java SE 9 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.

INFOBYTE CAREER INSTITUTE 2

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.

$ 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)

INFOBYTE CAREER INSTITUTE 3

 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 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.

INFOBYTE CAREER INSTITUTE 4

 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
out
standard output functionality.
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 marks
World!" 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).

INFOBYTE CAREER INSTITUTE 5

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;
}

// 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

INFOBYTE CAREER INSTITUTE 6

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.

INFOBYTE CAREER INSTITUTE 7

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

INFOBYTE CAREER INSTITUTE 8

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.
}

INFOBYTE CAREER INSTITUTE 9

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 {

INFOBYTE CAREER INSTITUTE 10

 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:

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.
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 {

INFOBYTE CAREER INSTITUTE 11

 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.

INFOBYTE CAREER INSTITUTE 12

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.

INFOBYTE CAREER INSTITUTE 13

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:

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.
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.
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
|

INFOBYTE CAREER INSTITUTE 14

 ----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:

The directory structure must match the package name structure.

When you run the class, the full class name must be supplied; i.e. "com.example.HelloWorld" not
"HelloWorld".
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

INFOBYTE CAREER INSTITUTE 15

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

INFOBYTE CAREER INSTITUTE 16

version you need to support, and use that JDK's compiler in your builds.

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.

INFOBYTE CAREER INSTITUTE 17

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

INFOBYTE CAREER INSTITUTE 18

 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;

INFOBYTE CAREER INSTITUTE 19

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}
*/

INFOBYTE CAREER INSTITUTE 20

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

INFOBYTE CAREER INSTITUTE 21

 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) {

/*

INFOBYTE CAREER INSTITUTE 22

 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

INFOBYTE CAREER INSTITUTE 23

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

INFOBYTE CAREER INSTITUTE 24

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":

INFOBYTE CAREER INSTITUTE 25

 feelMe = true;
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.

INFOBYTE CAREER INSTITUTE 26

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:

INFOBYTE CAREER INSTITUTE 27

 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.

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

INFOBYTE CAREER INSTITUTE 28

 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)

INFOBYTE CAREER INSTITUTE 29

$ 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.

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.)

INFOBYTE CAREER INSTITUTE 30

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.

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 {

INFOBYTE CAREER INSTITUTE 31

 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.

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.

INFOBYTE CAREER INSTITUTE 32

 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 -cp . HelloWorld

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

INFOBYTE CAREER INSTITUTE 33

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.)

INFOBYTE CAREER INSTITUTE 34

Chapter 9: 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 9.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 9.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-15.

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

INFOBYTE CAREER INSTITUTE 35

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 9.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 9.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

INFOBYTE CAREER INSTITUTE 36

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 9.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 9.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.

INFOBYTE CAREER INSTITUTE 37

Reference:

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 9.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 9.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')

INFOBYTE CAREER INSTITUTE 38

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

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

// 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 9.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.)

INFOBYTE CAREER INSTITUTE 39

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:

Every hexadecimal floating point literal starts with a zero ( 0) and then an x or X.
The digits of the number (but not the exponent part!) also include the hexadecimal digits a through f and their
uppercase equivalents.
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:

INFOBYTE CAREER INSTITUTE 40

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.

INFOBYTE CAREER INSTITUTE 41

Chapter 10: 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 10.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 10.2: Primitive Types Cheatsheet

Table showing size and values range of all primitive types:

default
data type numeric representation range of values
value

INFOBYTE CAREER INSTITUTE 42

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:

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.
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.
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
A char conventionally represents a Unicode / UTF-16 code unit.
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 10.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; float // without 'f' after digits = double

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

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

= 89.3f; float negativeFloat = -89.3f; float it can be positive,
integerFloat = 43.0f; float underZeroFloat or negative
= 0.0549f; it can be a whole number (not an int)
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

INFOBYTE CAREER INSTITUTE 43

// multiplication
float result = 26.3f * 1.7f; // result: 44.71

// 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 10.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

INFOBYTE CAREER INSTITUTE 44

 2147483648) % 4294967296) - 2147483648

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 10.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 10.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

INFOBYTE CAREER INSTITUTE 45

char Char 2 bytes / 16 bytes
int Integer 4 bytes / 16 bytes
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 10.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

INFOBYTE CAREER INSTITUTE 46

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
== 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 10.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;

INFOBYTE CAREER INSTITUTE 47

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 10.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 10.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

INFOBYTE CAREER INSTITUTE 48

byte defaultByte; // defaultByte == 0

Section 10.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)

INFOBYTE CAREER INSTITUTE 49

Section 10.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

INFOBYTE CAREER INSTITUTE 50

Chapter 11: 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 11.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 == or !=

INFOBYTE CAREER INSTITUTE 51

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.

INFOBYTE CAREER INSTITUTE 52

Comparing with interned Strings

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 11.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

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";

INFOBYTE CAREER INSTITUTE 53

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:

Declare a string.
Input the string.
Convert the string into a character array.
Input the character that is to be searched.
Search for the character into the character array.
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.
Change the original character from the Character array.
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);

for (int i = 0; i <= s.length(); i++) {

if (a[i] == d) {
if (d >= 'a' && d <= 'z') {
d -= 32;

INFOBYTE CAREER INSTITUTE 54

 } else if (d >= 'A' && d <= 'Z') { d += 32;

}
a[i] = d;
break;
}
}
s = String.valueOf(a);
System.out.println(s);

Section 11.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

INFOBYTE CAREER INSTITUTE 55

Section 11.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

INFOBYTE CAREER INSTITUTE 56

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 11.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"};

INFOBYTE CAREER INSTITUTE 57

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.

INFOBYTE CAREER INSTITUTE 58

 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
ov
r

Section 11.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]"

INFOBYTE CAREER INSTITUTE 59

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 11.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]));

INFOBYTE CAREER INSTITUTE 60

 }
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 11.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

INFOBYTE CAREER INSTITUTE 61

the piece extends until the end of the String. When given two parameters, the first parameter is the starting 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 11.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 11.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:

INFOBYTE CAREER INSTITUTE 62

 String code = "code";
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 11.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

INFOBYTE CAREER INSTITUTE 63

public String toString() {
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 11.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 11.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!

INFOBYTE CAREER INSTITUTE 64

 Care must be taken not to have any uppercase characters in the labels - those will never get executed!

Section 11.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:

INFOBYTE CAREER INSTITUTE 65

 spiral metallica petallica et al.
Replace first match only:
String replaceFirst(String regex, String replacement)

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 11.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 11.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 11.17: Counting occurrences of a substring or

INFOBYTE CAREER INSTITUTE 66

character in a string
countMatches method from org.apache.commons.lang3.StringUtils is typically used to count occurrences of a
substring or character in a String:

import org.apache.commons.lang3.StringUtils;

String text = "One fish, two fish, red fish, blue fish";

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;
}

INFOBYTE CAREER INSTITUTE 67

Chapter 12: StringBu er
Introduction to Java StringBuffer class.

Section 12.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
}
}

INFOBYTE CAREER INSTITUTE 68

Chapter 13: 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 13.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));

INFOBYTE CAREER INSTITUTE 69

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 13.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();

INFOBYTE CAREER INSTITUTE 70

Chapter 14: 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 14.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 14.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

INFOBYTE CAREER INSTITUTE 71

Chapter 15: Splitting a string into fixed
length parts
Section 15.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 15.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 + "})");

INFOBYTE CAREER INSTITUTE 72

Chapter 16: 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"
long date
(January 1, 1970, 00:00:00 GMT)

Section 16.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 16.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

INFOBYTE CAREER INSTITUTE 73

// 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 16.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();

INFOBYTE CAREER INSTITUTE 74

 // 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 16.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 16.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();

INFOBYTE CAREER INSTITUTE 75

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 16.6: LocalTime

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

LocalTime time = LocalTime.now();

time = LocalTime.MIDNIGHT;
time = LocalTime.NOON;
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 16.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;

INFOBYTE CAREER INSTITUTE 76

 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 16.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 16.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,

INFOBYTE CAREER INSTITUTE 77

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)));

INFOBYTE CAREER INSTITUTE 78

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 :

INFOBYTE CAREER INSTITUTE 79

 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 16.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 16.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();

INFOBYTE CAREER INSTITUTE 80

//print default time zone
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

INFOBYTE CAREER INSTITUTE 81

Chapter 17: Dates and Time (java.time.*)
Section 17.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 17.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 17.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 17.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);

INFOBYTE CAREER INSTITUTE 82

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

Section 17.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);
}

/**

INFOBYTE CAREER INSTITUTE 83

 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);
}

/**

INFOBYTE CAREER INSTITUTE 84

 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 17.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 17.7: Simple Date Manipulations

Get the current date.

LocalDate.now()

Get yesterday's date.

INFOBYTE CAREER INSTITUTE 85

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.

INFOBYTE CAREER INSTITUTE 86

Chapter 18: 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 18.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);
}
}

INFOBYTE CAREER INSTITUTE 87

Section 18.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 18.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 18.4: Time Zones and their time di erence

import java.time.LocalTime;

INFOBYTE CAREER INSTITUTE 88

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");

}
}

INFOBYTE CAREER INSTITUTE 89

Chapter 19: BigDecimal
The BigDecimal class provides operations for arithmetic (add, subtract, multiply, divide), scale manipulation, rounding,
comparison, hashing, and format conversion. The BigDecimal represents immutable, arbitrary-precision signed decimal
numbers. This class shall be used in a necessity of high-precision calculation.

Section 19.1: Comparing BigDecimals

The method compareTo should be used to compare BigDecimals:

BigDecimal a = new BigDecimal(5);

a.compareTo(new BigDecimal(0)); a is greater, returns 1
a.compareTo(new BigDecimal(5)); a is equal, returns 0
a.compareTo(new BigDecimal(10)); a is less, returns -1

Commonly you should not use the equals method since it considers two BigDecimals equal only if they are equal in value
and also scale:

BigDecimal a = new BigDecimal(5);

a.equals(new BigDecimal(5)); // value and scale are equal, returns true
a.equals(new BigDecimal(5.00)); // value is equal but scale is not, returns false

Section 19.2: Using BigDecimal instead of float

Due to way that the float type is represented in computer memory, results of operations using this type can be
inaccurate - some values are stored as approximations. Good examples of this are monetary calculations. If high
precision is necessary, other types should be used. e.g. Java 7 provides BigDecimal.

import java.math.BigDecimal;

public class FloatTest {

public static void main(String[] args) {

float accountBalance = 10000.00f;
System.out.println("Operations using float:");
System.out.println("1000 operations for 1.99");
for(int i = 0; i<1000; i++){
accountBalance -= 1.99f;
}
System.out.println(String.format("Account balance after float operations: %f", accountBalance));

BigDecimal accountBalanceTwo = new BigDecimal("10000.00");

System.out.println("Operations using BigDecimal:");
System.out.println("1000 operations for 1.99");
BigDecimal operation = new BigDecimal("1.99");
for(int i = 0; i<1000; i++){
accountBalanceTwo = accountBalanceTwo.subtract(operation);
}
System.out.println(String.format("Account balance after BigDecimal operations: %f",
accountBalanceTwo));
}

Output of this program is:

INFOBYTE CAREER INSTITUTE 90

 Operations using float:
1000 operations for 1.99
Account balance after float operations: 8009,765625
Operations using BigDecimal:
1000 operations for 1.99
Account balance after BigDecimal operations: 8010,000000

For a starting balance of 10000.00, after 1000 operations for 1.99, we expect the balance to be 8010.00. Using the float
type gives us an answer around 8009.77, which is unacceptably imprecise in the case of monetary calculations. Using
BigDecimal gives us the proper result.

Section 19.3: BigDecimal.valueOf()

The BigDecimal class contains an internal cache of frequently used numbers e.g. 0 to 10. The BigDecimal.valueOf()
methods are provided in preference to constructors with similar type parameters i.e. in the below example a is preferred
to b.

BigDecimal a = BigDecimal.valueOf(10L); //Returns cached Object reference BigDecimal b = new

BigDecimal(10L); //Does not return cached Object reference

BigDecimal a = BigDecimal.valueOf(20L); //Does not return cached Object reference BigDecimal b = new
BigDecimal(20L); //Does not return cached Object reference

BigDecimal a = BigDecimal.valueOf(15.15); //Preferred way to convert a double (or float) into a BigDecimal, as the value returned is
equal to that resulting from constructing a BigDecimal from the result of using Double.toString(double)

BigDecimal b = new BigDecimal(15.15); //Return unpredictable result

Section 19.4: Mathematical operations with BigDecimal

This example shows how to perform basic mathematical operations using BigDecimals.

1.Addition
BigDecimal a = new BigDecimal("5");
BigDecimal b = new BigDecimal("7");

//Equivalent to result = a + b
BigDecimal result = a.add(b);
System.out.println(result);

Result : 12

2.Subtraction
BigDecimal a = new BigDecimal("5");
BigDecimal b = new BigDecimal("7");

//Equivalent to result = a - b
BigDecimal result = a.subtract(b);
System.out.println(result);

Result : -2

INFOBYTE CAREER INSTITUTE 91

3.Multiplication

When multiplying two BigDecimals the result is going to have scale equal to the sum of the scales of operands.

BigDecimal a = new BigDecimal("5.11");

BigDecimal b = new BigDecimal("7.221");

//Equivalent to result = a * b
BigDecimal result = a.multiply(b);
System.out.println(result);

Result : 36.89931

To change the scale of the result use the overloaded multiply method which allows passing MathContext - an object
describing the rules for operators, in particular the precision and rounding mode of the result. For more information about
available rounding modes please refer to the Oracle Documentation.

BigDecimal a = new BigDecimal("5.11");

BigDecimal b = new BigDecimal("7.221");

MathContext returnRules = new MathContext(4, RoundingMode.HALF_DOWN);

//Equivalent to result = a * b
BigDecimal result = a.multiply(b, returnRules);
System.out.println(result);

Result : 36.90

4.Division

Division is a bit more complicated than the other arithmetic operations, for instance consider the below example:

BigDecimal a = new BigDecimal("5");

BigDecimal b = new BigDecimal("7");

BigDecimal result = a.divide(b);

System.out.println(result);

We would expect this to give something similar to : 0.7142857142857143, but we would get:

Result: java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable

decimal result.

This would work perfectly well when the result would be a terminating decimal say if I wanted to divide 5 by 2, but for
those numbers which upon dividing would give a non terminating result we would get an ArithmeticException. In the real
world scenario, one cannot predict the values that would be encountered during the division, so we need to specify the
Scale and the Rounding Mode for BigDecimal division. For more information on the Scale and Rounding Mode, refer the
Oracle Documentation.

For example, I could do:

BigDecimal a = new BigDecimal("5");

INFOBYTE CAREER INSTITUTE 92

BigDecimal b = new BigDecimal("7");

//Equivalent to result = a / b (Upto 10 Decimal places and Round HALF_UP) BigDecimal result =
a.divide(b,10,RoundingMode.HALF_UP); System.out.println(result);

Result : 0.7142857143

5.Remainder or Modulus
BigDecimal a = new BigDecimal("5");
BigDecimal b = new BigDecimal("7");

//Equivalent to result = a % b
BigDecimal result = a.remainder(b);
System.out.println(result);

Result : 5

6.Power
BigDecimal a = new BigDecimal("5");

//Equivalent to result = a^10

BigDecimal result = a.pow(10);
System.out.println(result);

Result : 9765625

7.Max
BigDecimal a = new BigDecimal("5");
BigDecimal b = new BigDecimal("7");

//Equivalent to result = MAX(a,b)

BigDecimal result = a.max(b);
System.out.println(result);

Result : 7

8.Min
BigDecimal a = new BigDecimal("5");
BigDecimal b = new BigDecimal("7");

//Equivalent to result = MIN(a,b)

BigDecimal result = a.min(b);
System.out.println(result);

Result : 5

9.Move Point To Left

INFOBYTE CAREER INSTITUTE 93

BigDecimal a = new BigDecimal("5234.49843776");

//Moves the decimal point to 2 places left of current position BigDecimal result =
a.movePointLeft(2); System.out.println(result);

Result : 52.3449843776

10.Move Point To Right

BigDecimal a = new BigDecimal("5234.49843776");

//Moves the decimal point to 3 places right of current position BigDecimal result =
a.movePointRight(3); System.out.println(result);

Result : 5234498.43776

There are many more options and combination of parameters for the above mentioned examples (For instance, there
are 6 variations of the divide method), this set is a non-exhaustive list and covers a few basic examples.

Section 19.5: Initialization of BigDecimals with value zero,

one or ten
BigDecimal provides static properties for the numbers zero, one and ten. It's good practise to use these instead of using
the actual numbers:

BigDecimal.ZERO
BigDecimal.ONE
BigDecimal.TEN

By using the static properties, you avoid an unnecessary instantiation, also you've got a literal in your code instead of a
'magic number'.

//Bad example:
BigDecimal bad0 = new BigDecimal(0);
BigDecimal bad1 = new BigDecimal(1);
BigDecimal bad10 = new BigDecimal(10);

//Good Example:
BigDecimal good0 = BigDecimal.ZERO;
BigDecimal good1 = BigDecimal.ONE;
BigDecimal good10 = BigDecimal.TEN;

Section 19.6: BigDecimal objects are immutable

If you want to calculate with BigDecimal you have to use the returned value because BigDecimal objects are
immutable:

BigDecimal a = new BigDecimal("42.23");

BigDecimal b = new BigDecimal("10.001");

a.add(b); // a will still be 42.23

INFOBYTE CAREER INSTITUTE 94

BigDecimal c = a.add(b); // c will be 52.231

INFOBYTE CAREER INSTITUTE 95

Chapter 20: 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 20.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:

INFOBYTE CAREER INSTITUTE 96

 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 20.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

Subtraction: 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

INFOBYTE CAREER INSTITUTE 97

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:

INFOBYTE CAREER INSTITUTE 98

BigInteger value1 = new BigInteger("10");
BigInteger value2 = new BigInteger("11");

System.out.println(value1.min(value2));

Output: 10

Section 20.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:

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.

INFOBYTE CAREER INSTITUTE 99

 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 20.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);

Output: 3 (which is equivalent to 10 ^ 9)

RightShift:

BigInteger val1 = new BigInteger("10");

INFOBYTE CAREER INSTITUTE 100

 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 20.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.

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:

INFOBYTE CAREER INSTITUTE 101

import java.security.SecureRandom;

// somewhere in the code...

new BigInteger(32, new SecureRandom());

You can even implement an algorithm on-the-fly with an anonymous class! Note that rolling out your own RNG
algorithm will end you up with low quality randomness, so always be sure to use an algorithm that is proven to be
decent unless you want the resulting BigInteger(s) to be predictable.

new BigInteger(32, new Random() {

int seed = 0;

@Override
protected int next(int bits) {
seed = ((22695477 * seed) + 1) & 2147483647; // Values shamelessly stolen from

="https://en.wikipedia.org/wiki/Linear_congruential_generator#Parameters_in_common_use" rel="nofollow
noreferrer">Wikipedia return seed; } });

INFOBYTE CAREER INSTITUTE 102

Chapter 21: NumberFormat
Section 21.1: NumberFormat
Different countries have different number formats and considering this we can have different formats using Locale of
java. Using locale can help in formatting

Locale locale = new Locale("en", "IN");

NumberFormat numberFormat = NumberFormat.getInstance(locale);

using above format you can perform various tasks

Format Number

numberFormat.format(10000000.99);

Format Currency

NumberFormat currencyFormat = NumberFormat.getCurrencyInstance(locale);

currencyFormat.format(10340.999);

Format Percentage

NumberFormat percentageFormat = NumberFormat.getPercentInstance(locale);

percentageFormat.format(10929.999);

Control Number of Digits

numberFormat.setMinimumIntegerDigits(int digits)
numberFormat.setMaximumIntegerDigits(int digits)
numberFormat.setMinimumFractionDigits(int digits)
numberFormat.setMaximumFractionDigits(int digits)

INFOBYTE CAREER INSTITUTE 103

Chapter 22: Bit Manipulation
Section 22.1: Checking, setting, clearing, and
toggling individual bits. Using long as bit mask
Assuming we want to modify bit n of an integer primitive, i (byte, short, char, int, or long):

(i & 1 << n) != 0 // checks bit 'n'

i |= 1 << n; // sets bit 'n' to 1
i &= ~(1 << n); // sets bit 'n' to 0
i ^= 1 << n; // toggles the value of bit 'n'

Using long/int/short/byte as a bit mask:

public class BitMaskExample {

private static final long FIRST_BIT = 1L << 0;
private static final long SECOND_BIT = 1L << 1;
private static final long THIRD_BIT = 1L << 2;
private static final long FOURTH_BIT = 1L << 3;
private static final long FIFTH_BIT = 1L << 4;
private static final long BIT_55 = 1L << 54;

public static void main(String[] args) {

checkBitMask(FIRST_BIT | THIRD_BIT | FIFTH_BIT | BIT_55);
}

private static void checkBitMask(long bitmask) {

System.out.println("FIRST_BIT: " + ((bitmask & FIRST_BIT) != 0));
System.out.println("SECOND_BIT: " + ((bitmask & SECOND_BIT) != 0));
System.out.println("THIRD_BIT: " + ((bitmask & THIRD_BIT) != 0));
System.out.println("FOURTh_BIT: " + ((bitmask & FOURTH_BIT) != 0));
System.out.println("FIFTH_BIT: " + ((bitmask & FIFTH_BIT) != 0));
System.out.println("BIT_55: " + ((bitmask & BIT_55) != 0));
}
}

Prints

FIRST_BIT: true
SECOND_BIT: false
THIRD_BIT: true
FOURTh_BIT: false
FIFTH_BIT: true
BIT_55: true

which matches that mask we passed as checkBitMask parameter: FIRST_BIT | THIRD_BIT | FIFTH_BIT | BIT_55.

Section 22.2: java.util.BitSet class

Since 1.7 there's a java.util.BitSet class that provides simple and user-friendly bit storage and manipulation
interface:

final BitSet bitSet = new BitSet(8); // by default all bits are unset

IntStream.range(0, 8).filter(i -> i % 2 == 0).forEach(bitSet::set); // {0, 2, 4, 6} bitSet.set(3); // {0, 2, 3, 4, 6}

INFOBYTE CAREER INSTITUTE 104

 bitSet.set(3, false); // {0, 2, 4, 6}

final boolean b = bitSet.get(3); // b = false

bitSet.flip(6); // {0, 2, 4}

bitSet.set(100); // {0, 2, 4, 100} - expands automatically

BitSet implements Clonable and Serializable, and under the hood all bit values are stored in long[] words field, that expands
automatically.

It also supports whole-set logical operations and, or, xor, andNot:

bitSet.and(new BitSet(8));
bitSet.or(new BitSet(8));
bitSet.xor(new BitSet(8));
bitSet.andNot(new BitSet(8));

Section 22.3: Checking if a number is a power of 2

If an integer x is a power of 2, only one bit is set, whereas x-1 has all bits set after that. For example: 4 is 100 and 3 is
011 as binary number, which satisfies the aforementioned condition. Zero is not a power of 2 and has to be checked
explicitly.

boolean isPowerOfTwo(int x)
{
return (x != 0) && ((x & (x - 1)) == 0);
}

Usage for Left and Right Shift

Let’s suppose, we have three kind of permissions, READ, WRITE and EXECUTE. Each permission can range from 0 to
7. (Let’s assume 4 bit number system)

RESOURCE = READ WRITE EXECUTE (12 bit number)

RESOURCE = 0100 0110 0101 = 4 6 5 (12 bit number)

How can we get the (12 bit number) permissions, set on above (12 bit number)?

0100 0110 0101

0000 0000 0111 (&)

0000 0000 0101 = 5

So, this is how we can get the EXECUTE permissions of the RESOURCE. Now, what if we want to get READ
permissions of the RESOURCE?

0100 0110 0101

0111 0000 0000 (&)

INFOBYTE CAREER INSTITUTE 105

 0100 0000 0000 = 1024

Right? You are probably assuming this? But, permissions are resulted in 1024. We want to get only READ permissions
for the resource. Don’t worry, that’s why we had the shift operators. If we see, READ permissions are 8 bits behind the
actual result, so if apply some shift operator, which will bring READ permissions to the very right of the result? What if we
do:

0100 0000 0000 >> 8 => 0000 0000 0100 (Because it’s a positive number so replaced with 0’s, if you don’t
care about sign, just use unsigned right shift operator)

We now actually have the READ permissions which is 4.

Now, for example, we are given READ, WRITE, EXECUTE permissions for a RESOURCE, what can we do to make
permissions for this RESOURCE?

Let’s first take the example of binary permissions. (Still assuming 4 bit number system)

READ = 0001

WRITE = 0100

EXECUTE = 0110

If you are thinking that we will simply do:

READ | WRITE | EXECUTE, you are somewhat right but not exactly. See, what will happen if we will perform READ |
WRITE | EXECUTE

0001 | 0100 | 0110 => 0111

But permissions are actually being represented (in our example) as 0001 0100 0110

So, in order to do this, we know that READ is placed 8 bits behind, WRITE is placed 4 bits behind and PERMISSIONS is
placed at the last. The number system being used for RESOURCE permissions is actually 12 bit (in our example). It
can(will) be different in different systems.

(READ << 8) | (WRITE << 4) | (EXECUTE)

0000 0000 0001 << 8 (READ)

0001 0000 0000 (Left shift by 8 bits)

0000 0000 0100 << 4 (WRITE)

0000 0100 0000 (Left shift by 4 bits)

0000 0000 0001 (EXECUTE)

Now if we add the results of above shifting, it will be something like;

INFOBYTE CAREER INSTITUTE 106

 0001 0000 0000 (READ)

0000 0100 0000 (WRITE)

0000 0000 0001 (EXECUTE)

0001 0100 0001 (PERMISSIONS)

Section 22.4: Signed vs unsigned shift

In Java, all number primitives are signed. For example, an int always represent values from [-2^31 - 1, 2^31], keeping the
first bit to sign the value - 1 for negative value, 0 for positive.

Basic shift operators >> and << are signed operators. They will conserve the sign of the value.

But it is common for programmers to use numbers to store unsigned values. For an int, it means shifting the range to
[0, 2^32 - 1], to have twice as much value as with a signed int.

For those power users, the bit for sign as no meaning. That's why Java added >>>, a left-shift operator, disregarding that
sign bit.

initial value: 4 ( 100)

signed left-shift: 4 << 1 8 ( 1000)
signed right-shift: 4 >> 1 2 ( 10)
unsigned right-shift: 4 >>> 1 2 ( 10)
initial value: -4 ( 11111111111111111111111111111100)
signed left-shift: -4 << 1 -8 ( 11111111111111111111111111111000)
signed right-shift: -4 >> 1 -2 ( 11111111111111111111111111111110)
unsigned right-shift: -4 >>> 1 2147483646 ( 1111111111111111111111111111110)

Why is there no <<< ?

This comes from the intended definition of right-shift. As it fills the emptied places on the left, there are no decision to
take regarding the bit of sign. As a consequence, there is no need for 2 different operators.

See this question for a more detailled answer.

Section 22.5: Expressing the power of 2

For expressing the power of 2 (2^n) of integers, one may use a bitshift operation that allows to explicitly specify the n.

The syntax is basically:

int pow2 = 1<<n;

Examples:

int twoExp4 = 1<<4; //2^4

int twoExp5 = 1<<5; //2^5
int twoExp6 = 1<<6; //2^6
...
int twoExp31 = 1<<31; //2^31

This is especially useful when defining constant values that should make it apparent, that a power of 2 is used,

INFOBYTE CAREER INSTITUTE 107

instead of using hexadecimal or decimal values.

int twoExp4 = 0x10; //hexadecimal

int twoExp5 = 0x20; //hexadecimal
int twoExp6 = 64; //decimal
...
int twoExp31 = -2147483648; //is that a power of 2?

A simple method to calculate the int power of 2 would be

int pow2(int exp){

return 1<<exp;
}

Section 22.6: Packing / unpacking values as bit fragments

It is common for memory performance to compress multiple values into a single primitive value. This may be useful to
pass various information into a single variable.

For example, one can pack 3 bytes - such as color code in RGB - into an single int.

Packing the values

// Raw bytes as input

byte[] b = {(byte)0x65, (byte)0xFF, (byte)0x31};

Packed in big endian: x == 0x65FF31 int x =

(b[0] & 0xFF) << 16 // Red
| (b[1] & 0xFF) << 8 // Green
(b[2] & 0xFF) << 0; // Blue

Packed in little endian: y == 0x31FF65 int y =

(b[0] & 0xFF) << 0
(b[1] & 0xFF) << 8
(b[2] & 0xFF) << 16;

Unpacking the values

Raw int32 as input int x

= 0x31FF65;

Unpacked in big endian: {0x65, 0xFF, 0x31} byte[] c = {

(byte)(x >> 16),

(byte)(x >> 8),
(byte)(x & 0xFF)
};

Unpacked in little endian: {0x31, 0xFF, 0x65} byte[] d = {

(byte)(x & 0xFF),

(byte)(x >> 8),
(byte)(x >> 16)
};

INFOBYTE CAREER INSTITUTE 108

Chapter 23: Arrays
Parameter Details
ArrayType Type of the array. This can be primitive (int, long, byte) or Objects (String, MyObject, etc).
index Index refers to the position of a certain Object in an array.
Every array, when being created, needs a set length specified. This is either done when creating an
length
empty array (new int[3]) or implied when specifying values ({1, 2, 3}).

Arrays allow for the storage and retrieval of an arbitrary quantity of values. They are analogous to vectors in
mathematics. Arrays of arrays are analogous to matrices, and act as multidimensional arrays. Arrays can store any data
of any type: primitives such as int or reference types such as Object.

Section 23.1: Creating and Initializing Arrays

Basic cases
int[] numbers1 = new int[3]; // Array for 3 int values, default value is 0
int[] numbers2 = { 1, 2, 3 }; // Array literal of 3 int values
int[] numbers3 = new int[] { 1, 2, 3 }; // Array of 3 int values initialized
int[][] numbers4 = { { 1, 2 }, { 3, 4, 5 } }; // Jagged array literal
int[][] numbers5 = new int[5][]; // Jagged array, one dimension 5 long
int[][] numbers6 = new int[5][4]; // Multidimensional array: 5x4

Arrays may be created using any primitive or reference type.

float[] boats = new float[5]; // Array of five 32-bit floating point numbers. double[] header = new double[] { 4.56,
332.267, 7.0, 0.3367, 10.0 };
Array of five 64-bit floating point numbers.
String[] theory = new String[] { "a", "b", "c" };
Array of three strings (reference type).
Object[] dArt = new Object[] { new Object(), "We love Stack Overflow.", new Integer(3) }; // Array of three Objects
(reference type).

For the last example, note that subtypes of the declared array type are allowed in the array.

Arrays for user defined types can also be built similar to primitive types

UserDefinedClass[] udType = new UserDefinedClass[5];

Arrays, Collections, and Streams

Version ≥ Java SE 1.2

// Parameters require objects, not primitives

// Auto-boxing happening for int 127 here

Integer[] initial = { 127, Integer.valueOf( 42 ) };
List<Integer> toList = Arrays.asList( initial ); // Fixed size!

// Note: Works with all collections

Integer[] fromCollection = toList.toArray( new Integer[toList.size()] );

//Java doesn't allow you to create an array of a parameterized type

List<String>[] list = new ArrayList<String>[2]; // Compilation error!
Version ≥ Java SE 8
// Streams - JDK 8+
Stream<Integer> toStream = Arrays.stream( initial );
Integer[] fromStream = toStream.toArray( Integer[]::new );

Intro

INFOBYTE CAREER INSTITUTE 109

An array is a data structure that holds a fixed number of primitive values or references to object instances.

Each item in an array is called an element, and each element is accessed by its numerical index. The length of an
array is established when the array is created:

int size = 42;

int[] array = new int[size];

The size of an array is fixed at runtime when initialized. It cannot be changed after initialization. If the size must be
mutable at runtime, a Collection class such as ArrayList should be used instead. ArrayList stores elements in an array and
supports resizing by allocating a new array and copying elements from the old array.

If the array is of a primitive type, i.e.

int[] array1 = { 1,2,3 };

int[] array2 = new int[10];

the values are stored in the array itself. In the absence of an initializer (as in array2 above), the default value
assigned to each element is 0 (zero).

If the array type is an object reference, as in

SomeClassOrInterface[] array = new SomeClassOrInterface[10];

then the array contains references to objects of type SomeClassOrInterface. Those references can refer to an instance of
SomeClassOrInterface or any subclass (for classes) or implementing class (for interfaces) of SomeClassOrInterface. If the
array declaration has no initializer then the default value of null is assigned to each element.

Because all arrays are int-indexed, the size of an array must be specified by an int. The size of the array cannot be
specified as a long:

long size = 23L;

int[] array = new int[size]; // Compile-time error:
incompatible types: possible lossy conversion from
long to int

Arrays use a zero-based index system, which means indexing starts at 0 and ends at length - 1.

For example, the following image represents an array with size 10. Here, the first element is at index 0 and the last
element is at index 9, instead of the first element being at index 1 and the last element at index 10 (see figure below).

Accesses to elements of arrays are done in constant time. That means accessing to the first element of the array has
the same cost (in time) of accessing the second element, the third element and so on.

Java offers several ways of defining and initializing arrays, including literal and constructor notations. When

INFOBYTE CAREER INSTITUTE 110

 declaring arrays using the new Type[length] constructor, each element will be initialized with the following default values:

0 for primitive numerical types: byte, short, int, long, float, and double.
'\u0000' (null character) for the char type.
false for the boolean type.
null for reference types.

Creating and initializing primitive type arrays

int[] array1 = new int[] { 1, 2, 3 }; // Create an array with new operator and
// array initializer.
int[] array2 = { 1, 2, 3 }; // Shortcut syntax with array initializer.
int[] array3 = new int[3]; // Equivalent to {0,0,0}
int[] array4 = null; // The array itself is an object, so it
// can be set as null.

When declaring an array, [] will appear as part of the type at the beginning of the declaration (after the type name), or as
part of the declarator for a particular variable (after variable name), or both:

int array5[]; /* equivalent to */ int[] array5;

int a, b[], c[][]; /* equivalent to */ int a; int[] b; int[][] c;
int[] a, b[]; /* equivalent to */ int[] a; int[][] b;
int a, []b, c[][]; /* Compilation Error, because [] is not part of the type at beginning of the declaration, rather
it is before 'b'. */
The same rules apply when declaring a method that returns an array: int foo()[] { ... } /*
equivalent to */ int[] foo() { ... }

In the following example, both declarations are correct and can compile and run without any problems. However, both
the Java Coding Convention and the Google Java Style Guide discourage the form with brackets after the variable
name—the brackets identify the array type and should appear with the type designation. The same should be used for
method return signatures.

float array[]; /* and */ int foo()[] { ... } /* are discouraged */ float[] array; /* and */ int[]
foo() { ... } /* are encouraged */

The discouraged type is meant to accommodate transitioning C users, who are familiar with the syntax for C which has
the brackets after the variable name.

In Java, it is possible to have arrays of size 0:

int[] array = new int[0]; // Compiles and runs fine.

int[] array2 = {}; // Equivalent syntax.

However, since it's an empty array, no elements can be read from it or assigned to it:

array[0] = 1; // Throws java.lang.ArrayIndexOutOfBoundsException.

int i = array2[0]; // Also throws ArrayIndexOutOfBoundsException.

Such empty arrays are typically useful as return values, so that the calling code only has to worry about dealing with an
array, rather than a potential null value that may lead to a NullPointerException.

The length of an array must be a non-negative integer:

int[] array = new int[-1]; // Throws java.lang.NegativeArraySizeException

INFOBYTE CAREER INSTITUTE 111

The array size can be determined using a public final field called length:

System.out.println(array.length); // Prints 0 in this case.

Note: array.length returns the actual size of the array and not the number of array elements which were assigned a value,
unlike ArrayList.size() which returns the number of array elements which were assigned a value.

Creating and initializing multi-dimensional arrays

The simplest way to create a multi-dimensional array is as follows:

int[][] a = new int[2][3];

It will create two three-length int arrays—a[0] and a[1]. This is very similar to the classical, C-style initialization of
rectangular multi-dimensional arrays.

You can create and initialize at the same time:

int[][] a = { {1, 2}, {3, 4}, {5, 6} };

Unlike C, where only rectangular multi-dimensional arrays are supported, inner arrays do not need to be of the same
length, or even defined:

int[][] a = { {1}, {2, 3}, null };

Here, a[0] is a one-length int array, whereas a[1] is a two-length int array and a[2] is null. Arrays like this are called
jagged arrays or ragged arrays, that is, they are arrays of arrays. Multi-dimensional arrays in Java are implemented as
arrays of arrays, i.e. array[i][j][k] is equivalent to ((array[i])[j])[k]. Unlike C#, the syntax array[i,j] is not supported in Java.

Multidimensional array representation in Java

Source - Live on Ideone

Creating and initializing reference type arrays

String[] array6 = new String[] { "Laurel", "Hardy" }; // Create an array with new
// operator and array initializer.
String[] array7 = { "Laurel", "Hardy" }; // Shortcut syntax with array

INFOBYTE CAREER INSTITUTE 112

 // initializer.
String[] array8 = new String[3]; // { null, null, null }
String[] array9 = null; // null

Live on Ideone

In addition to the String literals and primitives shown above, the shortcut syntax for array initialization also works with
canonical Object types:

Object[] array10 = { new Object(), new Object() };

Because arrays are covariant, a reference type array can be initialized as an array of a subclass, although an
ArrayStoreException will be thrown if you try to set an element to something other than a String:

Object[] array11 = new String[] { "foo", "bar", "baz" }; array11[1] = "qux"; //

fine
array11[1] = new StringBuilder(); // throws ArrayStoreException

The shortcut syntax cannot be used for this because the shortcut syntax would have an implicit type of Object[].

An array can be initialized with zero elements by using String[] emptyArray = new String[0]. For example, an array with
zero length like this is used for Creating an Array from a Collection when the method needs the runtime type of an
object.

In both primitive and reference types, an empty array initialization (for example String[] array8 = new String[3])
will initialize the array with the default value for each data type.

Creating and initializing generic type arrays

In generic classes, arrays of generic types cannot be initialized like this due to type erasure:

public class MyGenericClass<T> {

private T[] a;

public MyGenericClass() {
a = new T[5]; // Compile time error: generic array creation
}
}

Instead, they can be created using one of the following methods: (note that these will generate unchecked
warnings)

1. By creating an Object array, and casting it to the generic type:

a = (T[]) new Object[5];

This is the simplest method, but since the underlying array is still of type Object[], this method does not provide
type safety. Therefore, this method of creating an array is best used only within the generic class - not exposed
publicly.

2. By using Array.newInstance with a class parameter:

public MyGenericClass(Class<T> clazz) {

a = (T[]) Array.newInstance(clazz, 5);

INFOBYTE CAREER INSTITUTE 113

 }

Here the class of T has to be explicitly passed to the constructor. The return type of Array.newInstance is always
Object. However, this method is safer because the newly created array is always of type T[], and therefore can
be safely externalized.

Filling an array after initialization

Version ≥ Java SE 1.2

Arrays.fill() can be used to fill an array with the same value after initialization:

Arrays.fill(array8, "abc"); // { "abc", "abc", "abc" }

Live on Ideone

fill() can also assign a value to each element of the specified range of the array:

Arrays.fill(array8, 1, 2, "aaa"); // Placing "aaa" from index 1 to 2.

Live on Ideone

Version ≥ Java SE 8

Since Java version 8, the method setAll, and its Concurrent equivalent parallelSetAll, can be used to set every element of
an array to generated values. These methods are passed a generator function which accepts an index and returns the
desired value for that position.

The following example creates an integer array and sets all of its elements to their respective index value:

int[] array = new int[5];

Arrays.setAll(array, i -> i); // The array becomes { 0, 1, 2, 3, 4 }.

Live on Ideone

Separate declaration and initialization of arrays

The value of an index for an array element must be a whole number (0, 1, 2, 3, 4, ...) and less than the length of the
array (indexes are zero-based). Otherwise, an ArrayIndexOutOfBoundsException will be thrown:

int[] array9; // Array declaration - uninitialized

array9 = new int[3]; // Initialize array -{0,0,0 }
array9[0] = 10; // Set index 0 value -{10,0,0}
array9[1] = 20; // Set index 1 value - { 10, 20, 0 }
array9[2] = 30; // Set index 2 value - { 10, 20, 30 }
Arrays may not be re-initialized with array initializer shortcut syntax

It is not possible to re-initialize an array via a shortcut syntax with an array initializer since an array initializer can only
be specified in a field declaration or local variable declaration, or as a part of an array creation expression.

However, it is possible to create a new array and assign it to the variable being used to reference the old array. While this
results in the array referenced by that variable being re-initialized, the variable contents are a completely new array. To
do this, the new operator can be used with an array initializer and assigned to the array variable:

// First initialization of array

int[] array = new int[] { 1, 2, 3 };

INFOBYTE CAREER INSTITUTE 114

 Prints "1 2 3 ". for (int i :
array) {
System.out.print(i + " ");
}

Re-initializes array to a new int[] array. array = new

int[] { 4, 5, 6 };

Prints "4 5 6 ".

for (int i : array) {
System.out.print(i + " ");
}

array = { 1, 2, 3, 4 }; // Compile-time error! Can't re-initialize an array via shortcut // syntax with array initializer.

Live on Ideone

Section 23.2: Creating a List from an Array

The Arrays.asList() method can be used to return a fixed-size List containing the elements of the given array.
The resulting List will be of the same parameter type as the base type of the array.

String[] stringArray = {"foo", "bar", "baz"};

List<String> stringList = Arrays.asList(stringArray);

Note: This list is backed by (a view of) the original array, meaning that any changes to the list will change the array and
vice versa. However, changes to the list that would change its size (and hence the array length) will throw an
exception.

To create a copy of the list, use the constructor of java.util.ArrayList taking a Collection as an argument:

Version ≥ Java SE 5
String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = new ArrayList<String>(Arrays.asList(stringArray));
Version ≥ Java SE 7

In Java SE 7 and later, a pair of angle brackets <> (empty set of type arguments) can be used, which is called the
Diamond. The compiler can determine the type arguments from the context. This means the type information can be left
out when calling the constructor of ArrayList and it will be inferred automatically during compilation. This is called Type
Inference which is a part of Java Generics.

// Using Arrays.asList()

String[] stringArray = {"foo", "bar", "baz"};

List<String> stringList = new ArrayList<>(Arrays.asList(stringArray));

// Using ArrayList.addAll()

String[] stringArray = {"foo", "bar", "baz"};

ArrayList<String> list = new ArrayList<>();
list.addAll(Arrays.asList(stringArray));

// Using Collections.addAll()

String[] stringArray = {"foo", "bar", "baz"};

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, stringArray);

INFOBYTE CAREER INSTITUTE 115

A point worth noting about the Diamond is that it cannot be used with Anonymous Classes.

Version ≥ Java SE 8
// Using Streams

int[] ints = {1, 2, 3};

List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());

String[] stringArray = {"foo", "bar", "baz"};

List<Object> list = Arrays.stream(stringArray).collect(Collectors.toList());

Important notes related to using Arrays.asList() method

This method returns List, which is an instance of Arrays$ArrayList(static inner class of Arrays) and not
java.util.ArrayList. The resulting List is of fixed-size. That means, adding or removing elements is not supported
and will throw an UnsupportedOperationException:

stringList.add("something"); // throws java.lang.UnsupportedOperationException

A new List can be created by passing an array-backed List to the constructor of a new List. This creates a new
copy of the data, which has changeable size and that is not backed by the original array:

List<String> modifiableList = new ArrayList<>(Arrays.asList("foo", "bar"));

Calling <T> List<T> asList(T... a) on a primitive array, such as an int[], will produce a List<int[]> whose only
element is the source primitive array instead of the actual elements of the source array.

The reason for this behavior is that primitive types cannot be used in place of generic type parameters, so the
entire primitive array replaces the generic type parameter in this case. In order to convert a primitive array to a
List, first of all, convert the primitive array to an array of the corresponding wrapper type (i.e. call Arrays.asList on
an Integer[] instead of an int[]).

Therefore, this will print false:

int[] arr = {1, 2, 3}; // primitive array of int

System.out.println(Arrays.asList(arr).contains(1));

View Demo

On the other hand, this will print true:

Integer[] arr = {1, 2, 3}; // object array of Integer (wrapper for int)
System.out.println(Arrays.asList(arr).contains(1));

View Demo

This will also print true, because the array will be interpreted as an Integer[]):

System.out.println(Arrays.asList(1,2,3).contains(1));

View Demo

INFOBYTE CAREER INSTITUTE 116

Section 23.3: Creating an Array from a Collection
Two methods in java.util.Collection create an array from a collection:

Object[] toArray()

<T> T[] toArray(T[] a)

Object[] toArray() can be used as follows:

Version ≥ Java SE 5
Set<String> set = new HashSet<String>();
set.add("red");
set.add("blue");

although set is a Set<String>, toArray() returns an Object[] not a String[] Object[] objectArray =
set.toArray();

<T> T[] toArray(T[] a) can be used as follows:

Version ≥ Java SE 5
Set<String> set = new HashSet<String>();
set.add("red");
set.add("blue");

The array does not need to be created up front with the correct size.
Only the array type matters. (If the size is wrong, a new array will
be created with the same type.)
String[] stringArray = set.toArray(new String[0]);

If you supply an array of the same size as collection or bigger, it

will be populated with collection values and returned (new array
won't be allocated)
String[] stringArray2 = set.toArray(new String[set.size()]);

The difference between them is more than just having untyped vs typed results. Their performance can differ as well
(for details please read this performance analysis section):

Object[] toArray() uses vectorized arraycopy, which is much faster than the type-checked arraycopy used in T[]
toArray(T[] a).
T[] toArray(new T[non-zero-size]) needs to zero-out the array at runtime, while T[] toArray(new T[0]) does not. Such
avoidance makes the latter call faster than the former. Detailed analysis here : Arrays of Wisdom of the Ancients.
Version ≥ Java SE 8

Starting from Java SE 8+, where the concept of Stream has been introduced, it is possible to use the Stream
produced by the collection in order to create a new Array using the Stream.toArray method.

String[] strings = list.stream().toArray(String[]::new);

Examples taken from two answers (1, 2) to Converting 'ArrayList to 'String[]' in Java on Stack Overflow.

Section 23.4: Multidimensional and Jagged Arrays

It is possible to define an array with more than one dimension. Instead of being accessed by providing a single
index, a multidimensional array is accessed by specifying an index for each dimension.

INFOBYTE CAREER INSTITUTE 117

The declaration of multidimensional array can be done by adding [] for each dimension to a regular array declaration.
For instance, to make a 2-dimensional int array, add another set of brackets to the declaration, such as int[][]. This
continues for 3-dimensional arrays (int[][][]) and so forth.

To define a 2-dimensional array with three rows and three columns:

int rows = 3;
int columns = 3;
int[][] table = new int[rows][columns];

The array can be indexed and assign values to it with this construct. Note that the unassigned values are the default
values for the type of an array, in this case 0 for int.

table[0][0] = 0;
table[0][1] = 1;
table[0][2] = 2;

It is also possible to instantiate a dimension at a time, and even make non-rectangular arrays. These are more
commonly referred to as jagged arrays.

int[][] nonRect = new int[4][];

It is important to note that although it is possible to define any dimension of jagged array, it's preceding level must be
defined.

// valid
String[][] employeeGraph = new String[30][];

// invalid
int[][] unshapenMatrix = new int[][10];

// also invalid
int[][][] misshapenGrid = new int[100][][10];

How Multidimensional Arrays are represented in Java

Image source: http://math.hws.edu/eck/cs124/javanotes3/c8/s5.html

INFOBYTE CAREER INSTITUTE 118

Jagged array literal intialization

Multidimensional arrays and jagged arrays can also be initialized with a literal expression. The following declares and
populates a 2x3 int array:

int[][] table = {
{1, 2, 3},
{4, 5, 6}
};

Note: Jagged subarrays may also be null. For instance, the following code declares and populates a two
dimensional int array whose first subarray is null, second subarray is of zero length, third subarray is of one length
and the last subarray is a two length array:

int[][] table = {
null,
{},
{1},
{1,2}
};

For multidimensional array it is possible to extract arrays of lower-level dimension by their indices:

int[][][] arr = new int[3][3][3];

int[][] arr1 = arr[0]; // get first 3x3-dimensional array from arr int[] arr2 = arr1[0]; // get first
3-dimensional array from arr1 int[] arr3 = arr[0]; // error: cannot convert from int[][] to int[]

Section 23.5: ArrayIndexOutOfBoundsException

The ArrayIndexOutOfBoundsException is thrown when a non-existing index of an array is being accessed.

Arrays are zero-based indexed, so the index of the first element is 0 and the index of the last element is the array
capacity minus 1 (i.e. array.length - 1).

Therefore, any request for an array element by the index i has to satisfy the condition 0 <= i < array.length, otherwise
the ArrayIndexOutOfBoundsException will be thrown.

The following code is a simple example where an ArrayIndexOutOfBoundsException is thrown.

String[] people = new String[] { "Carol", "Andy" };

An array will be created:

people[0]: "Carol"
people[1]: "Andy"

Notice: no item on index 2. Trying to access it triggers the exception:

System.out.println(people[2]); // throws an ArrayIndexOutOfBoundsException.

Output:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2

at your.package.path.method(YourClass.java:15)

Note that the illegal index that is being accessed is also included in the exception ( 2 in the example); this information could

INFOBYTE CAREER INSTITUTE 119

be useful to find the cause of the exception.

To avoid this, simply check that the index is within the limits of the array:

int index = 2;
if (index >= 0 && index < people.length) {
System.out.println(people[index]);
}

Section 23.6: Array Covariance

Object arrays are covariant, which means that just as Integer is a subclass of Number, Integer[] is a subclass of
Number[]. This may seem intuitive, but can result in surprising behavior:

Integer[] integerArray = {1, 2, 3};

Number[] numberArray = integerArray; // valid
Number firstElement = numberArray[0]; // valid
numberArray[0] = 4L; // throws ArrayStoreException at runtime

Although Integer[] is a subclass of Number[], it can only hold Integers, and trying to assign a Long element throws a runtime
exception.

Note that this behavior is unique to arrays, and can be avoided by using a generic List instead:

List<Integer> integerList = Arrays.asList(1, 2, 3);

//List<Number> numberList = integerList; // compile error
List<? extends Number> numberList = integerList;
Number firstElement = numberList.get(0);
//numberList.set(0, 4L); // compile error

It's not necessary for all of the array elements to share the same type, as long as they are a subclass of the array's
type:

interface I {}

class A implements I {}
class B implements I {}
class C implements I {}

I[] array10 = new I[] { new A(), new B(), new C() }; // Create an array with new
// operator and array initializer.

I[] array11 = { new A(), new B(), new C() }; // Shortcut syntax with array
// initializer.

I[] array12 = new I[3]; // { null, null, null }

I[] array13 = new A[] { new A(), new A() }; // Works because A implements I.

Object[] array14 = new Object[] { "Hello, World!", 3.14159, 42 }; // Create an array with // new operator and array initializer.

Object[] array15 = { new A(), 64, "My String" }; // Shortcut syntax

// with array initializer.

INFOBYTE CAREER INSTITUTE 120

Section 23.7: Arrays to Stream
Version ≥ Java SE 8

Converting an array of objects to Stream:

String[] arr = new String[] {"str1", "str2", "str3"};

Stream<String> stream = Arrays.stream(arr);

Converting an array of primitives to Stream using Arrays.stream() will transform the array to a primitive
specialization of Stream:

int[] intArr = {1, 2, 3};

IntStream intStream = Arrays.stream(intArr);

You can also limit the Stream to a range of elements in the array. The start index is inclusive and the end index is
exclusive:

int[] values = {1, 2, 3, 4};

IntStream intStream = Arrays.stream(values, 2, 4);

A method similar to Arrays.stream() appears in the Stream class: Stream.of(). The difference is that Stream.of()
uses a varargs parameter, so you can write something like:

Stream<Integer> intStream = Stream.of(1, 2, 3);

Stream<String> stringStream = Stream.of("1", "2", "3");
Stream<Double> doubleStream = Stream.of(new Double[]{1.0, 2.0});

Section 23.8: Iterating over arrays

You can iterate over arrays either by using enhanced for loop (aka foreach) or by using array indices:

int[] array = new int[10];

// using indices: read and write

for (int i = 0; i < array.length; i++) {
array[i] = i;
}
Version ≥ Java SE 5
extended for: read only for
(int e : array) {
System.out.println(e);
}

It is worth noting here that there is no direct way to use an Iterator on an Array, but through the Arrays library it can be
easily converted to a list to obtain an Iterable object.

For boxed arrays use Arrays.asList:

Integer[] boxed = {1, 2, 3};

Iterable<Integer> boxedIt = Arrays.asList(boxed); // list-backed iterable Iterator<Integer>
fromBoxed1 = boxedIt.iterator();

For primitive arrays (using java 8) use streams (specifically in this example - Arrays.stream -> IntStream):

int[] primitives = {1, 2, 3};

INFOBYTE CAREER INSTITUTE 121

IntStream primitiveStream = Arrays.stream(primitives); // list-backed iterable PrimitiveIterator.OfInt
fromPrimitive1 = primitiveStream.iterator();

If you can't use streams (no java 8), you can choose to use google's guava library:

Iterable<Integer> fromPrimitive2 = Ints.asList(primitives);

In two-dimensional arrays or more, both techniques can be used in a slightly more complex fashion.

Example:

int[][] array = new int[10][10];

for (int indexOuter = 0; indexOuter < array.length; indexOuter++) {

for (int indexInner = 0; indexInner < array[indexOuter].length; indexInner++) {
array[indexOuter][indexInner] = indexOuter + indexInner;
}
}
Version ≥ Java SE 5
for (int[] numbers : array) {
for (int value : numbers) {
System.out.println(value);
}
}

It is impossible to set an Array to any non-uniform value without using an index based loop.

Of course you can also use while or do-while loops when iterating using indices.

One note of caution: when using array indices, make sure the index is between 0 and array.length - 1 (both
inclusive). Don't make hard coded assumptions on the array length otherwise you might break your code if the array
length changes but your hard coded values don't.

Example:

int[] numbers = {1, 2, 3, 4};

public void incrementNumbers() {

// DO THIS :
for (int i = 0; i < numbers.length; i++) {
numbers[i] += 1; //or this: numbers[i] = numbers[i] + 1; or numbers[i]++;
}

// DON'T DO THIS :
for (int i = 0; i < 4; i++) {
numbers[i] += 1;
}
}

It's also best if you don't use fancy calculations to get the index but use the index to iterate and if you need
different values calculate those.

Example:

public void fillArrayWithDoubleIndex(int[] array) { // DO THIS :

for (int i = 0; i < array.length; i++) {

array[i] = i * 2;

INFOBYTE CAREER INSTITUTE 122

 }

// DON'T DO THIS :
int doubleLength = array.length * 2;
for (int i = 0; i < doubleLength; i += 2) {
array[i / 2] = i;
}
}

Accessing Arrays in reverse order

int[] array = {0, 1, 1, 2, 3, 5, 8, 13};

for (int i = array.length - 1; i >= 0; i--) {
System.out.println(array[i]);
}

Using temporary Arrays to reduce code repetition

Iterating over a temporary array instead of repeating code can make your code cleaner. It can be used where the
same operation is performed on multiple variables.

we want to print out all of these String

name = "Margaret";
int eyeCount = 16; double
height = 50.2; int legs = 9;

int arms = 5;

copy-paste approach:
System.out.println(name);
System.out.println(eyeCount);
System.out.println(height);
System.out.println(legs);
System.out.println(arms);

// temporary array approach:

for(Object attribute : new Object[]{name, eyeCount, height, legs, arms})
System.out.println(attribute);

// using only numbers

for(double number : new double[]{eyeCount, legs, arms, height})
System.out.println(Math.sqrt(number));

Keep in mind that this code should not be used in performance-critical sections, as an array is created every time the
loop is entered, and that primitive variables will be copied into the array and thus cannot be modified.

Section 23.9: Arrays to a String

Version ≥ Java SE 5

Since Java 1.5 you can get a String representation of the contents of the specified array without iterating over its every
element. Just use Arrays.toString(Object[]) or Arrays.deepToString(Object[]) for multidimentional arrays:

int[] arr = {1, 2, 3, 4, 5};

System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4, 5]

INFOBYTE CAREER INSTITUTE 123

int[][] arr = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
System.out.println(Arrays.deepToString(arr)); // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Arrays.toString() method uses Object.toString() method to produce String values of every item in the array, beside primitive
type array, it can be used for all type of arrays. For instance:

public class Cat { /* implicitly extends Object */

@Override
public String toString() {
return "CAT!";
}
}

Cat[] arr = { new Cat(), new Cat() };

System.out.println(Arrays.toString(arr)); // [CAT!, CAT!]

If no overridden toString() exists for the class, then the inherited toString() from Object will be used. Usually the output is
then not very useful, for example:

public class Dog {

/* implicitly extends Object */
}

Dog[] arr = { new Dog() };

System.out.println(Arrays.toString(arr)); // [Dog@17ed40e0]

Section 23.10: Sorting arrays

Sorting arrays can be easily done with the Arrays api.

import java.util.Arrays;

creating an array with integers int[] array

= {7, 4, 2, 1, 19};
this is the sorting part just one function ready to be used Arrays.sort(array);

prints [1, 2, 4, 7, 19]

System.out.println(Arrays.toString(array));

Sorting String arrays:

String is not a numeric data, it defines it's own order which is called lexicographic order, also known as alphabetic order.
When you sort an array of String using sort() method, it sorts array into natural order defined by Comparable interface,
as shown below :

Increasing Order

String[] names = {"John", "Steve", "Shane", "Adam", "Ben"};

System.out.println("String array before sorting : " + Arrays.toString(names)); Arrays.sort(names);

System.out.println("String array after sorting in ascending order : " + Arrays.toString(names));

Output:

INFOBYTE CAREER INSTITUTE 124

String array before sorting : [John, Steve, Shane, Adam, Ben]
String array after sorting in ascending order : [Adam, Ben, John, Shane, Steve]

Decreasing Order

Arrays.sort(names, 0, names.length, Collections.reverseOrder());

System.out.println("String array after sorting in descending order : " + Arrays.toString(names));

Output:

String array after sorting in descending order : [Steve, Shane, John, Ben, Adam]

Sorting an Object array

In order to sort an object array, all elements must implement either Comparable or Comparator interface to define the
order of the sorting.

We can use either sort(Object[]) method to sort an object array on its natural order, but you must ensure that all elements
in the array must implement Comparable.

Furthermore, they must be mutually comparable as well, for example e1.compareTo(e2) must not throw a
ClassCastException for any elements e1 and e2 in the array. Alternatively you can sort an Object array on custom order
using sort(T[], Comparator) method as shown in following example.

How to Sort Object Array in Java using Comparator and Comparable Course[]
courses = new Course[4];
courses[0] = new Course(101, "Java", 200); courses[1] =
new Course(201, "Ruby", 300); courses[2] = new
Course(301, "Python", 400); courses[3] = new Course(401,
"Scala", 500);

System.out.println("Object array before sorting : " + Arrays.toString(courses));

Arrays.sort(courses);
System.out.println("Object array after sorting in natural order : " + Arrays.toString(courses));

Arrays.sort(courses, new Course.PriceComparator());

System.out.println("Object array after sorting by price : " + Arrays.toString(courses));

Arrays.sort(courses, new Course.NameComparator());

System.out.println("Object array after sorting by name : " + Arrays.toString(courses));

Output:

Object array before sorting : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]
Object array after sorting in natural order : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 ,
#401 Scala@500 ]
Object array after sorting by price : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401
Scala@500 ]
Object array after sorting by name : [#101 Java@200 , #301 Python@400 , #201 Ruby@300 , #401
Scala@500 ]

INFOBYTE CAREER INSTITUTE 125

Section 23.11: Getting the Length of an Array
Arrays are objects which provide space to store up to its size of elements of specified type. An array's size can not be
modified after the array is created.

int[] arr1 = new int[0];

int[] arr2 = new int[2];
int[] arr3 = new int[]{1, 2, 3, 4};
int[] arr4 = {1, 2, 3, 4, 5, 6, 7};

int len1 = arr1.length; // 0

int len2 = arr2.length; // 2
int len3 = arr3.length; // 4
int len4 = arr4.length; // 7

The length field in an array stores the size of an array. It is a final field and cannot be modified.

This code shows the difference between the length of an array and amount of objects an array stores.

public static void main(String[] args) {

Integer arr[] = new Integer[] {1,2,3,null,5,null,7,null,null,null,11,null,13};

int arrayLength = arr.length;

int nonEmptyElementsCount = 0;

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

Integer arrElt = arr[i];
if (arrElt != null) {
nonEmptyElementsCount++;
}
}

System.out.println("Array 'arr' has a length of "+arrayLength+"\n"

"and it contains "+nonEmptyElementsCount+" non-empty values");
}

Result:

Array 'arr' has a length of 13

and it contains 7 non-empty values

Section 23.12: Finding an element in an array

There are many ways find the location of a value in an array. The following example snippets all assume that the
array is one of the following:

String[] strings = new String[] { "A", "B", "C" }; int[] ints = new int[] {
1, 2, 3, 4 };

In addition, each one sets index or index2 to either the index of required element, or -1 if the element is not present.

Using Arrays.binarySearch (for sorted arrays only)

int index = Arrays.binarySearch(strings, "A");
int index2 = Arrays.binarySearch(ints, 1);

INFOBYTE CAREER INSTITUTE 126

Using a Arrays.asList (for non-primitive arrays only)
int index = Arrays.asList(strings).indexOf("A");
int index2 = Arrays.asList(ints).indexOf(1); // compilation error

Using a Stream
Version ≥ Java SE 8
int index = IntStream.range(0, strings.length)
.filter(i -> "A".equals(strings[i]))
.findFirst()
.orElse(-1); // If not present, gives us -1.
Similar for an array of primitives

Linear search using a loop

int index = -1;
for (int i = 0; i < array.length; i++) {
if ("A".equals(array[i])) {
index = i;
break;
}
}
// Similar for an array of primitives

Linear search using 3rd-party libraries such as org.apache.commons

int index = org.apache.commons.lang3.ArrayUtils.contains(strings, "A"); int index2 =
org.apache.commons.lang3.ArrayUtils.contains(ints, 1);

Note: Using a direct linear search is more efficient than wrapping in a list.

Testing if an array contains an element

The examples above can be adapted to test if the array contains an element by simply testing to see if the index
computed is greater or equal to zero.

Alternatively, there are also some more concise variations:

boolean isPresent = Arrays.asList(strings).contains("A");

Version ≥ Java SE 8
boolean isPresent = Stream<String>.of(strings).anyMatch(x -> "A".equals(x));

boolean isPresent = false;

for (String s : strings) {
if ("A".equals(s)) {
isPresent = true;
break;
}
}

boolean isPresent = org.apache.commons.lang3.ArrayUtils.contains(ints, 4);

Section 23.13: How do you change the size of an array?

The simple answer is that you cannot do this. Once an array has been created, its size cannot be changed. Instead, an
array can only be "resized" by creating a new array with the appropriate size and copying the elements from the existing
array to the new one.

String[] listOfCities = new String[3]; // array created with size 3.

listOfCities[0] = "New York";

INFOBYTE CAREER INSTITUTE 127

listOfCities[1] = "London";
listOfCities[2] = "Berlin";

Suppose (for example) that a new element needs to be added to the listOfCities array defined as above. To do this, you
will need to:

create a new array with size 4,

copy the existing 3 elements of the old array to the new array at offsets 0, 1 and 2, and
add the new element to the new array at offset 3.

There are various ways to do the above. Prior to Java 6, the most concise way was:

String[] newArray = new String[listOfCities.length + 1];

System.arraycopy(listOfCities, 0, newArray, 0, listOfCities.length);
newArray[listOfCities.length] = "Sydney";

From Java 6 onwards, the Arrays.copyOf and Arrays.copyOfRange methods can do this more simply:

String[] newArray = Arrays.copyOf(listOfCities, listOfCities.length + 1); newArray[listOfCities.length]

= "Sydney";

For other ways to copy an array, refer to the following example. Bear in mind that you need an array copy with a
different length to the original when resizing.

Copying arrays

A better alternatives to array resizing

There two major drawbacks with resizing an array as described above:

It is inefficient. Making an array bigger (or smaller) involves copying many or all of the existing array
elements, and allocating a new array object. The larger the array, the more expensive it gets.
You need to be able to update any "live" variables that contain references to the old array.

One alternative is to create the array with a large enough size to start with. This is only viable if you can determine that
size accurately before allocating the array. If you cannot do that, then the problem of resizing the array arises again.

The other alternative is to use a data structure class provided by the Java SE class library or a third-party library. For
example, the Java SE "collections" framework provides a number of implementations of the List, Set and Map APIs with
different runtime properties. The ArrayList class is closest to performance characteristics of a plain array (e.g. O(N)
lookup, O(1) get and set, O(N) random insertion and deletion) while providing more efficient resizing without the
reference update problem.

(The resize efficiency for ArrayList comes from its strategy of doubling the size of the backing array on each resize. For a
typical use-case, this means that you only resize occasionally. When you amortize over the lifetime of the list, the resize
cost per insert is O(1). It may be possible to use the same strategy when resizing a plain array.)

Section 23.14: Converting arrays between primitives and

boxed types
Sometimes conversion of primitive types to boxed types is necessary.

To convert the array, it's possible to use streams (in Java 8 and above):

INFOBYTE CAREER INSTITUTE 128

Version ≥ Java SE 8
int[] primitiveArray = {1, 2, 3, 4};
Integer[] boxedArray =
Arrays.stream(primitiveArray).boxed().toArray(Integer[]::new);

With lower versions it can be by iterating the primitive array and explicitly copying it to the boxed array:

Version < Java SE 8

int[] primitiveArray = {1, 2, 3, 4};
Integer[] boxedArray = new Integer[primitiveArray.length]; for (int i = 0; i <
primitiveArray.length; ++i) {
boxedArray[i] = primitiveArray[i]; // Each element is autoboxed here
}

Similarly, a boxed array can be converted to an array of its primitive counterpart:

Version ≥ Java SE 8
Integer[] boxedArray = {1, 2, 3, 4};
int[] primitiveArray =
Arrays.stream(boxedArray).mapToInt(Integer::intValue).toArray();
Version < Java SE 8

Integer[] boxedArray = {1, 2, 3, 4};

int[] primitiveArray = new int[boxedArray.length]; for (int i = 0; i <
boxedArray.length; ++i) {
primitiveArray[i] = boxedArray[i]; // Each element is outboxed here
}

Section 23.15: Remove an element from an array

Java doesn't provide a direct method in java.util.Arrays to remove an element from an array. To perform it, you can either
copy the original array to a new one without the element to remove or convert your array to another structure allowing
the removal.

Using ArrayList

You can convert the array to a java.util.List, remove the element and convert the list back to an array as follows:

String[] array = new String[]{"foo", "bar", "baz"};

List<String> list = new ArrayList<>(Arrays.asList(array)); list.remove("foo");

Creates a new array with the same size as the list and copies the list
elements to it.
array = list.toArray(new String[list.size()]);

System.out.println(Arrays.toString(array)); //[bar, baz]

Using System.arraycopy

System.arraycopy() can be used to make a copy of the original array and remove the element you want. Below an
example:

int[] array = new int[] { 1, 2, 3, 4 }; // Original array.

int[] result = new int[array.length - 1]; // Array which will contain the result.
int index = 1; // Remove the value "2".

INFOBYTE CAREER INSTITUTE 129

 Copy the elements at the left of the index.
System.arraycopy(array, 0, result, 0, index);
Copy the elements at the right of the index.
System.arraycopy(array, index + 1, result, index, array.length - index - 1);

System.out.println(Arrays.toString(result)); //[1, 3, 4]

Using Apache Commons Lang

To easily remove an element, you can use the Apache Commons Lang library and especially the static method
removeElement() of the class ArrayUtils. Below an example:

int[] array = new int[]{1,2,3,4};

array = ArrayUtils.removeElement(array, 2); //remove first occurrence of 2
System.out.println(Arrays.toString(array)); //[1, 3, 4]

Section 23.16: Comparing arrays for equality

Array types inherit their equals() (and hashCode()) implementations from java.lang.Object, so equals() will only return true
when comparing against the exact same array object. To compare arrays for equality based on their values, use
java.util.Arrays.equals, which is overloaded for all array types.

int[] a = new int[]{1, 2, 3};

int[] b = new int[]{1, 2, 3};
System.out.println(a.equals(b)); //prints "false" because a and b refer to different objects System.out.println(Arrays.equals(a, b));
//prints "true" because the elements of a and b have the same values

When the element type is a reference type, Arrays.equals() calls equals() on the array elements to determine equality. In
particular, if the element type is itself an array type, identity comparison will be used. To compare multidimensional
arrays for equality, use Arrays.deepEquals() instead as below:

int a[] = { 1, 2, 3 };
int b[] = { 1, 2, 3 };

Object[] aObject = { a }; // aObject contains one element

Object[] bObject = { b }; // bObject contains one element

System.out.println(Arrays.equals(aObject, bObject)); // false

System.out.println(Arrays.deepEquals(aObject, bObject));// true

Because sets and maps use equals() and hashCode(), arrays are generally not useful as set elements or map keys. Either
wrap them in a helper class that implements equals() and hashCode() in terms of the array elements, or convert them to
List instances and store the lists.

Section 23.17: Copying arrays

Java provides several ways to copy an array.

for loop
int[] a = { 4, 1, 3, 2 };
int[] b = new int[a.length];
for (int i = 0; i < a.length; i++) {
b[i] = a[i];
}

INFOBYTE CAREER INSTITUTE 130

Note that using this option with an Object array instead of primitive array will fill the copy with reference to the
original content instead of copy of it.

Object.clone()

Since arrays are Objects in Java, you can use Object.clone().

int[] a = { 4, 1, 3, 2 };
int[] b = a.clone(); // [4, 1, 3, 2]

Note that the Object.clone method for an array performs a shallow copy, i.e. it returns a reference to a new array which
references the same elements as the source array.

Arrays.copyOf()

java.util.Arrays provides an easy way to perform the copy of an array to another. Here is the basic usage:

int[] a = {4, 1, 3, 2};

int[] b = Arrays.copyOf(a, a.length); // [4, 1, 3, 2]

Note that Arrays.copyOf also provides an overload which allows you to change the type of the array:

Double[] doubles = { 1.0, 2.0, 3.0 };

Number[] numbers = Arrays.copyOf(doubles, doubles.length, Number[].class);

System.arraycopy()

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
Copies an array from the specified source array, beginning at the specified position, to the specified
position of the destination array.

Below an example of use

int[] a = { 4, 1, 3, 2 };
int[] b = new int[a.length];
System.arraycopy(a, 0, b, 0, a.length); // [4, 1, 3, 2]

Arrays.copyOfRange()

Mainly used to copy a part of an Array, you can also use it to copy whole array to another as below:

int[] a = { 4, 1, 3, 2 };
int[] b = Arrays.copyOfRange(a, 0, a.length); // [4, 1, 3, 2]

Section 23.18: Casting Arrays

Arrays are objects, but their type is defined by the type of the contained objects. Therefore, one cannot just cast A[] to T[],
but each A member of the specific A[] must be cast to a T object. Generic example:

public static <T, A> T[] castArray(T[] target, A[] array) { for (int i = 0; i <
array.length; i++) {
target[i] = (T) array[i];

INFOBYTE CAREER INSTITUTE 131

 }
return target;
}

Thus, given an A[] array:

T[] target = new T[array.Length];

target = castArray(target, array);

Java SE provides the method Arrays.copyOf(original, newLength, newType) for this purpose:

Double[] doubles = { 1.0, 2.0, 3.0 };

Number[] numbers = Arrays.copyOf(doubles, doubles.length, Number[].class);

INFOBYTE CAREER INSTITUTE 132

Chapter 24: Collections
The collections framework in java.util provides a number of generic classes for sets of data with functionality that can't be
provided by regular arrays.

Collections framework contains interfaces for Collection<O>, with main sub-interfaces List<O> and Set<O>, and mapping
collection Map<K,V>. Collections are the root interface and are being implemented by many other collection
frameworks.

Section 24.1: Removing items from a List within a loop

It is tricky to remove items from a list while within a loop, this is due to the fact that the index and length of the list gets
changed.

Given the following list, here are some examples that will give an unexpected result and some that will give the
correct result.

List<String> fruits = new ArrayList<String>();

fruits.add("Apple");
fruits.add("Banana");
fruits.add("Strawberry");
INCORRECT
Removing in iteration of for statement Skips "Banana":

The code sample will only print Apple and Strawberry. Banana is skipped because it moves to index 0 once Apple is
deleted, but at the same time i gets incremented to 1.

for (int i = 0; i < fruits.size(); i++) {

System.out.println (fruits.get(i));
if ("Apple".equals(fruits.get(i))) {
fruits.remove(i);
}
}

Removing in the enhanced for statement Throws Exception:

Because of iterating over collection and modifying it at the same time.

Throws: java.util.ConcurrentModificationException

for (String fruit : fruits) {

System.out.println(fruit);
if ("Apple".equals(fruit)) {
fruits.remove(fruit);
}
}
CORRECT
Removing in while loop using an Iterator
Iterator<String> fruitIterator = fruits.iterator();
while(fruitIterator.hasNext()) {
String fruit = fruitIterator.next();
System.out.println(fruit);
if ("Apple".equals(fruit)) {

INFOBYTE CAREER INSTITUTE 133

 fruitIterator.remove();
}
}

The Iterator interface has a remove() method built in just for this case. However, this method is marked as
"optional" in the documentation, and it might throw an UnsupportedOperationException.

Throws: UnsupportedOperationException - if the remove operation is not supported by this iterator

Therefore, it is advisable to check the documentation to make sure this operation is supported (in practice, unless the
collection is an immutable one obtained through a 3rd party library or the use of one of the Collections.unmodifiable...()
method, the operation is almost always supported).

While using an Iterator a ConcurrentModificationException is thrown when the modCount of the List is changed from when the
Iterator was created. This could have happened in the same thread or in a multi-threaded application sharing the same
list.

A modCount is an int variable which counts the number of times this list has been structurally modified. A structural
change essentially means an add() or remove() operation being invoked on Collection object (changes made by Iterator are
not counted). When the Iterator is created, it stores this modCount and on every iteration of the List checks if the current
modCount is same as and when the Iterator was created. If there is a change in the modCount value it throws a
ConcurrentModificationException.

Hence for the above-declared list, an operation like below will not throw any exception:

Iterator<String> fruitIterator = fruits.iterator(); fruits.set(0,

"Watermelon"); while(fruitIterator.hasNext()){

System.out.println(fruitIterator.next());
}

But adding a new element to the List after initializing an Iterator will throw a
ConcurrentModificationException:

Iterator<String> fruitIterator = fruits.iterator();

fruits.add("Watermelon");
while(fruitIterator.hasNext()){
System.out.println(fruitIterator.next()); //ConcurrentModificationException here
}

Iterating backwards
for (int i = (fruits.size() - 1); i >=0; i--) {
System.out.println (fruits.get(i));
if ("Apple".equals(fruits.get(i))) {
fruits.remove(i);
}
}

This does not skip anything. The downside of this approach is that the output is reverse. However, in most cases
where you remove items that will not matter. You should never do this with LinkedList.

Iterating forward, adjusting the loop index

for (int i = 0; i < fruits.size(); i++) {
System.out.println (fruits.get(i));

INFOBYTE CAREER INSTITUTE 134

 if ("Apple".equals(fruits.get(i))) {
fruits.remove(i);
i--;
}
}

This does not skip anything. When the ith element is removed from the List, the element originally positioned at index
i+1 becomes the new ith element. Therefore, the loop can decrement i in order for the next iteration to process the next
element, without skipping.

Using a "should-be-removed" list

ArrayList shouldBeRemoved = new ArrayList();
for (String str : currentArrayList) {
if (condition) {
shouldBeRemoved.add(str);
}
}
currentArrayList.removeAll(shouldBeRemoved);

This solution enables the developer to check if the correct elements are removed in a cleaner way.

Version ≥ Java SE 8

In Java 8 the following alternatives are possible. These are cleaner and more straight forward if the removing does
not have to happen in a loop.

Filtering a Stream

A List can be streamed and filtered. A proper filter can be used to remove all undesired elements.

List<String> filteredList =
fruits.stream().filter(p -> !"Apple".equals(p)).collect(Collectors.toList());

Note that unlike all the other examples here, this example produces a new List instance and keeps the original List
unchanged.

Using removeIf

Saves the overhead of constructing a stream if all that is needed is to remove a set of items.

fruits.removeIf(p -> "Apple".equals(p));

Section 24.2: Constructing collections from existing data

Standard Collections
Java Collections framework

A simple way to construct a List from individual data values is to use java.utils.Arrays method Arrays.asList:

List<String> data = Arrays.asList("ab", "bc", "cd", "ab", "bc", "cd");

All standard collection implementations provide constructors that take another collection as an argument adding all
elements to the new collection at the time of construction:

List<String> list = new ArrayList<>(data); // will add data as is

Set<String> set1 = new HashSet<>(data); // will add data keeping only unique values

INFOBYTE CAREER INSTITUTE 135

SortedSet<String> set2 = new TreeSet<>(data); // will add data keeping unique values and sorting Set<String> set3 = new
LinkedHashSet<>(data); // will add data keeping only unique values and preserving the original order

Google Guava Collections framework

Another great framework is Google Guava that is amazing utility class (providing convenience static methods) for
construction of different types of standard collections Lists and Sets:

import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
...
List<String> list1 = Lists.newArrayList("ab", "bc", "cd");
List<String> list2 = Lists.newArrayList(data);
Set<String> set4 = Sets.newHashSet(data);
SortedSet<String> set5 = Sets.newTreeSet("bc", "cd", "ab", "bc", "cd");
Mapping Collections
Java Collections framework

Similarly for maps, given a Map<String, Object> map a new map can be constructed with all elements as follows:

Map<String, Object> map1 = new HashMap<>(map);

SortedMap<String, Object> map2 = new TreeMap<>(map);

Apache Commons Collections framework

Using Apache Commons you can create Map using array in ArrayUtils.toMap as well as MapUtils.toMap:

import org.apache.commons.lang3.ArrayUtils;
...
Taken from org.apache.commons.lang.ArrayUtils#toMap JavaDoc

Create a Map mapping colors.

Map colorMap = MapUtils.toMap(new String[][] {{
{"RED", "#FF0000"},
{"GREEN", "#00FF00"},
{"BLUE", "#0000FF"}});

Each element of the array must be either a Map.Entry or an Array, containing at least two elements, where the first
element is used as key and the second as value.

Google Guava Collections framework

Utility class from Google Guava framework is named Maps:

import com.google.common.collect.Maps;
...
void howToCreateMapsMethod(Function<? super K,V> valueFunction, Iterable<K>
keys1,
Set<K> keys2,
SortedSet<K> keys3) {
ImmutableMap<K, V> map1 = toMap(keys1, valueFunction); // Immutable copy
Map<K, V> map2 = asMap(keys2, valueFunction); // Live Map view
SortedMap<K, V> map3 = toMap(keys3, valueFunction); // Live Map view
}
Version ≥ Java SE 8

INFOBYTE CAREER INSTITUTE 136

Using Stream,

Stream.of("xyz", "abc").collect(Collectors.toList());

or

Arrays.stream("xyz", "abc").collect(Collectors.toList());

Section 24.3: Declaring an ArrayList and adding objects

We can create an ArrayList (following the List interface):

List aListOfFruits = new ArrayList();

Version ≥ Java SE 5
List<String> aListOfFruits = new ArrayList<String>();
Version ≥ Java SE 7
List<String> aListOfFruits = new ArrayList<>();

Now, use the method add to add a String:

aListOfFruits.add("Melon");
aListOfFruits.add("Strawberry");

In the above example, the ArrayList will contain the String "Melon" at index 0 and the String "Strawberry" at index 1.

Also we can add multiple elements with addAll(Collection<? extends E> c) method

List<String> aListOfFruitsAndVeggies = new ArrayList<String>();

aListOfFruitsAndVeggies.add("Onion");
aListOfFruitsAndVeggies.addAll(aListOfFruits);

Now "Onion" is placed at 0 index in aListOfFruitsAndVeggies, "Melon" is at index 1 and "Strawberry" is at index 2.

Section 24.4: Iterating over Collections

Iterating over List
List<String> names = new ArrayList<>(Arrays.asList("Clementine", "Duran", "Mike"));
Version ≥ Java SE 8
names.forEach(System.out::println);

If we need parallelism use

names.parallelStream().forEach(System.out::println);
Version ≥ Java SE 5
for (String name : names) {
System.out.println(name);
}
Version < Java SE 5
for (int i = 0; i < names.size(); i++) {
System.out.println(names.get(i));
}
Version ≥ Java SE 1.2

INFOBYTE CAREER INSTITUTE 137

//Creates ListIterator which supports both forward as well as backward traversel ListIterator<String>
listIterator = names.listIterator();

//Iterates list in forward direction

while(listIterator.hasNext()){
System.out.println(listIterator.next());
}

//Iterates list in backward direction once reaches the last element from above iterator in forward direction

while(listIterator.hasPrevious()){
System.out.println(listIterator.previous());
}
Iterating over Set
Set<String> names = new HashSet<>(Arrays.asList("Clementine", "Duran", "Mike"));
Version ≥ Java SE 8
names.forEach(System.out::println);
Version ≥ Java SE 5
for (Iterator<String> iterator = names.iterator(); iterator.hasNext(); ) {
System.out.println(iterator.next());
}

for (String name : names) {

System.out.println(name);
}
Version < Java SE 5

Iterator iterator = names.iterator();

while (iterator.hasNext()) {
System.out.println(iterator.next());
}
Iterating over Map
Map<Integer, String> names = new HashMap<>();
names.put(1, "Clementine");
names.put(2, "Duran");
names.put(3, "Mike");
Version ≥ Java SE 8
names.forEach((key, value) -> System.out.println("Key: " + key + " Value: " + value));
Version ≥ Java SE 5
for (Map.Entry<Integer, String> entry : names.entrySet()) {
System.out.println(entry.getKey()); System.out.println(entry.getValue());

// Iterating over only keys

for (Integer key : names.keySet()) {
System.out.println(key);
}
// Iterating over only values
for (String value : names.values()) {
System.out.println(value);
}
Version < Java SE 5

Iterator entries = names.entrySet().iterator();

while (entries.hasNext()) {
Map.Entry entry = (Map.Entry) entries.next();
System.out.println(entry.getKey());
System.out.println(entry.getValue());

INFOBYTE CAREER INSTITUTE 138

}

Section 24.5: Immutable Empty Collections

Sometimes it is appropriate to use an immutable empty collection. The Collections class provides methods to get such
collections in an efficient way:

List<String> anEmptyList = Collections.emptyList();

Map<Integer, Date> anEmptyMap = Collections.emptyMap();
Set<Number> anEmptySet = Collections.emptySet();

These methods are generic and will automatically convert the returned collection to the type it is assigned to. That is, an
invocation of e.g. emptyList() can be assigned to any type of List and likewise for emptySet() and emptyMap().

The collections returned by these methods are immutable in that they will throw UnsupportedOperationException if you
attempt to call methods which would change their contents ( add, put, etc.). These collections are primarily useful as
substitutes for empty method results or other default values, instead of using null or creating objects with new.

Section 24.6: Sub Collections

List subList(int fromIndex, int toIndex)

Here fromIndex is inclusive and toIndex is exclusive.

List list = new ArrayList();

List list1 = list.subList(fromIndex,toIndex);

If the list doesn't exist in the give range, it throws IndexOutofBoundException.

What ever changes made on the list1 will impact the same changes in the list.This is called backed collections.
If the fromnIndex is greater than the toIndex (fromIndex > toIndex) it throws IllegalArgumentException.

Example:

List<String> list = new ArrayList<String>();

List<String> list = new ArrayList<String>();
list.add("Hello1");
list.add("Hello2");
System.out.println("Before Sublist "+list);
List<String> list2 = list.subList(0, 1);
list2.add("Hello3");
System.out.println("After sublist changes "+list);

Output:
Before Sublist [Hello1, Hello2]
After sublist changes [Hello1, Hello3, Hello2]

Set subSet(fromIndex,toIndex)

Here fromIndex is inclusive and toIndex is exclusive.

Set set = new TreeSet();

INFOBYTE CAREER INSTITUTE 139

Set set1 = set.subSet(fromIndex,toIndex);

The returned set will throw an IllegalArgumentException on an attempt to insert an element outside its range.

Map subMap(fromKey,toKey)

fromKey is inclusive and toKey is exclusive

Map map = new TreeMap();

Map map1 = map.get(fromKey,toKey);

If fromKey is greater than toKey or if this map itself has a restricted range, and fromKey or toKey lies outside the
bounds of the range then it throws IllegalArgumentException.

All the collections support backed collections means changes made on the sub collection will have same change on the
main collection.

Section 24.7: Unmodifiable Collection

Sometimes it's not a good practice expose an internal collection since it can lead to a malicious code vulnerability due to
it's mutable characteristic. In order to provide "read-only" collections java provides its unmodifiable versions.

An unmodifiable collection is often a copy of a modifiable collection which guarantees that the collection itself
cannot be altered. Attempts to modify it will result in an UnsupportedOperationException exception.

It is important to notice that objects which are present inside the collection can still be altered.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MyPojoClass {

private List<Integer> intList = new ArrayList<>();

public void addValueToIntList(Integer value){

intList.add(value);
}

public List<Integer> getIntList() {

return Collections.unmodifiableList(intList);
}
}

The following attempt to modify an unmodifiable collection will throw an exception:

import java.util.List;

public class App {

public static void main(String[] args) {

MyPojoClass pojo = new MyPojoClass();
pojo.addValueToIntList(42);

List<Integer> list = pojo.getIntList();

list.add(69);
}
}

INFOBYTE CAREER INSTITUTE 140

output:

Exception in thread "main" java.lang.UnsupportedOperationException

at java.util.Collections$UnmodifiableCollection.add(Collections.java:1055)
at App.main(App.java:12)

Section 24.8: Pitfall: concurrent modification exceptions

This exception occurs when a collection is modified while iterating over it using methods other than those provided by the
iterator object. For example, we have a list of hats and we want to remove all those that have ear flaps:

List<IHat> hats = new ArrayList<>();

hats.add(new Ushanka()); // that one has ear flaps
hats.add(new Fedora());
hats.add(new Sombrero());
for (IHat hat : hats) {
if (hat.hasEarFlaps()) {
hats.remove(hat);
}
}

If we run this code, ConcurrentModificationException will be raised since the code modifies the collection while
iterating it. The same exception may occur if one of the multiple threads working with the same list is trying to modify the
collection while others iterate over it. Concurrent modification of collections in multiple threads is a natural thing, but
should be treated with usual tools from the concurrent programming toolbox such as synchronization locks, special
collections adopted for concurrent modification, modifying the cloned collection from initial etc.

Section 24.9: Removing matching items from Lists

using Iterator
Above I noticed an example to remove items from a List within a Loop and I thought of another example that may come
in handy this time using the Iterator interface.
This is a demonstration of a trick that might come in handy when dealing with duplicate items in lists that you want to get
rid of.

Note: This is only adding on to the Removing items from a List within a loop example:

So let's define our lists as usual

String[] names = {"James","Smith","Sonny","Huckle","Berry","Finn","Allan"}; List<String> nameList =

new ArrayList<>();

//Create a List from an Array

nameList.addAll(Arrays.asList(names));

String[] removeNames = {"Sonny","Huckle","Berry"};

List<String> removeNameList = new ArrayList<>();

//Create a List from an Array

removeNameList.addAll(Arrays.asList(removeNames));

The following method takes in two Collection objects and performs the magic of removing the elements in our
removeNameList that match with elements in nameList.

INFOBYTE CAREER INSTITUTE 141

 private static void removeNames(Collection<String> collection1, Collection<String> collection2) { //get Iterator.

Iterator<String> iterator = collection1.iterator();

//Loop while collection has items

while(iterator.hasNext()){
if (collection2.contains(iterator.next()))
iterator.remove(); //remove the current Name or Item
}
}

Calling the method and passing in the nameList and the removeNameListas follows
removeNames(nameList,removeNameList);
Will produce the following output:

Array List before removing names: James Smith Sonny Huckle Berry Finn Allan
Array List after removing names: James Smith Finn Allan

A simple neat use for Collections that may come in handy to remove repeating elements within lists.

Section 24.10: Join lists

Following ways can be used for joining lists without modifying source list(s).

First approach. Has more lines but easy to understand

List<String> newList = new ArrayList<String>();

newList.addAll(listOne);
newList.addAll(listTwo);

Second approach. Has one less line but less readable.

List<String> newList = new ArrayList<String>(listOne);

newList.addAll(listTwo);

Third approach. Requires third party Apache commons-collections library.

ListUtils.union(listOne,listTwo);
Version ≥ Java SE 8

Using Streams the same can be achieved by

List<String> newList = Stream.concat(listOne.stream(),

listTwo.stream()).collect(Collectors.toList());

References. Interface List

Section 24.11: Creating your own Iterable structure for use

with Iterator or for-each loop
To ensure that our collection can be iterated using iterator or for-each loop, we have to take care of following steps:

The stuff we want to iterate upon has to be Iterable and expose iterator().
Design a java.util.Iterator by overriding hasNext(), next() and remove().

INFOBYTE CAREER INSTITUTE 142

I have added a simple generic linked list implementation below that uses above entities to make the linked list
iterable.

package org.algorithms.linkedlist;

import java.util.Iterator;
import java.util.NoSuchElementException;

public class LinkedList<T> implements Iterable<T> {

Node<T> head, current;

private static class Node<T> {

T data;
Node<T> next;

Node(T data) {
this.data = data;
}
}

public LinkedList(T data) {

head = new Node<>(data);
}

public Iterator<T> iterator() {

return new LinkedListIterator();
}

private class LinkedListIterator implements Iterator<T> {

Node<T> node = head;

@Override
public boolean hasNext() {
return node != null;
}

@Override
public T next() {
if (!hasNext())
throw new NoSuchElementException();
Node<T> prevNode = node;
node = node.next;
return prevNode.data;
}

@Override
public void remove() {
throw new UnsupportedOperationException("Removal logic not implemented.");
}
}

public void add(T data) {

Node current = head;

INFOBYTE CAREER INSTITUTE 143

 while (current.next != null)
current = current.next;
current.next = new Node<>(data);
}

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

LinkedList<Integer> list = new LinkedList<>(1);

list.add(2);
list.add(4);
list.add(3);

//Test #1
System.out.println("using Iterator:");
Iterator<Integer> itr = list.iterator();
while (itr.hasNext()) {
Integer i = itr.next();
System.out.print(i + " ");
}

//Test #2
System.out.println("\n\nusing for-each:");
for (Integer data : list) {
System.out.print(data + " ");
}
}
}

Output

using Iterator:
1 2 4 3
using for-each:
1 2 4 3

This will run in Java 7+. You can make it run on Java 5 and Java 6 also by substituting:

LinkedList<Integer> list = new LinkedList<>(1);

with

LinkedList<Integer> list = new LinkedList<Integer>(1);

or just any other version by incorporating the compatible changes.

Section 24.12: Collections and Primitive Values

Collections in Java only work for objects. I.e. there is no Map<int, int> in Java. Instead, primitive values need to be boxed
into objects, as in Map<Integer, Integer>. Java auto-boxing will enable transparent use of these collections:

Map<Integer, Integer> map = new HashMap<>();

INFOBYTE CAREER INSTITUTE 144

map.put(1, 17); // Automatic boxing of int to Integer objects int a = map.get(1); //
Automatic unboxing.

Unfortunately, the overhead of this is substantial. A HashMap<Integer, Integer> will require about 72 bytes per entry (e.g.
on 64-bit JVM with compressed pointers, and assuming integers larger than 256, and assuming 50% load of the map).
Because the actual data is only 8 bytes, this yields a massive overhead. Furthermore, it requires two level of indirection
(Map -> Entry -> Value) it is unnecessarily slow.

There exist several libraries with optimized collections for primitive data types (that require only ~16 bytes per entry at
50% load, i.e. 4x less memory, and one level of indirection less), that can yield substantial performance benefits when
using large collections of primitive values in Java.

INFOBYTE CAREER INSTITUTE 145

Chapter 25: Lists
A list is an ordered collection of values. In Java, lists are part of the Java Collections Framework. Lists implement the
java.util.List interface, which extends java.util.Collection.

Section 25.1: Sorting a generic list

The Collections class offers two standard static methods to sort a list:

sort(List<T> list) applicable to lists where T extends Comparable<? super T>, and sort(List<T>
list, Comparator<? super T> c) applicable to lists of any type.

Applying the former requires amending the class of list elements being sorted, which is not always possible. It
might also be undesirable as although it provides the default sorting, other sorting orders may be required in
different circumstances, or sorting is just a one off task.

Consider we have a task of sorting objects that are instances of the following class:

public class User {

public final Long id;
public final String username;

public User(Long id, String username) {

this.id = id;
this.username = username;
}

@Override
public String toString() {
return String.format("%s:%d", username, id);
}
}

In order to use Collections.sort(List<User> list) we need to modify the User class to implement the Comparable
interface. For example

public class User implements Comparable<User> {

public final Long id;
public final String username;

public User(Long id, String username) {

this.id = id;
this.username = username;
}

@Override
public String toString() {
return String.format("%s:%d", username, id);
}

@Override
/** The natural ordering for 'User' objects is by the 'id' field. */ public int
compareTo(User o) {
return id.compareTo(o.id);
}
}

INFOBYTE CAREER INSTITUTE 146

(Aside: many standard Java classes such as String, Long, Integer implement the Comparable interface. This makes lists of
those elements sortable by default, and simplifies implementation of compare or compareTo in other classes.)

With the modification above, the we can easily sort a list of User objects based on the classes natural ordering. (In this
case, we have defined that to be ordering based on id values). For example:

List<User> users = Lists.newArrayList(

new User(33L, "A"),
new User(25L, "B"),
new User(28L, ""));
Collections.sort(users);

System.out.print(users);
// [B:25, C:28, A:33]

However, suppose that we wanted to sort User objects by name rather than by id. Alternatively, suppose that we had
not been able to change the class to make it implement Comparable.

This is where the sort method with the Comparator argument is useful:

Collections.sort(users, new Comparator<User>() {

@Override
/* Order two 'User' objects based on their names. */ public int
compare(User left, User right) {
return left.username.compareTo(right.username);
}
});
System.out.print(users);
[A:33, B:25, C:28]
Version ≥ Java SE 8

In Java 8 you can use a lambda instead of an anonymous class. The latter reduces to a one-liner:

Collections.sort(users, (l, r) -> l.username.compareTo(r.username));

Further, there Java 8 adds a default sort method on the List interface, which simplifies sorting even more.

users.sort((l, r) -> l.username.compareTo(r.username))

Section 25.2: Convert a list of integers to a list of strings

List<Integer> nums = Arrays.asList(1, 2, 3);
List<String> strings = nums.stream()
.map(Object::toString)
.collect(Collectors.toList());

That is:

Create a stream from the list

Map each element using Object::toString
Collect the String values into a List using Collectors.toList()

Section 25.3: Classes implementing List - Pros and Cons

The List interface is implemented by different classes. Each of them has its own way for implementing it with
different strategies and providing different pros and cons.

INFOBYTE CAREER INSTITUTE 147

Classes implementing List

These are all of the public classes in Java SE 8 that implement the java.util.List interface:

Abstract Classes:
AbstractList
AbstractSequentialList
Concrete Classes:
ArrayList
AttributeList
CopyOnWriteArrayList
LinkedList
RoleList
RoleUnresolvedList
Stack
Vector

Pros and Cons of each implementation in term of time complexity

ArrayList
public class ArrayList<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

ArrayList is a resizable-array implementation of the List interface. Storing the list into an array, ArrayList provides
methods (in addition to the methods implementing the List interface) for manipulating the size of the array.

Initialize ArrayList of Integer with size 100

List<Integer> myList = new ArrayList<Integer>(100); // Constructs an empty list with the specified initial capacity.

- PROS:

The size, isEmpty, get, set, iterator, and listIterator operations run in constant time. So getting and setting each
element of the List has the same time cost:

int e1 = myList.get(0); // \
int e2 = myList.get(10); // | => All the same constant cost => O(1)
myList.set(2,10); // /

- CONS:

Being implemented with an array (static structure) adding elements over the size of the array has a big cost due to the
fact that a new allocation need to be done for all the array. However, from documentation:

The add operation runs in amortized constant time, that is, adding n elements requires O(n) time

Removing an element requires O(n) time.

AttributeList

INFOBYTE CAREER INSTITUTE 148

On coming

CopyOnWriteArrayList

On coming

LinkedList
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, Serializable

LinkedList is implemented by a doubly-linked list a linked data structure that consists of a set of sequentially linked
records called nodes.

Iitialize LinkedList of Integer

List<Integer> myList = new LinkedList<Integer>(); // Constructs an empty list.

- PROS:

Adding or removing an element to the front of the list or to the end has constant time.

myList.add(10); // \
myList.add(0,2); // | => constant time => O(1)
myList.remove(); // /

CONS: From documentation:

Operations that index into the list will traverse the list from the beginning or the end, whichever is closer to the
specified index.

Operations such as:

myList.get(10); // \
myList.add(11,25); // | => worst case done in O(n/2)
myList.set(15,35); // /

RoleList

On coming

RoleUnresolvedList

On coming

Stack

On coming

INFOBYTE CAREER INSTITUTE 149

Vector

On coming

Section 25.4: Finding common elements between 2 lists

Suppose you have two lists: A and B, and you need to find the elements that exist in both lists.

You can do it by just invoking the method List.retainAll().

Example:

public static void main(String[] args) {

List<Integer> numbersA = new ArrayList<>();
List<Integer> numbersB = new ArrayList<>();
numbersA.addAll(Arrays.asList(new Integer[] { 1, 3, 4, 7, 5, 2 }));
numbersB.addAll(Arrays.asList(new Integer[] { 13, 32, 533, 3, 4, 2 }));

System.out.println("A: " + numbersA);

System.out.println("B: " + numbersB);
List<Integer> numbersC = new ArrayList<>();
numbersC.addAll(numbersA);
numbersC.retainAll(numbersB);

System.out.println("List A : " + numbersA);

System.out.println("List B : " + numbersB);
System.out.println("Common elements between A and B: " + numbersC);

Section 25.5: In-place replacement of a List element

This example is about replacing a List element while ensuring that the replacement element is at the same
position as the element that is replaced.

This can be done using these methods:

set(int index, T type)

int indexOf(T type)

Consider an ArrayList containing the elements "Program starting!", "Hello world!" and "Goodbye world!"

List<String> strings = new ArrayList<String>();

strings.add("Program starting!");
strings.add("Hello world!");
strings.add("Goodbye world!");

If we know the index of the element we want to replace, we can simply use set as follows:

strings.set(1, "Hi world");

If we don't know the index, we can search for it first. For example:

int pos = strings.indexOf("Goodbye world!");

if (pos >= 0) {

INFOBYTE CAREER INSTITUTE 150

 strings.set(pos, "Goodbye cruel world!");
}

Notes:

The set operation will not cause a ConcurrentModificationException.

The set operation is fast ( O(1) ) for ArrayList but slow ( O(N) ) for a LinkedList.
An indexOf search on an ArrayList or LinkedList is slow ( O(N) ).

Section 25.6: Making a list unmodifiable

The Collections class provides a way to make a list unmodifiable:

List<String> ls = new ArrayList<String>();

List<String> unmodifiableList = Collections.unmodifiableList(ls);

If you want an unmodifiable list with one item you can use:

List<String> unmodifiableList = Collections.singletonList("Only string in the list");

Section 25.7: Moving objects around in the list

The Collections class allows for you to move objects around in the list using various methods (ls is the List):

Reversing a list:

Collections.reverse(ls);

Rotating positions of elements in a list

The rotate method requires an integer argument. This is how many spots to move it along the line by. An example of
this is below:

List<String> ls = new ArrayList<String>();

ls.add(" how");
ls.add(" are");
ls.add(" you?");
ls.add("hello,");
Collections.rotate(ls, 1);

for(String line : ls) System.out.print(line);

System.out.println();

This will print "hello, how are you?"

Shuffling elements around in a list

Using the same list above, we can shuffle the elements in a list:

Collections.shuffle(ls);

We can also give it a java.util.Random object that it uses to randomly place objects in spots:

Random random = new Random(12);

Collections.shuffle(ls, random);

INFOBYTE CAREER INSTITUTE 151

Section 25.8: Creating, Adding and Removing element from
an ArrayList
ArrayList is one of the inbuilt data structures in Java. It is a dynamic array (where the size of the data structure not needed
to be declared first) for storing elements (Objects).

It extends AbstractList class and implements List interface. An ArrayList can contain duplicate elements where it maintains
insertion order. It should be noted that the class ArrayList is non-synchronized, so care should be taken when handling
concurrency with ArrayList. ArrayList allows random access because array works at the index basis. Manipulation is slow
in ArrayList because of shifting that often occurs when an element is removed from the array list.

An ArrayList can be created as follows:

List<T> myArrayList = new ArrayList<>();

Where T ( Generics ) is the type that will be stored inside ArrayList.

The type of the ArrayList can be any Object. The type can't be a primitive type (use their wrapper classes instead).

To add an element to the ArrayList, use add() method:

myArrayList.add(element);

Or to add item to a certain index:

myArrayList.add(index, element); //index of the element should be an int (starting from 0)

To remove an item from the ArrayList, use the remove() method:

myArrayList.remove(element);

Or to remove an item from a certain index:

myArrayList.remove(index); //index of the element should be an int (starting from 0)

Section 25.9: Creating a List

Giving your list a type

To create a list you need a type (any class, e.g. String). This is the type of your List. The List will only store objects of the
specified type. For example:

List<String> strings;

Can store "string1", "hello world!", "goodbye", etc, but it can't store 9.2, however:

List<Double> doubles;

Can store 9.2, but not "hello world!".

Initialising your list

If you try to add something to the lists above you will get a NullPointerException, because strings and doubles

INFOBYTE CAREER INSTITUTE 152

both equal null!

There are two ways to initialise a list:

Option 1: Use a class that implements List

List is an interface, which means that does not have a constructor, rather methods that a class must override.
ArrayList is the most commonly used List, though LinkedList is also common. So we initialise our list like this:

List<String> strings = new ArrayList<String>();

or

List<String> strings = new LinkedList<String>();

Version ≥ Java SE 7

Starting from Java SE 7, you can use a diamond operator:

List<String> strings = new ArrayList<>();

or

List<String> strings = new LinkedList<>();

Option 2: Use the Collections class

The Collections class provides two useful methods for creating Lists without a List variable:

emptyList(): returns an empty list.

singletonList(T): creates a list of type T and adds the element specified.

And a method which uses an existing List to fill data in:

addAll(L, T...): adds all the specified elements to the list passed as the first parameter.

Examples:

import java.util.List; import java.util.Collections; List<Integer> l = Collections.emptyList(); List<Integer> l1 =

Collections.singletonList(42); Collections.addAll(l1, 1, 2, 3);

Section 25.10: Positional Access Operations

The List API has eight methods for positional access operations:

add(T type)
add(int index, T type)
remove(Object o)
remove(int index)
get(int index)
set(int index, E element)
int indexOf(Object o)
int lastIndexOf(Object o)

So, if we have a List:

INFOBYTE CAREER INSTITUTE 153

 List<String> strings = new ArrayList<String>();

And we wanted to add the strings "Hello world!" and "Goodbye world!" to it, we would do it as such:

strings.add("Hello world!");
strings.add("Goodbye world!");

And our list would contain the two elements. Now lets say we wanted to add "Program starting!" at the front of the list.
We would do this like this:

strings.add(0, "Program starting!");

NOTE: The first element is 0.

Now, if we wanted to remove the "Goodbye world!" line, we could do it like this:

strings.remove("Goodbye world!");

And if we wanted to remove the first line (which in this case would be "Program starting!", we could do it like this:

strings.remove(0);

Note:

Adding and removing list elements modify the list, and this can lead to a ConcurrentModificationException if the list is
being iterated concurrently.

Adding and removing elements can be O(1) or O(N) depending on the list class, the method used, and
whether you are adding / removing an element at the start, the end, or in the middle of the list.

In order to retrieve an element of the list at a specified position you can use the E get(int index); method of the
List API. For example:

strings.get(0);

will return the first element of the list.

You can replace any element at a specified position by using the set(int index, E element);. For example:

strings.set(0,"This is a replacement");

This will set the String "This is a replacement" as the first element of the list.

Note: The set method will overwrite the element at the position 0. It will not add the new String at the position 0 and
push the old one to the position 1.

The int indexOf(Object o); returns the position of the first occurrence of the object passed as argument. If there are no
occurrences of the object in the list then the -1 value is returned. In continuation of the previous example if you call:

strings.indexOf("This is a replacement")

the 0 is expected to be returned as we set the String "This is a replacement" in the position 0 of our list. In case where
there are more than one occurrence in the list when int indexOf(Object o); is called then as mentioned

INFOBYTE CAREER INSTITUTE 154

the index of the first occurrence will be returned. By calling the int lastIndexOf(Object o) you can retrieve the index of the
last occurrence in the list. So if we add another "This is a replacement":

strings.add("This is a replacement");
strings.lastIndexOf("This is a replacement");

This time the 1 will be returned and not the 0;

Section 25.11: Iterating over elements in a list

For the example, lets say that we have a List of type String that contains four elements: "hello, ", "how ", "are ",
"you?"

The best way to iterate over each element is by using a for-each loop:

public void printEachElement(List<String> list){

for(String s : list){
System.out.println(s);
}
}

Which would print:

hello,
how
are
you?

To print them all in the same line, you can use a StringBuilder:

public void printAsLine(List<String> list){

StringBuilder builder = new StringBuilder();
for(String s : list){
builder.append(s);
}
System.out.println(builder.toString());
}

Will print:

hello, how are you?

Alternatively, you can use element indexing ( as described in Accessing element at ith Index from ArrayList ) to
iterate a list. Warning: this approach is inefficient for linked lists.

Section 25.12: Removing elements from list B that are present

in the list A
Lets suppose you have 2 Lists A and B, and you want to remove from B all the elements that you have in A the
method in this case is

List.removeAll(Collection c);

#Example:

INFOBYTE CAREER INSTITUTE 155

 public static void main(String[] args) {
List<Integer> numbersA = new ArrayList<>();
List<Integer> numbersB = new ArrayList<>();
numbersA.addAll(Arrays.asList(new Integer[] { 1, 3, 4, 7, 5, 2 }));
numbersB.addAll(Arrays.asList(new Integer[] { 13, 32, 533, 3, 4, 2 })); System.out.println("A: " +
numbersA); System.out.println("B: " + numbersB);

numbersB.removeAll(numbersA);
System.out.println("B cleared: " + numbersB);
}

this will print

[1, 3, 4, 7, 5, 2]

[13, 32, 533, 3, 4, 2]

B cleared: [13, 32, 533]

INFOBYTE CAREER INSTITUTE 156

Chapter 26: Sets
Section 26.1: Initialization
A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction.

Set have its implementation in various classes like HashSet, TreeSet, LinkedHashSet.

For example:

HashSet:

Set<T> set = new HashSet<T>();

Here T can be String, Integer or any other object. HashSet allows for quick lookup of O(1) but does not sort the data
added to it and loses the insertion order of items.

TreeSet:

It stores data in a sorted manner sacrificing some speed for basic operations which take O(lg(n)). It does not
maintain the insertion order of items.

TreeSet<T> sortedSet = new TreeSet<T>();

LinkedHashSet:

It is a linked list implementation of HashSet Once can iterate over the items in the order they were added. Sorting is not
provided for its contents. O(1) basic operations are provided, however there is higher cost than HashSet in maintaining
the backing linked list.

LinkedHashSet<T> linkedhashset = new LinkedHashSet<T>();

Section 26.2: Basics of Set

What is a Set?

A set is a data structure which contains a set of elements with an important property that no two elements in the set
are equal.

Types of Set:

HashSet: A set backed by a hash table (actually a HashMap instance)

Linked HashSet: A Set backed by Hash table and linked list, with predictable iteration order
TreeSet: A NavigableSet implementation based on a TreeMap.

Creating a set

Set<Integer> set = new HashSet<Integer>(); // Creates an empty Set of Integers

Set<Integer> linkedHashSet = new LinkedHashSet<Integer>(); //Creates a empty Set of Integers, with predictable iteration order

Adding elements to a Set

INFOBYTE CAREER INSTITUTE 157

Elements can be added to a set using the add() method

set.add(12); // - Adds element 12 to the set

set.add(13); // - Adds element 13 to the set

Our set after executing this method:

set = [12,13]

Delete all the elements of a Set

set.clear(); //Removes all objects from the collection.

After this set will be:

set = []

Check whether an element is part of the Set

Existence of an element in the set can be checked using the contains() method

set.contains(0); //Returns true if a specified object is an element within the set.

Output: False

Check whether a Set is empty

isEmpty() method can be used to check whether a Set is empty.

set.isEmpty(); //Returns true if the set has no elements

Output: True

Remove an element from the Set

set.remove(0); // Removes first occurrence of a specified object from the collection

Check the Size of the Set

set.size(); //Returns the number of elements in the collection

Output: 0

Section 26.3: Types and Usage of Sets

Generally, sets are a type of collection which stores unique values. Uniqueness is determined by the equals() and
hashCode() methods.

Sorting is determined by the type of set.

HashSet - Random Sorting

Version ≥ Java SE 7
Set<String> set = new HashSet<> ();
set.add("Banana");

INFOBYTE CAREER INSTITUTE 158

set.add("Banana");
set.add("Apple");
set.add("Strawberry");

// Set Elements: ["Strawberry", "Banana", "Apple"]

LinkedHashSet - Insertion Order

Version ≥ Java SE 7
Set<String> set = new LinkedHashSet<> ();
set.add("Banana");
set.add("Banana");
set.add("Apple");
set.add("Strawberry");

// Set Elements: ["Banana", "Apple", "Strawberry"]

TreeSet - By compareTo() or Comparator

Version ≥ Java SE 7
Set<String> set = new TreeSet<> ();
set.add("Banana");
set.add("Banana");
set.add("Apple");
set.add("Strawberry");

Set Elements: ["Apple", "Banana", "Strawberry"]

Version ≥ Java SE 7
Set<String> set = new TreeSet<> ((string1, string2) -> string2.compareTo(string1));
set.add("Banana");
set.add("Banana");
set.add("Apple");
set.add("Strawberry");

// Set Elements: ["Strawberry", "Banana", "Apple"]

Section 26.4: Create a list from an existing Set

Using a new List

List<String> list = new ArrayList<String>(listOfElements);

Using List.addAll() method

Set<String> set = new HashSet<String>();

set.add("foo");
set.add("boo");

List<String> list = new ArrayList<String>();

list.addAll(set);

Using Java 8 Steam API

List<String> list = set.stream().collect(Collectors.toList());

Section 26.5: Eliminating duplicates using Set

Suppose you have a collection elements, and you want to create another collection containing the same elements but
with all duplicates eliminated:

INFOBYTE CAREER INSTITUTE 159

Collection<Type> noDuplicates = new HashSet<Type>(elements);

Example:

List<String> names = new ArrayList<>(

Arrays.asList("John", "Marco", "Jenny", "Emily", "Jenny", "Emily", "John")); Set<String> noDuplicates =
new HashSet<>(names); System.out.println("noDuplicates = " + noDuplicates);

Output:

noDuplicates = [Marco, Emily, John, Jenny]

Section 26.6: Declaring a HashSet with values

You can create a new class that inherits from HashSet:

Set<String> h = new HashSet<String>() {{

add("a");
add("b");
}};

One line solution:

Set<String> h = new HashSet<String>(Arrays.asList("a", "b"));

Using guava:

Sets.newHashSet("a", "b", "c")

Using Streams:

Set<String> set3 = Stream.of("a", "b", "c").collect(toSet());

INFOBYTE CAREER INSTITUTE 160

Chapter 27: List vs Set
What are differences between List and Set collection at the top level and How to choose when to use List in java and
when to use Set in Java

Section 27.1: List vs Set

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class SetAndListExample
{
public static void main( String[] args )
{
System.out.println("List example .....");
List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("1");
for (String temp : list){
System.out.println(temp);
}

System.out.println("Set example .....");

Set<String> set = new HashSet<String>();
set.add("1");
set.add("2");
set.add("3");
set.add("4");
set.add("1");
set.add("2");
set.add("5");

for (String temp : set){

System.out.println(temp);
}
}

Output List example ..... 1 2 3 4 1 Set example ..... 3 2 10 5 4

INFOBYTE CAREER INSTITUTE 161

Chapter 28: Maps
The java.util.Map interface represents a mapping between keys and their values. A map cannot contain duplicate
keys; and each key can map to at most one value.

Since Map is an interface, then you need to instantiate a concrete implementation of that interface in order to use it; there
are several Map implementations, and mostly used are the java.util.HashMap and java.util.TreeMap

Section 28.1: Iterating Map Entries E ciently

This section provides code and benchmarks for ten unique example implementations which iterate over the entries of a
Map<Integer, Integer> and generate the sum of the Integer values. All of the examples have an algorithmic complexity of
Θ(n), however, the benchmarks are still useful for providing insight on which implementations are more efficient in a "real
world" environment.

1. Implementation using Iterator with Map.Entry

Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator(); while (it.hasNext()) {

Map.Entry<Integer, Integer> pair = it.next();

sum += pair.getKey() + pair.getValue();
}

2. Implementation using for with Map.Entry

for (Map.Entry<Integer, Integer> pair : map.entrySet()) { sum +=

pair.getKey() + pair.getValue();
}

3. Implementation using Map.forEach (Java 8+)

map.forEach((k, v) -> sum[0] += k + v);

4. Implementation using Map.keySet with for

for (Integer key : map.keySet()) {

sum += key + map.get(key);
}

5. Implementation using Map.keySet with Iterator

Iterator<Integer> it = map.keySet().iterator();
while (it.hasNext()) {
Integer key = it.next();
sum += key + map.get(key);
}

6. Implementation using for with Iterator and Map.Entry

for (Iterator<Map.Entry<Integer, Integer>> entries =

map.entrySet().iterator(); entries.hasNext(); ) {
Map.Entry<Integer, Integer> entry = entries.next(); sum +=
entry.getKey() + entry.getValue();
}

7. Implementation using Stream.forEach (Java 8+)

INFOBYTE CAREER INSTITUTE 162

 map.entrySet().stream().forEach(e -> sum += e.getKey() + e.getValue());

8. Implementation using Stream.forEach with Stream.parallel (Java 8+)

map.entrySet()
.stream()
.parallel()
.forEach(e -> sum += e.getKey() + e.getValue());

9. Implementation using IterableMap from Apache Collections

MapIterator<Integer, Integer> mit = iterableMap.mapIterator(); while (mit.hasNext())

{
sum += mit.next() + it.getValue();
}

Implementation using MutableMap from Eclipse Collections

mutableMap.forEachKeyValue((key, value) -> { sum += key

+ value;
});

Performance Tests (Code available on Github)

Test Environment: Windows 8.1 64-bit, Intel i7-4790 3.60GHz, 16 GB

1. Average Performance of 10 Trials (100 elements) Best: 308±21 ns/op

Benchmark Score Error Units

test3_UsingForEachAndJava8 308 ± 21 ns/op
test10_UsingEclipseMutableMap 309 ± 9 ns/op
test1_UsingWhileAndMapEntry 380 ± 14 ns/op
test6_UsingForAndIterator 387 ± 16 ns/op
test2_UsingForEachAndMapEntry 391 ± 23 ns/op
test7_UsingJava8StreamAPI 510 ± 14 ns/op
test9_UsingApacheIterableMap 524 ± 8 ns/op
test4_UsingKeySetAndForEach 816 ± 26 ns/op
test5_UsingKeySetAndIterator 863 ± 25 ns/op
test8_UsingJava8StreamAPIParallel 5552 ± 185 ns/op

2. Average Performance of 10 Trials (10000 elements) Best: 37.606±0.790 μs/op

Benchmark Score Error Units

test10_UsingEclipseMutableMap 37606 ± 790 ns/op
test3_UsingForEachAndJava8 50368 ± 887 ns/op
test6_UsingForAndIterator 50332 ± 507 ns/op
test2_UsingForEachAndMapEntry 51406 ± 1032 ns/op
test1_UsingWhileAndMapEntry 52538 ± 2431 ns/op
test7_UsingJava8StreamAPI 54464 ± 712 ns/op
test4_UsingKeySetAndForEach 79016 ± 25345 ns/op
test5_UsingKeySetAndIterator 91105 ± 10220 ns/op
test8_UsingJava8StreamAPIParallel 112511 ± 365 ns/op
test9_UsingApacheIterableMap 125714 ± 1935 ns/op

3. Average Performance of 10 Trials (100000 elements) Best: 1184.767±332.968 μs/op

Benchmark Score Error Units

INFOBYTE CAREER INSTITUTE 163

 test1_UsingWhileAndMapEntry 1184.767 ± 332.968 μs/op
test10_UsingEclipseMutableMap 1191.735 ± 304.273 μs/op
test2_UsingForEachAndMapEntry 1205.815 ± 366.043 μs/op
test6_UsingForAndIterator 1206.873 ± 367.272 μs/op
test8_UsingJava8StreamAPIParallel 1485.895 ± 233.143 μs/op
test5_UsingKeySetAndIterator 1540.281 ± 357.497 μs/op
test4_UsingKeySetAndForEach 1593.342 ± 294.417 μs/op
test3_UsingForEachAndJava8 1666.296 ± 126.443 μs/op
test7_UsingJava8StreamAPI 1706.676 ± 436.867 μs/op
test9_UsingApacheIterableMap 3289.866 ± 1445.564 μs/op

4. A Comparison of Performance Variations Respective to Map Size

x: Size of Map
f(x): Benchmark Score (μs/op)

100 600 1100 1600 2100

---------------------------------------------------
10 | 0.333 1.631 2.752 5.937 8.024
3 | 0.309 1.971 4.147 8.147 10.473
6 | 0.372 2.190 4.470 8.322 10.531
1 | 0.405 2.237 4.616 8.645 10.707
Tests 2 | 0.376 2.267 4.809 8.403 10.910
f(x) 7 | 0.473 2.448 5.668 9.790 12.125
9 | 0.565 2.830 5.952 13.22 16.965
4 | 0.808 5.012 8.813 13.939 17.407
5 | 0.81 5.104 8.533 14.064 17.422
8 | 5.173 12.499 17.351 24.671 30.403

Section 28.2: Usage of HashMap

HashMap is an implementation of the Map interface that provides a Data Structure to store data in Key-Value pairs.

1. Declaring HashMap

Map<KeyType, ValueType> myMap = new HashMap<KeyType, ValueType>();

INFOBYTE CAREER INSTITUTE 164

KeyType and ValueType must be valid types in Java, such as - String, Integer, Float or any custom class like
Employee, Student etc..

For Example : Map<String,Integer> myMap = new HashMap<String,Integer>();

2. Putting values in HashMap.

To put a value in the HashMap, we have to call put method on the HashMap object by passing the Key and the
Value as parameters.

myMap.put("key1", 1);
myMap.put("key2", 2);

If you call the put method with the Key that already exists in the Map, the method will override its value and return the
old value.

3. Getting values from HashMap.

For getting the value from a HashMap you have to call the get method, by passing the Key as a parameter.

myMap.get("key1"); //return 1 (class Integer)

If you pass a key that does not exists in the HashMap, this method will return null

4. Check whether the Key is in the Map or not.

myMap.containsKey(varKey);

5. Check whether the Value is in the Map or not.

myMap.containsValue(varValue);

The above methods will return a boolean value true or false if key, value exists in the Map or not.

Section 28.3: Using Default Methods of Map from Java 8

Examples of using Default Methods introduced in Java 8 in Map interface

Using getOrDefault

Returns the value mapped to the key, or if the key is not present, returns the default value

Map<Integer, String> map = new HashMap<>();

map.put(1, "First element");
map.get(1); // => First element
map.get(2); // => null
map.getOrDefault(2, "Default element"); // => Default element

Using forEach

Allows to perform the operation specified in the 'action' on each Map Entry

Map<Integer, String> map = new HashMap<Integer, String>();

map.put(1, "one");
map.put(2, "two");
map.put(3, "three");

INFOBYTE CAREER INSTITUTE 165

 map.forEach((key, value) -> System.out.println("Key: "+key+ " :: Value: "+value));

Key: 1 :: Value: one

Key: 2 :: Value: two
Key: 3 :: Value: three

Using replaceAll

Will replace with new-value only if key is present

Map<String, Integer> map = new HashMap<String, Integer>();

map.put("john", 20);
map.put("paul", 30);
map.put("peter", 40);
map.replaceAll((key,value)->value+10); //{john=30, paul=40, peter=50}

Using putIfAbsent

Key-Value pair is added to the map, if the key is not present or mapped to null

Map<String, Integer> map = new HashMap<String, Integer>();

map.put("john", 20);
map.put("paul", 30);
map.put("peter", 40);
map.putIfAbsent("kelly", 50); //{john=20, paul=30, peter=40, kelly=50}

Using remove

Removes the key only if its associated with the given value

Map<String, Integer> map = new HashMap<String, Integer>();

map.put("john", 20);
map.put("paul", 30);
map.put("peter", 40);
map.remove("peter",40); //{john=30, paul=40}

Using replace

If the key is present then the value is replaced by new-value. If the key is not present, does nothing.

Map<String, Integer> map = new HashMap<String, Integer>();

map.put("john", 20);
map.put("paul", 30);
map.put("peter", 40);
map.replace("peter",50); //{john=20, paul=30, peter=50}
map.replace("jack",60); //{john=20, paul=30, peter=50}

Using computeIfAbsent

This method adds an entry in the Map. the key is specified in the function and the value is the result of the
application of the mapping function

Map<String, Integer> map = new HashMap<String, Integer>();

map.put("john", 20);
map.put("paul", 30);
map.put("peter", 40);

INFOBYTE CAREER INSTITUTE 166

 map.computeIfAbsent("kelly", k->map.get("john")+10); //{john=20, paul=30, peter=40, kelly=30}
map.computeIfAbsent("peter", k->map.get("john")+10); //{john=20, paul=30, peter=40, kelly=30}
//peter already present

Using computeIfPresent

This method adds an entry or modifies an existing entry in the Map. Does nothing if an entry with that key is not
present

Map<String, Integer> map = new HashMap<String, Integer>();

map.put("john", 20);
map.put("paul", 30);
map.put("peter", 40);
map.computeIfPresent("kelly", (k,v)->v+10); //{john=20, paul=30, peter=40} //kelly not present map.computeIfPresent("peter",
(k,v)->v+10); //{john=20, paul=30, peter=50} // peter present, so
increase the value

Using compute

This method replaces the value of a key by the newly computed value

Map<String, Integer> map = new HashMap<String, Integer>();

map.put("john", 20);
map.put("paul", 30);
map.put("peter", 40);
map.compute("peter", (k,v)->v+50); //{john=20, paul=30, peter=90} //Increase the value

10. Using merge

Adds the key-value pair to the map, if key is not present or value for the key is null Replaces the value with the
newly computed value, if the key is present Key is removed from the map , if new value computed is null

Map<String, Integer> map = new HashMap<String, Integer>();

map.put("john", 20);
map.put("paul", 30);
map.put("peter", 40);

//Adds the key-value pair to the map, if key is not present or value for the key is null
map.merge("kelly", 50 , (k,v)->map.get("john")+10); // {john=20, paul=30, peter=40, kelly=50}

//Replaces the value with the newly computed value, if the key is present
map.merge("peter", 50 , (k,v)->map.get("john")+10); //{john=20, paul=30, peter=30, kelly=50}

//Key is removed from the map , if new value computed is null

map.merge("peter", 30 , (k,v)->map.get("nancy")); //{john=20, paul=30, kelly=50}

Section 28.4: Iterating through the contents of a Map

Maps provide methods which let you access the keys, values, or key-value pairs of the map as collections. You can
iterate through these collections. Given the following map for example:

Map<String, Integer> repMap = new HashMap<>();

repMap.put("Jon Skeet", 927_654);
repMap.put("BalusC", 708_826);
repMap.put("Darin Dimitrov", 715_567);

Iterating through map keys:

INFOBYTE CAREER INSTITUTE 167

for (String key : repMap.keySet()) {
System.out.println(key);
}

Prints:

Darin Dimitrov
Jon Skeet
BalusC

keySet() provides the keys of the map as a Set. Set is used as the keys cannot contain duplicate values. Iterating through
the set yields each key in turn. HashMaps are not ordered, so in this example the keys may be returned in any order.

Iterating through map values:

for (Integer value : repMap.values()) {

System.out.println(value);
}

Prints:

715567
927654
708826

values() returns the values of the map as a Collection. Iterating through the collection yields each value in turn.
Again, the values may be returned in any order.

Iterating through keys and values together

for (Map.Entry<String, Integer> entry : repMap.entrySet()) {

System.out.printf("%s = %d\n", entry.getKey(), entry.getValue());
}

Prints:

Darin Dimitrov = 715567

Jon Skeet = 927654
BalusC = 708826

entrySet() returns a collection of Map.Entry objects. Map.Entry gives access to the key and value for each entry.

Section 28.5: Merging, combine and composing Maps

Use putAll to put every member of one map into another. Keys already present in the map will have their
corresponding values overwritten.

Map<String, Integer> numbers = new HashMap<>();

numbers.put("One", 1)

INFOBYTE CAREER INSTITUTE 168

numbers.put("Three", 3)
Map<String, Integer> other_numbers = new HashMap<>();
other_numbers.put("Two", 2) other_numbers.put("Three", 4)

numbers.putAll(other_numbers)

This yields the following mapping in numbers:

"One" -> 1
"Two" -> 2
"Three" -> 4 //old value 3 was overwritten by new value 4

If you want to combine values instead of overwriting them, you can use Map.merge, added in Java 8, which uses a
user-provided BiFunction to merge values for duplicate keys. merge operates on individual keys and values, so you'll
need to use a loop or Map.forEach. Here we concatenate strings for duplicate keys:

for (Map.Entry<String, Integer> e : other_numbers.entrySet())

numbers.merge(e.getKey(), e.getValue(), Integer::sum);
//or instead of the above loop
other_numbers.forEach((k, v) -> numbers.merge(k, v, Integer::sum));

If you want to enforce the constraint there are no duplicate keys, you can use a merge function that throws an
AssertionError:

mapA.forEach((k, v) ->
mapB.merge(k, v, (v1, v2) ->
{throw new AssertionError("duplicate values for key: "+k);}));

Composing Map<X,Y> and Map<Y,Z> to get Map<X,Z>

If you want to compose two mappings, you can do it as follows

Map<String, Integer> map1 = new HashMap<String, Integer>();

map1.put("key1", 1);
map1.put("key2", 2);
map1.put("key3", 3);

Map<Integer, Double> map2 = new HashMap<Integer, Double>();

map2.put(1, 1.0);
map2.put(2, 2.0);
map2.put(3, 3.0);

Map<String, Double> map3 = new new HashMap<String, Double>();

map1.forEach((key,value)->map3.put(key,map2.get(value)));

This yields the following mapping

"key1" -> 1.0

"key2" -> 2.0
"key3" -> 3.0

Section 28.6: Add multiple items

We can use V put(K key,V value):

INFOBYTE CAREER INSTITUTE 169

 Associates the specified value with the specified key in this map (optional operation). If the map
previously contained a mapping for the key, the old value is replaced by the specified value.

String currentVal;
Map<Integer, String> map = new TreeMap<>();
currentVal = map.put(1, "First element.");
System.out.println(currentVal);// Will print null
currentVal = map.put(2, "Second element.");
System.out.println(currentVal); // Will print null yet again
currentVal = map.put(2, "This will replace 'Second element'");
System.out.println(currentVal); // will print Second element.
System.out.println(map.size()); // Will print 2 as key having
// value 2 was replaced.

Map<Integer, String> map2 = new HashMap<>();

map2.put(2, "Element 2");
map2.put(3, "Element 3");

map.putAll(map2);

System.out.println(map.size());

Output:

To add many items you can use an inner classes like this:

Map<Integer, String> map = new HashMap<>() {{

This is now an anonymous inner class with an unnamed instance constructor put(5, "high");

put(4, "low");
put(1, "too slow");
}};

Keep in mind that creating an anonymous inner class is not always efficient and can lead to memory leaks so when
possible, use an initializer block instead:

static Map<Integer, String> map = new HashMap<>();

static {
Now no inner classes are created so we can avoid memory leaks put(5, "high");

put(4, "low");
put(1, "too slow");
}

The example above makes the map static. It can also be used in a non-static context by removing all occurrences of
static.

In addition to that most implementations support putAll, which can add all entries in one map to another like this:

another.putAll(one);

INFOBYTE CAREER INSTITUTE 170

Section 28.7: Creating and Initializing Maps
Introduction

Maps stores key/value pairs, where each key has an associated value. Given a particular key, the map can look up the
associated value very quickly.

Maps, also known as associate array, is an object that stores the data in form of keys and values. In Java, maps are
represented using Map interface which is not an extension of the collection interface.

Way 1:

/*J2SE < 5.0*/

Map map = new HashMap();
map.put("name", "A");
map.put("address", "Malviya-Nagar");
map.put("city", "Jaipur");
System.out.println(map);

Way 2:

/*J2SE 5.0+ style (use of generics):*/

Map<String, Object> map = new HashMap<>();
map.put("name", "A");
map.put("address", "Malviya-Nagar");
map.put("city", "Jaipur");
System.out.println(map);

Way 3:

Map<String, Object> map = new HashMap<String, Object>(){{ put("name",

"A");
put("address", "Malviya-Nagar");
put("city", "Jaipur");
}};
System.out.println(map);

Way 4:

Map<String, Object> map = new TreeMap<String, Object>();

map.put("name", "A");
map.put("address", "Malviya-Nagar");
map.put("city", "Jaipur");
System.out.println(map);

Way 5:

//Java 8
final Map<String, String> map =
Arrays.stream(new String[][] {
{ "name", "A" },
{ "address", "Malviya-Nagar" }, { "city",
"jaipur" },
}).collect(Collectors.toMap(m -> m[0], m -> m[1]));
System.out.println(map);

INFOBYTE CAREER INSTITUTE 171

 Way 6:

//This way for initial a map in outside the function final static
Map<String, String> map;
static
{
map = new HashMap<String, String>();
map.put("a", "b");
map.put("c", "d");
}

Way 7: Creating an immutable single key-value map.

//Immutable single key-value map

Map<String, String> singletonMap = Collections.singletonMap("key", "value");

Please note, that it is impossible to modify such map.

Any attemts to modify the map will result in throwing the UnsupportedOperationException.

//Immutable single key-value pair

Map<String, String> singletonMap = Collections.singletonMap("key", "value"); singletonMap.put("newKey",
"newValue"); //will throw UnsupportedOperationException singletonMap.putAll(new HashMap<>()); //will
throw UnsupportedOperationException singletonMap.remove("key"); //will throw
UnsupportedOperationException singletonMap.replace("key", "value", "newValue"); //will throw

UnsupportedOperationException
//and etc

Section 28.8: Check if key exists

Map<String, String> num = new HashMap<>();
num.put("one", "first");

if (num.containsKey("one")) {
System.out.println(num.get("one")); // => first
}
Maps can contain null values

For maps, one has to be carrefull not to confuse "containing a key" with "having a value". For example, HashMaps can
contain null which means the following is perfectly normal behavior :

Map<String, String> map = new HashMap<>();

map.put("one", null);
if (map.containsKey("one")) {
System.out.println("This prints !"); // This line is reached
}
if (map.get("one") != null) {
System.out.println("This is never reached !"); // This line is never reached
}

More formally, there is no guarantee that map.contains(key) <=> map.get(key)!=null

Section 28.9: Add an element

1. Addition

INFOBYTE CAREER INSTITUTE 172

Map<Integer, String> map = new HashMap<>();
map.put(1, "First element.");
System.out.println(map.get(1));

Output: First element.

2. Override

Map<Integer, String> map = new HashMap<>();

map.put(1, "First element.");
map.put(1, "New element.");
System.out.println(map.get(1));

Output: New element.

HashMap is used as an example. Other implementations that implement the Map interface may be used as well.

Section 28.10: Clear the map

Map<Integer, String> map = new HashMap<>();

map.put(1, "First element.");

map.put(2, "Second element.");
map.put(3, "Third element.");

map.clear();

System.out.println(map.size()); // => 0

Section 28.11: Use custom object as key

Before using your own object as key you must override hashCode() and equals() method of your object.

In simple case you would have something like:

class MyKey {
private String name;
MyKey(String name) {
this.name = name;
}

@Override
public boolean equals(Object obj) {
if(obj instanceof MyKey) {
return this.name.equals(((MyKey)obj).name);
}
return false;
}

@Override
public int hashCode() {
return this.name.hashCode();
}
}

hashCode will decide which hash bucket the key belongs to and equals will decide which object inside that hash
bucket.

INFOBYTE CAREER INSTITUTE 173

Without these method, the reference of your object will be used for above comparison which will not work unless you
use the same object reference every time.

INFOBYTE CAREER INSTITUTE 174

Chapter 29: LinkedHashMap
LinkedHashMap class is Hash table and Linked list implementation of the Map interface, with predictable iteration
order. It inherits HashMap class and implements the Map interface.

The important points about Java LinkedHashMap class are: A LinkedHashMap contains values based on the key. It
contains only unique elements. It may have one null key and multiple null values. It is same as HashMap instead
maintains insertion order.

Section 29.1: Java LinkedHashMap class

Key Points:

Is Hash table and Linked list implementation of the Map interface, with predictable iteration order.

inherits HashMap class and implements the Map interface.

contains values based on the key.

only unique elements.

may have one null key and multiple null values.

same as HashMap instead maintains insertion order.

Methods:

void clear().
boolean containsKey(Object key).
Object get(Object key).
protected boolean removeEldestEntry(Map.Entry eldest)

Example:

public static void main(String arg[])

{
LinkedHashMap<String, String> lhm = new LinkedHashMap<String, String>();
lhm.put("Ramesh", "Intermediate");
lhm.put("Shiva", "B-Tech");
lhm.put("Santosh", "B-Com");
lhm.put("Asha", "Msc");
lhm.put("Raghu", "M-Tech");

Set set = lhm.entrySet();

Iterator i = set.iterator();
while (i.hasNext()) {
Map.Entry me = (Map.Entry) i.next();
System.out.println(me.getKey() + " : " + me.getValue());
}

System.out.println("The Key Contains : " + lhm.containsKey("Shiva"));

System.out.println("The value to the corresponding to key : " + lhm.get("Asha"));
}

INFOBYTE CAREER INSTITUTE 175

Chapter 30: WeakHashMap
Concepts of weak Hashmap

Section 30.1: Concepts of WeakHashmap

Key Points:

Implementation of Map.
stores only weak references to its keys.

Weak References : The objects that are referenced only by weak references are garbage collected eagerly; the GC
won’t wait until it needs memory in that case.

Difference between Hashmap and WeakHashMap:

If the Java memory manager no longer has a strong reference to the object specified as a key, then the entry in the map
will be removed in WeakHashMap.

Example:

public class WeakHashMapTest {

public static void main(String[] args) {
Map hashMap= new HashMap();

Map weakHashMap = new WeakHashMap();

String keyHashMap = new String("keyHashMap");

String keyWeakHashMap = new String("keyWeakHashMap");

hashMap.put(keyHashMap, "Ankita");
weakHashMap.put(keyWeakHashMap, "Atul");
System.gc();
System.out.println("Before: hash map value:"+hashMap.get("keyHashMap")+" and weak hash map
value:"+weakHashMap.get("keyWeakHashMap"));

keyHashMap = null;
keyWeakHashMap = null;

System.gc();

System.out.println("After: hash map value:"+hashMap.get("keyHashMap")+" and weak hash map

value:"+weakHashMap.get("keyWeakHashMap"));
}

Size differences (HashMap vs WeakHashMap):

Calling size() method on HashMap object will return the same number of key-value pairs. size will decrease only if
remove() method is called explicitly on the HashMap object.

Because the garbage collector may discard keys at anytime, a WeakHashMap may behave as though an unknown
thread is silently removing entries. So it is possible for the size method to return smaller values over time.So, in
WeakHashMap size decrease happens automatically.

INFOBYTE CAREER INSTITUTE 176

Chapter 31: SortedMap
Introduction to sorted Map.

Section 31.1: Introduction to sorted Map

Keypoint:

SortedMap interface extends Map.

entries are maintained in an ascending key order.

Methods of sorted Map :

Comparator comparator( ).
Object firstKey( ).
SortedMap headMap(Object end).
Object lastKey( ).
SortedMap subMap(Object start, Object end).
SortedMap tailMap(Object start).

Example

public static void main(String args[]) {

Create a hash map TreeMap tm
= new TreeMap();

Put elements to the map

tm.put("Zara", new Double(3434.34));
tm.put("Mahnaz", new Double(123.22));
tm.put("Ayan", new Double(1378.00));
tm.put("Daisy", new Double(99.22));
tm.put("Qadir", new Double(-19.08));

Get a set of the entries Set set

= tm.entrySet();

Get an iterator
Iterator i = set.iterator();

Display elements
while(i.hasNext()) {
Map.Entry me = (Map.Entry)i.next();
System.out.print(me.getKey() + ": ");
System.out.println(me.getValue());
}
System.out.println();

Deposit 1000 into Zara's account

double balance = ((Double)tm.get("Zara")).doubleValue();
tm.put("Zara", new Double(balance + 1000));
System.out.println("Zara's new balance: " + tm.get("Zara"));
}

INFOBYTE CAREER INSTITUTE 177

Chapter 32: TreeMap and TreeSet
TreeMap and TreeSet are basic Java collections added in Java 1.2. TreeMap is a mutable, ordered, Map
implementation. Similarly, TreeSet is a mutable, ordered Set implementation.

TreeMap is implemented as a Red-Black tree, which provides O(log n) access times. TreeSet is implemented using a
TreeMap with dummy values.

Both collections are not thread-safe.

Section 32.1: TreeMap of a simple Java type

First, we create an empty map, and insert some elements into it:

Version ≥ Java SE 7
TreeMap<Integer, String> treeMap = new TreeMap<>();
Version < Java SE 7
TreeMap<Integer, String> treeMap = new TreeMap<Integer, String>();

treeMap.put(10, "ten");
treeMap.put(4, "four");
treeMap.put(1, "one");
treeSet.put(12, "twelve");

Once we have a few elements in the map, we can perform some operations:

System.out.println(treeMap.firstEntry()); // Prints 1=one

System.out.println(treeMap.lastEntry()); // Prints 12=twelve
System.out.println(treeMap.size()); // Prints 4, since there are 4 elemens in the map
System.out.println(treeMap.get(12)); // Prints twelve
System.out.println(treeMap.get(15)); // Prints null, since the key is not found in the map

We can also iterate over the map elements using either an Iterator, or a foreach loop. Note that the entries are
printed according to their natural ordering, not the insertion order:

Version ≥ Java SE 7
for (Entry<Integer, String> entry : treeMap.entrySet()) {
System.out.print(entry + " "); //prints 1=one 4=four 10=ten 12=twelve
}

Iterator<Entry<Integer, String>> iter = treeMap.entrySet().iterator(); while (iter.hasNext()) {

System.out.print(iter.next() + " "); //prints 1=one 4=four 10=ten 12=twelve

}

Section 32.2: TreeSet of a simple Java Type

First, we create an empty set, and insert some elements into it:

Version ≥ Java SE 7
TreeSet<Integer> treeSet = new TreeSet<>();
Version < Java SE 7
TreeSet<Integer> treeSet = new TreeSet<Integer>();

treeSet.add(10);
treeSet.add(4);
treeSet.add(1);

INFOBYTE CAREER INSTITUTE 178

treeSet.add(12);

Once we have a few elements in the set, we can perform some operations:

System.out.println(treeSet.first()); // Prints 1
System.out.println(treeSet.last()); // Prints 12
System.out.println(treeSet.size()); // Prints 4, since there are 4 elemens in the set
System.out.println(treeSet.contains(12)); // Prints true
System.out.println(treeSet.contains(15)); // Prints false

We can also iterate over the map elements using either an Iterator, or a foreach loop. Note that the entries are
printed according to their natural ordering, not the insertion order:

Version ≥ Java SE 7
for (Integer i : treeSet) {
System.out.print(i + " "); //prints 1 4 10 12
}

Iterator<Integer> iter = treeSet.iterator();

while (iter.hasNext()) {
System.out.print(iter.next() + " "); //prints 1 4 10 12
}

Section 32.3: TreeMap/TreeSet of a custom Java type

Since TreeMaps and TreeSets maintain keys/elements according to their natural ordering. Therefor TreeMap keys and
TreeSet elements have to comparable to one another.

Say we have a custom Person class:

public class Person {

private int id;

private String firstName, lastName;
private Date birthday;

//... Constuctors, getters, setters and various methods

}

If we store it as-is in a TreeSet (or a Key in a TreeMap):

TreeSet<Person2> set = ...

set.add(new Person(1,"first","last",Date.from(Instant.now())));

Then we'd run into an Exception such as this one:

Exception in thread "main" java.lang.ClassCastException: Person cannot be cast to java.lang.Comparable

at java.util.TreeMap.compare(TreeMap.java:1294)
at java.util.TreeMap.put(TreeMap.java:538)
at java.util.TreeSet.add(TreeSet.java:255)

To fix that, let's assume that we want to order Person instances based on the order of their ids (private int id).
We could do it in one of two ways:

1. One solution is to modify Person so it would implement the Comparable interface:

INFOBYTE CAREER INSTITUTE 179

 public class Person implements Comparable<Person> { private
int id;
private String firstName, lastName;
private Date birthday;

//... Constuctors, getters, setters and various methods

@Override
public int compareTo(Person o) {
return Integer.compare(this.id, o.id); //Compare by id
}
}

2. Another solution is to provide the TreeSet with a Comparator:

Version ≥ Java SE 8
TreeSet<Person> treeSet = new TreeSet<>((personA, personB) -> Integer.compare(personA.getId(), personB.getId()));

TreeSet<Person> treeSet = new TreeSet<>(new Comparator<Person>(){ @Override

public int compare(Person personA, Person personB) {

return Integer.compare(personA.getId(), personB.getId());
}
});

However, there are two caveats to both approaches:

It's very important not to modify any fields used for ordering once an instance has been inserted into a
TreeSet/TreeMap. In the above example, if we change the id of a person that's already inserted into the
collection, we might run into unexpected behavior.

It's important to implement the comparison properly and consistently. As per the Javadoc:

The implementor must ensure sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) for all x and y. (This implies that
x.compareTo(y) must throw an exception iff y.compareTo(x) throws an exception.)

The implementor must also ensure that the relation is transitive: (x.compareTo(y)>0 &&
y.compareTo(z)>0) implies x.compareTo(z)>0.

Finally, the implementor must ensure that x.compareTo(y)==0 implies that sgn(x.compareTo(z)) ==
sgn(y.compareTo(z)), for all z.

Section 32.4: TreeMap and TreeSet Thread Safety

TreeMap and TreeSet are not thread-safe collections, so care must be taken to ensure when used in multi-threaded
programs.

Both TreeMap and TreeSet are safe when read, even concurrently, by multiple threads. So if they have been created and
populated by a single thread (say, at the start of the program), and only then read, but not modified by multiple threads,
there's no reason for synchronization or locking.

However, if read and modified concurrently, or modified concurrently by more than one thread, the collection might
throw a ConcurrentModificationException or behave unexpectedly. In these cases, it's imperative to
synchronize/lock access to the collection using one of the following approaches:

INFOBYTE CAREER INSTITUTE 180

 Using Collections.synchronizedSorted..:

SortedSet<Integer> set = Collections.synchronizedSortedSet(new TreeSet<Integer>());

SortedMap<Integer,String> map = Collections.synchronizedSortedMap(new TreeMap<Integer,String>());

This will provide a SortedSet/SortedMap implementation backed by the actual collection, and synchronized on
some mutex object. Note that this will synchronize all read and write access to the collection on a single lock, so
even concurrent reads would not be possible.

2. By manually synchronizing on some object, like the collection itself:

TreeSet<Integer> set = new TreeSet<>();

...

//Thread 1
synchronized (set) {
set.add(4);
}

...

//Thread 2
synchronized (set) {
set.remove(5);
}

By using a lock, such as a ReentrantReadWriteLock:

TreeSet<Integer> set = new TreeSet<>(); ReentrantReadWriteLock lock = new

ReentrantReadWriteLock();

...

//Thread 1
lock.writeLock().lock();
set.add(4);
lock.writeLock().unlock();

...

//Thread 2
lock.readLock().lock();
set.contains(5);
lock.readLock().unlock();

As opposed to the previous synchronization methods, using a ReadWriteLock allows multiple threads to read from the
map concurrently.

INFOBYTE CAREER INSTITUTE 181

Chapter 33: Queues and Deques
Section 33.1: The usage of the PriorityQueue
PriorityQueue is a data structure. Like SortedSet, PriorityQueue sorts also its elements based on their priorities. The
elements, which have a higher priority, comes first. The type of the PriorityQueue should implement comparable or
comparator interface, whose methods decides the priorities of the elements of the data structure.

//The type of the PriorityQueue is Integer.

PriorityQueue<Integer> queue = new PriorityQueue<Integer>();

//The elements are added to the PriorityQueue queue.addAll(

Arrays.asList( 9, 2, 3, 1, 3, 8 ) );

//The PriorityQueue sorts the elements by using compareTo method of the Integer Class //The head of this
queue is the least element with respect to the specified ordering System.out.println( queue ); //The Output: [1, 2,
3, 9, 3, 8]
queue.remove();
System.out.println( queue ); //The Output: [2, 3, 3, 9, 8] queue.remove();

System.out.println( queue ); //The Output: [3, 8, 3, 9] queue.remove();

System.out.println( queue ); //The Output: [3, 8, 9] queue.remove();

System.out.println( queue ); //The Output: [8, 9]

queue.remove();
System.out.println( queue ); //The Output: [9]
queue.remove();
System.out.println( queue ); //The Output: []

Section 33.2: Deque

A Deque is a "double ended queue" which means that a elements can be added at the front or the tail of the queue.
The queue only can add elements to the tail of a queue.

The Deque inherits the Queue interface which means the regular methods remain, however the Deque interface offers
additional methods to be more flexible with a queue. The additional methods really speak for them self if you know how a
queue works, since those methods are intended to add more flexibility:

Method Brief description

getFirst() Gets the first item of the head of the queue without removing it.
getLast() Gets the first item of the tail of the queue without removing it.
addFirst(E e) Adds an item to the head of the queue addLast(E e)
Adds an item to the tail of the queue removeFirst() Removes the
first item at the head of the queue removeLast() Removes the first
item at the tail of the queue

Of course the same options for offer, poll and peek are available, however they do not work with exceptions but rather
with special values. There is no point in showing what they do here.

Adding and Accessing Elements

To add elements to the tail of a Deque you call its add() method. You can also use the addFirst() and addLast() methods,
which add elements to the head and tail of the deque.

INFOBYTE CAREER INSTITUTE 182

Deque<String> dequeA = new LinkedList<>();

dequeA.add("element 1"); //add element at tail

dequeA.addFirst("element 2"); //add element at head
dequeA.addLast("element 3"); //add element at tail

You can peek at the element at the head of the queue without taking the element out of the queue. This is done via the
element() method. You can also use the getFirst() and getLast() methods, which return the first and last element in the
Deque. Here is how that looks:

String firstElement0 = dequeA.element();

String firstElement1 = dequeA.getFirst();
String lastElement = dequeA.getLast();
Removing Elements

To remove elements from a deque, you call the remove(), removeFirst() and removeLast() methods. Here are a few
examples:

String firstElement = dequeA.remove();

String firstElement = dequeA.removeFirst();
String lastElement = dequeA.removeLast();

Section 33.3: Stacks

What is a Stack?

In Java, Stacks are a LIFO (Last In, First Out) Data structure for objects.

Stack API

Java contains a Stack API with the following methods

Stack() //Creates an empty Stack

isEmpty() //Is the Stack Empty? Return Type: Boolean
push(Item item) //push an item onto the stack
pop() //removes item from top of stack Return Type: Item
size() //returns # of items in stack Return Type: Int
Example
import java.util.*;

public class StackExample {

public static void main(String args[]) {

Stack st = new Stack();
System.out.println("stack: " + st);

st.push(10);
System.out.println("10 was pushed to the stack");
System.out.println("stack: " + st);

st.push(15);
System.out.println("15 was pushed to the stack");
System.out.println("stack: " + st);

st.push(80);
System.out.println("80 was pushed to the stack");
System.out.println("stack: " + st);

INFOBYTE CAREER INSTITUTE 183

 st.pop();
System.out.println("80 was popped from the stack");
System.out.println("stack: " + st);

st.pop();
System.out.println("15 was popped from the stack");
System.out.println("stack: " + st);

st.pop();
System.out.println("10 was popped from the stack");
System.out.println("stack: " + st);

if(st.isEmpty())
{
System.out.println("empty stack");
}
}
}

This returns:

stack: []
10 was pushed to the stack
stack: [10]
15 was pushed to the stack
stack: [10, 15]
80 was pushed to the stack
stack: [10, 15, 80]
80 was popped from the stack
stack: [10, 15]
15 was popped from the stack
stack: [10]
10 was popped from the stack
stack: []
empty stack

Section 33.4: BlockingQueue

A BlockingQueue is an interface, which is a queue that blocks when you try to dequeue from it and the queue is empty,
or if you try to enqueue items to it and the queue is already full. A thread trying to dequeue from an empty queue is
blocked until some other thread inserts an item into the queue. A thread trying to enqueue an item in a full queue is
blocked until some other thread makes space in the queue, either by dequeuing one or more items or clearing the queue
completely.

BlockingQueue methods come in four forms, with different ways of handling operations that cannot be satisfied
immediately, but may be satisfied at some point in the future: one throws an exception, the second returns a special
value (either null or false, depending on the operation), the third blocks the current thread indefinitely until the operation
can succeed, and the fourth blocks for only a given maximum time limit before giving up.

Operation Throws Exception Special Value Blocks Times out

Insert add() offer(e) put(e) offer(e, time, unit)
Remove remove() poll() take() poll(time, unit)
Examine element() peek() N/A N/A

A BlockingQueue can be bounded or unbounded. A bounded BlockingQueue is one which is initialized with initial

INFOBYTE CAREER INSTITUTE 184

capacity.

BlockingQueue<String> bQueue = new ArrayBlockingQueue<String>(2);

Any calls to a put() method will be blocked if the size of the queue is equal to the initial capacity defined.

An unbounded Queue is one which is initialized without capacity, actually by default it initialized with
Integer.MAX_VALUE.

Some common implementations of BlockingQueue are:

ArrayBlockingQueue
LinkedBlockingQueue
PriorityBlockingQueue

Now let's look at an example of ArrayBlockingQueue:

BlockingQueue<String> bQueue = new ArrayBlockingQueue<>(2);

bQueue.put("This is entry 1"); System.out.println("Entry one done");

bQueue.put("This is entry 2");

System.out.println("Entry two done");
bQueue.put("This is entry 3");
System.out.println("Entry three done");

This will print:

Entry one done

Entry two done

And the thread will be blocked after the second output.

Section 33.5: LinkedList as a FIFO Queue

The java.util.LinkedList class, while implementing java.util.List is a general-purpose implementation of java.util.Queue
interface too operating on a FIFO (First In, First Out) principle.

In the example below, with offer() method, the elements are inserted into the LinkedList. This insertion operation is called
enqueue. In the while loop below, the elements are removed from the Queue based on FIFO. This operation is called
dequeue.

Queue<String> queue = new LinkedList<String>();

queue.offer( "first element" );

queue.offer( "second element" );
queue.offer( "third element" );
queue.offer( "fourth. element" );
queue.offer( "fifth. element" );

while ( !queue.isEmpty() ) {
System.out.println( queue.poll() );
}

The output of this code is

first element

INFOBYTE CAREER INSTITUTE 185

second element
third element
fourth element
fifth element

As seen in the output, the first inserted element "first element" is removed firstly, "second element" is removed in the
second place etc.

Section 33.6: Queue Interface

Basics

A Queue is a collection for holding elements prior to processing. Queues typically, but not necessarily, order
elements in a FIFO (first-in-first-out) manner.

Head of the queue is the element that would be removed by a call to remove or poll. In a FIFO queue, all new
elements are inserted at the tail of the queue.

The Queue Interface

public interface Queue<E> extends Collection<E> {

boolean add(E e);

boolean offer(E e);

remove();

poll();

element();

peek();
}

Each Queue method exists in two forms:

one throws an exception if the operation fails;

other returns a special value if the operation fails (either null or false depending on the operation.

Type of operation Throws exception Returns special value

Insert add(e) offer(e)
Remove remove() poll()
Examine element() peek()

INFOBYTE CAREER INSTITUTE 186

Chapter 34: Dequeue Interface
A Deque is linear collection that supports element insertion and removal at both ends.

The name deque is short for "double ended queue" and is usually pronounced "deck".

Most Deque implementations place no fixed limits on the number of elements they may contain, but this interface
supports capacity-restricted deques as well as those with no fixed size limit.

The Deque interface is a richer abstract data type than both Stack and Queue because it implements both stacks and
queues at same time

Section 34.1: Adding Elements to Deque

Deque deque = new LinkedList();

//Adding element at tail

deque.add("Item1");

//Adding element at head

deque.addFirst("Item2");

//Adding element at tail

deque.addLast("Item3");

Section 34.2: Removing Elements from Deque

//Retrieves and removes the head of the queue represented by this deque Object headItem =
deque.remove();

//Retrieves and removes the first element of this deque.

Object firstItem = deque.removeFirst();

//Retrieves and removes the last element of this deque.

Object lastItem = deque.removeLast();

Section 34.3: Retrieving Element without Removing

//Retrieves, but does not remove, the head of the queue represented by this deque Object headItem =
deque.element();

//Retrieves, but does not remove, the first element of this deque.
Object firstItem = deque.getFirst();

//Retrieves, but does not remove, the last element of this deque.
Object lastItem = deque.getLast();

Section 34.4: Iterating through Deque

//Using Iterator
Iterator iterator = deque.iterator();
while(iterator.hasNext(){
String Item = (String) iterator.next();
}

//Using For Loop

INFOBYTE CAREER INSTITUTE 187

for(Object object : deque) {
String Item = (String) object;
}

INFOBYTE CAREER INSTITUTE 188

Chapter 35: Enums
Java enums (declared using the enum keyword) are shorthand syntax for sizable quantities of constants of a single
class.

Section 35.1: Declaring and using a basic enum

Enum can be considered to be syntax sugar for a sealed class that is instantiated only a number of times known at
compile-time to define a set of constants.

A simple enum to list the different seasons would be declared as follows:

public enum Season {

WINTER,
SPRING,
SUMMER,
FALL
}

While the enum constants don't necessarily need to be in all-caps, it is Java convention that names of constants are
entirely uppercase, with words separated by underscores.

You can declare an Enum in its own file:

/**
This enum is declared in the Season.java file.
*/
public enum Season {
WINTER,
SPRING,
SUMMER,
FALL
}

But you can also declare it inside another class:

public class Day {

private Season season;

public String getSeason() {

return season.name();
}

public void setSeason(String season) {

this.season = Season.valueOf(season);
}

/**
This enum is declared inside the Day.java file and
cannot be accessed outside because it's declared as private.
*/
private enum Season {
WINTER,
SPRING,
SUMMER,
FALL

INFOBYTE CAREER INSTITUTE 189

 }

Finally, you cannot declare an Enum inside a method body or constructor:

public class Day {

/**
Constructor
*/
public Day() {
Illegal. Compilation error enum
Season {
WINTER,
SPRING,
SUMMER,
FALL
}
}

public void aSimpleMethod() {

Legal. You can declare a primitive (or an Object) inside a method. Compile! int primitiveInt = 42;

Illegal. Compilation error.

enum Season {
WINTER,
SPRING,
SUMMER,
FALL
}

Season season = Season.SPRING;

}

Duplicate enum constants are not allowed:

public enum Season {

WINTER,
WINTER, //Compile Time Error : Duplicate Constants
SPRING,
SUMMER,
FALL
}

Every constant of enum is public, static and final by default. As every constant is static, they can be accessed directly
using the enum name.

Enum constants can be passed around as method parameters:

public static void display(Season s) {

System.out.println(s.name()); // name() is a built-in method that gets the exact name of the enum constant

display(Season.WINTER); // Prints out "WINTER"

INFOBYTE CAREER INSTITUTE 190

You can get an array of the enum constants using the values() method. The values are guaranteed to be in
declaration order in the returned array:

Season[] seasons = Season.values();

Note: this method allocates a new array of values each time it is called.

To iterate over the enum constants:

public static void enumIterate() {

for (Season s : Season.values()) {
System.out.println(s.name());
}
}

You can use enums in a switch statement:

public static void enumSwitchExample(Season s) {

switch(s) {
case WINTER:
System.out.println("It's pretty cold");
break;
case SPRING:
System.out.println("It's warming up");
break;
case SUMMER:
System.out.println("It's pretty hot");
break;
case FALL:
System.out.println("It's cooling down");
break;
}
}

You can also compare enum constants using ==:

Season.FALL == Season.WINTER // false

Season.SPRING == Season.SPRING // true

Another way to compare enum constants is by using equals() as below, which is considered bad practice as you can
easily fall into pitfalls as follows:

Season.FALL.equals(Season.FALL); // true
Season.FALL.equals(Season.WINTER); // false
Season.FALL.equals("FALL"); // false and no compiler error

Furthermore, although the set of instances in the enum cannot be changed at run-time, the instances themselves are
not inherently immutable because like any other class, an enum can contain mutable fields as is demonstrated below.

public enum MutableExample {

A,
B;

private int count = 0;

public void increment() {

INFOBYTE CAREER INSTITUTE 191

 count++;
}

public void print() {

System.out.println("The count of " + name() + " is " + count);
}
}

// Usage:
MutableExample.A.print(); // Outputs 0
MutableExample.A.increment();
MutableExample.A.print(); // Outputs 1 -- we've changed a field
MutableExample.B.print(); // Outputs 0 -- another instance remains unchanged

However, a good practice is to make enum instances immutable, i.e. when they either don't have any additional fields
or all such fields are marked as final and are immutable themselves. This will ensure that for a lifetime of the
application an enum won't leak any memory and that it is safe to use its instances across all threads.

Enums implicitly implement Serializable and Comparable because the Enum class does:

public abstract class Enum<E extends Enum<E>>

extends Object
implements Comparable<E>, Serializable

Section 35.2: Enums with constructors

An enum cannot have a public constructor; however, private constructors are acceptable (constructors for enums are
package-private by default):

public enum Coin {

PENNY(1), NICKEL(5), DIME(10), QUARTER(25); // usual names for US coins
note that the above parentheses and the constructor arguments match private int value;

Coin(int value) {
this.value = value;
}

public int getValue() {

return value;
}
}

int p = Coin.NICKEL.getValue(); // the int value will be 5

It is recommended that you keep all fields private and provide getter methods, as there are a finite number of
instances for an enum.

If you were to implement an Enum as a class instead, it would look like this:

public class Coin<T extends Coin<T>> implements Comparable<T>, Serializable{ public static
final Coin PENNY = new Coin(1);
public static final Coin NICKEL = new Coin(5);
public static final Coin DIME = new Coin(10);
public static final Coin QUARTER = new Coin(25);

private int value;

INFOBYTE CAREER INSTITUTE 192

 private Coin(int value){
this.value = value;
}

public int getValue() {

return value;
}
}

int p = Coin.NICKEL.getValue(); // the int value will be 5

Enum constants are technically mutable, so a setter could be added to change the internal structure of an enum
constant. However, this is considered very bad practice and should be avoided.

Best practice is to make Enum fields immutable, with final:

public enum Coin {

PENNY(1), NICKEL(5), DIME(10), QUARTER(25);

private final int value;

Coin(int value){
this.value = value;
}

...

You may define multiple constructors in the same enum. When you do, the arguments you pass in your enum
declaration decide which constructor is called:

public enum Coin {

PENNY(1, true), NICKEL(5, false), DIME(10), QUARTER(25);

private final int value;

private final boolean isCopperColored;

Coin(int value){
this(value, false);
}

Coin(int value, boolean isCopperColored){

this.value = value;
this.isCopperColored = isCopperColored;
}

...

Note: All non-primitive enum fields should implement Serializable because the Enum class does.

Section 35.3: Enums with Abstract Methods

Enums can define abstract methods, which each enum member is required to implement.

enum Action {
DODGE {

INFOBYTE CAREER INSTITUTE 193

 public boolean execute(Player player) {
return player.isAttacking();
}
},
ATTACK {
public boolean execute(Player player) {
return player.hasWeapon();
}
},
JUMP {
public boolean execute(Player player) {
return player.getCoordinates().equals(new Coordinates(0, 0));
}
};

public abstract boolean execute(Player player);

}

This allows for each enum member to define its own behaviour for a given operation, without having to switch on types
in a method in the top-level definition.

Note that this pattern is a short form of what is typically achieved using polymorphism and/or implementing
interfaces.

Section 35.4: Implements Interface

This is an enum that is also a callable function that tests String inputs against precompiled regular expression
patterns.

import java.util.function.Predicate;
import java.util.regex.Pattern;

enum RegEx implements Predicate<String> {

UPPER("[A-Z]+"), LOWER("[a-z]+"), NUMERIC("[+-]?[0-9]+");

private final Pattern pattern;

private RegEx(final String pattern) {

this.pattern = Pattern.compile(pattern);
}

@Override
public boolean test(final String input) {
return this.pattern.matcher(input).matches();
}
}

public class Main {

public static void main(String[] args) {
System.out.println(RegEx.UPPER.test("ABC"));
System.out.println(RegEx.LOWER.test("abc"));
System.out.println(RegEx.NUMERIC.test("+111"));
}
}

Each member of the enum can also implement the method:

import java.util.function.Predicate;

INFOBYTE CAREER INSTITUTE 194

enum Acceptor implements Predicate<String> {
NULL {
@Override
public boolean test(String s) { return s == null; }
},
EMPTY {
@Override
public boolean test(String s) { return s.equals(""); }
},
NULL_OR_EMPTY {
@Override
public boolean test(String s) { return NULL.test(s) || EMPTY.test(s); }
};
}

public class Main {

public static void main(String[] args) {
System.out.println(Acceptor.NULL.test(null)); // true
System.out.println(Acceptor.EMPTY.test("")); // true
System.out.println(Acceptor.NULL_OR_EMPTY.test(" ")); // false
}
}

Section 35.5: Implement Singleton pattern with a single-

element enum
Enum constants are instantiated when an enum is referenced for the first time. Therefore, that allows to implement
Singleton software design pattern with a single-element enum.

public enum Attendant {

INSTANCE;

private Attendant() {
// perform some initialization routine
}

public void sayHello() {

System.out.println("Hello!");
}
}

public class Main {

public static void main(String... args) {

Attendant.INSTANCE.sayHello();// instantiated at this point
}
}

According to "Effective Java" book by Joshua Bloch, a single-element enum is the best way to implement a singleton.
This approach has following advantages:

thread safety
guarantee of single instantiation
out-of-the-box serialization

And as shown in the section implements interface this singleton might also implement one or more interfaces.

INFOBYTE CAREER INSTITUTE 195

Section 35.6: Using methods and static blocks
An enum can contain a method, just like any class. To see how this works, we'll declare an enum like this:

public enum Direction {

NORTH, SOUTH, EAST, WEST;
}

Let's have a method that returns the enum in the opposite direction:

public enum Direction {

NORTH, SOUTH, EAST, WEST;

public Direction getOpposite(){

switch (this){
case NORTH:
return SOUTH;
case SOUTH:
return NORTH;
case WEST:
return EAST;
case EAST:
return WEST;
default: //This will never happen
return null;
}
}
}

This can be improved further through the use of fields and static initializer blocks:

public enum Direction {

NORTH, SOUTH, EAST, WEST;

private Direction opposite;

public Direction getOpposite(){

return opposite;
}

static {
NORTH.opposite = SOUTH;
SOUTH.opposite = NORTH;
WEST.opposite = EAST;
EAST.opposite = WEST;
}
}

In this example, the opposite direction is stored in a private instance field opposite, which is statically initialized the first
time a Direction is used. In this particular case (because NORTH references SOUTH and conversely), we cannot use
Enums with constructors here (Constructors NORTH(SOUTH), SOUTH(NORTH), EAST(WEST), WEST(EAST) would be more
elegant and would allow opposite to be declared final, but would be self-referential and therefore are not allowed).

Section 35.7: Zero instance enum

enum Util {
/* No instances */;

INFOBYTE CAREER INSTITUTE 196

 public static int clamp(int min, int max, int i) { return
Math.min(Math.max(i, min), max);
}

// other utility methods...

}

Just as enum can be used for singletons (1 instance classes), it can be used for utility classes (0 instance classes). Just
make sure to terminate the (empty) list of enum constants with a ;.

See the question Zero instance enum vs private constructors for preventing instantiation for a discussion on pro's and
con's compared to private constructors.

Section 35.8: Enum as a bounded type parameter

When writing a class with generics in java, it is possible to ensure that the type parameter is an enum. Since all
enums extend the Enum class, the following syntax may be used.

public class Holder<T extends Enum<T>> {

public final T value;

public Holder(T init) {

this.value = init;
}
}

In this example, the type T must be an enum.

Section 35.9: Documenting enums

Not always the enum name is clear enough to be understood. To document an enum, use standard javadoc:

/**
United States coins
*/
public enum Coins {

/**
One-cent coin, commonly known as a penny,
is a unit of currency equaling one-hundredth
of a United States dollar
*/
PENNY(1),

/**
A nickel is a five-cent coin equaling
five-hundredth of a United States dollar
*/
NICKEL(5),

/**
The dime is a ten-cent coin refers to
one tenth of a United States dollar
*/
DIME(10),

/**
The quarter is a US coin worth 25 cents,
one-fourth of a United States dollar

INFOBYTE CAREER INSTITUTE 197

 */
QUARTER(25);

private int value;

Coins(int value){
this.value = value;
}

public int getValue(){

return value;
}
}

Section 35.10: Enum constant specific body

In an enum it is possible to define a specific behavior for a particular constant of the enum which overrides the
default behavior of the enum, this technique is known as constant specific body.

Suppose three piano students - John, Ben and Luke - are defined in an enum named PianoClass, as follows:

enum PianoClass {
JOHN, BEN, LUKE;
public String getSex() {
return "Male";
}
public String getLevel() {
return "Beginner";
}
}

And one day two other students arrive - Rita and Tom - with a sex (Female) and level (Intermediate) that do not
match the previous ones:

enum PianoClass2 {
JOHN, BEN, LUKE, RITA, TOM;
public String getSex() {
return "Male"; // issue, Rita is a female
}
public String getLevel() {
return "Beginner"; // issue, Tom is an intermediate student
}
}

so that simply adding the new students to the constant declaration, as follows, is not correct:

PianoClass2 tom = PianoClass2.TOM;

PianoClass2 rita = PianoClass2.RITA;
System.out.println(tom.getLevel()); // prints Beginner -> wrong Tom's not a beginner
System.out.println(rita.getSex()); // prints Male -> wrong Rita's not a male

It's possible to define a specific behavior for each of the constant, Rita and Tom, which overrides the PianoClass2
default behavior as follows:

enum PianoClass3 {
JOHN, BEN, LUKE,
RITA {
@Override

INFOBYTE CAREER INSTITUTE 198

 public String getSex() {
return "Female";
}
},
TOM {
@Override
public String getLevel() {
return "Intermediate";
}
};
public String getSex() {
return "Male";
}
public String getLevel() {
return "Beginner";
}
}

and now Tom's level and Rita's sex are as they should be:

PianoClass3 tom = PianoClass3.TOM;

PianoClass3 rita = PianoClass3.RITA;
System.out.println(tom.getLevel()); // prints Intermediate
System.out.println(rita.getSex()); // prints Female

Another way to define content specific body is by using constructor, for instance:

enum Friend {
MAT("Male"),
JOHN("Male"),
JANE("Female");

private String gender;

Friend(String gender) {
this.gender = gender;
}

public String getGender() {

return this.gender;
}
}

and usage:

Friend mat = Friend.MAT;

Friend john = Friend.JOHN;
Friend jane = Friend.JANE;
System.out.println(mat.getGender()); // Male
System.out.println(john.getGender()); // Male
System.out.println(jane.getGender()); // Female

Section 35.11: Getting the values of an enum

Each enum class contains an implicit static method named values(). This method returns an array containing all values
of that enum. You can use this method to iterate over the values. It is important to note however that this method
returns a new array every time it is called.

INFOBYTE CAREER INSTITUTE 199

public enum Day {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;

/**
Print out all the values in this enum.
*/
public static void printAllDays() { for(Day day
: Day.values()) {
System.out.println(day.name());
}
}
}

If you need a Set you can use EnumSet.allOf(Day.class) as well.

Section 35.12: Enum Polymorphism Pattern

When a method need to accept an "extensible" set of enum values, the programmer can apply polymorphism like on a
normal class by creating an interface which will be used anywere where the enums shall be used:

public interface ExtensibleEnum {

String name();
}

This way, any enum tagged by (implementing) the interface can be used as a parameter, allowing the programmer to
create a variable amount of enums that will be accepted by the method. This can be useful, for example, in APIs where
there is a default (unmodifiable) enum and the user of these APIs want to "extend" the enum with more values.

A set of default enum values can be defined as follows:

public enum DefaultValues implements ExtensibleEnum {

VALUE_ONE, VALUE_TWO;
}

Additional values can then be defined like this:

public enum ExtendedValues implements ExtensibleEnum {

VALUE_THREE, VALUE_FOUR;
}

Sample which shows how to use the enums - note how printEnum() accepts values from both enum types:

private void printEnum(ExtensibleEnum val) {

System.out.println(val.name());
}

printEnum(DefaultValues.VALUE_ONE); // VALUE_ONE
printEnum(DefaultValues.VALUE_TWO); // VALUE_TWO
printEnum(ExtendedValues.VALUE_THREE); // VALUE_THREE
printEnum(ExtendedValues.VALUE_FOUR); // VALUE_FOUR

Note: This pattern does not prevent you from redefining enum values, which are already defined in one enum, in another
enum. These enum values would be different instances then. Also, it is not possible to use switch-on-enum since all we
have is the interface, not the real enum.

INFOBYTE CAREER INSTITUTE 200

Section 35.13: Compare and Contains for Enum values
Enums contains only constants and can be compared directly with ==. So, only reference check is needed, no need to
use .equals method. Moreover, if .equals used incorrectly, may raise the NullPointerException while that's not the case with
== check.

enum Day {
GOOD, AVERAGE, WORST;
}

public class Test {

public static void main(String[] args) {

Day day = null;

if (day.equals(Day.GOOD)) {//NullPointerException!
System.out.println("Good Day!");
}

if (day == Day.GOOD) {//Always use == to compare enum

System.out.println("Good Day!");
}

}
}

To group, complement, range the enum values we have EnumSet class which contains different methods.

EnumSet#range : To get subset of enum by range defined by two endpoints

EnumSet#of : Set of specific enums without any range. Multiple overloaded of methods are there.

EnumSet#complementOf : Set of enum which is complement of enum values provided in method parameter

enum Page {
A1, A2, A3, A4, A5, A6, A7, A8, A9, A10
}

public class Test {

public static void main(String[] args) {

EnumSet<Page> range = EnumSet.range(Page.A1, Page.A5);

if (range.contains(Page.A4)) {
System.out.println("Range contains A4");
}

EnumSet<Page> of = EnumSet.of(Page.A1, Page.A5, Page.A3);

if (of.contains(Page.A1)) {
System.out.println("Of contains A1");
}
}
}

Section 35.14: Get enum constant by name

Say we have an enum DayOfWeek:

INFOBYTE CAREER INSTITUTE 201

enum DayOfWeek {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY;
}

An enum is compiled with a built-in static valueOf() method which can be used to lookup a constant by its name:

String dayName = DayOfWeek.SUNDAY.name();

assert dayName.equals("SUNDAY");

DayOfWeek day = DayOfWeek.valueOf(dayName);

assert day == DayOfWeek.SUNDAY;

This is also possible using a dynamic enum type:

Class<DayOfWeek> enumType = DayOfWeek.class;

DayOfWeek day = Enum.valueOf(enumType, "SUNDAY");
assert day == DayOfWeek.SUNDAY;

Both of these valueOf() methods will throw an IllegalArgumentException if the specified enum does not have a constant
with a matching name.

The Guava library provides a helper method Enums.getIfPresent() that returns a Guava Optional to eliminate explicit
exception handling:

DayOfWeek defaultDay = DayOfWeek.SUNDAY;

DayOfWeek day = Enums.valueOf(DayOfWeek.class, "INVALID").or(defaultDay); assert day ==
DayOfWeek.SUNDAY;

Section 35.15: Enum with properties (fields)

In case we want to use enum with more information and not just as constant values, and we want to be able to
compare two enums.

Consider the following example:

public enum Coin {

PENNY(1), NICKEL(5), DIME(10), QUARTER(25);

private final int value;

Coin(int value){
this.value = value;
}

public boolean isGreaterThan(Coin other){

return this.value > other.value;
}

Here we defined an Enum called Coin which represent its value. With the method isGreaterThan we can compare two
enums:

Coin penny = Coin.PENNY;

Coin dime = Coin.DIME;

System.out.println(penny.isGreaterThan(dime)); // prints: false

INFOBYTE CAREER INSTITUTE 202

System.out.println(dime.isGreaterThan(penny)); // prints: true

Section 35.16: Convert enum to String

Sometimes you want to convert your enum to a String, there are two ways to do that.

Assume we have:

public enum Fruit {

APPLE, ORANGE, STRAWBERRY, BANANA, LEMON, GRAPE_FRUIT;
}

So how do we convert something like Fruit.APPLE to "APPLE"?

Convert using name()

name() is an internal method in enum that returns the String representation of the enum, the return String
represents exactly how the enum value was defined.

For example:

System.out.println(Fruit.BANANA.name()); // "BANANA"
System.out.println(Fruit.GRAPE_FRUIT.name()); // "GRAPE_FRUIT"

Convert using toString()

toString() is, by default, overridden to have the same behavior as name()

However, toString() is likely overridden by developers to make it print a more user friendly String

Don't use toString() if you want to do checking in your code, name() is much more stable for that. Only use
toString() when you are going to output the value to logs or stdout or something

By default:
System.out.println(Fruit.BANANA.toString()); // "BANANA"
System.out.println(Fruit.GRAPE_FRUIT.toString()); // "GRAPE_FRUIT"

Example of being overridden

System.out.println(Fruit.BANANA.toString()); // "Banana"
System.out.println(Fruit.GRAPE_FRUIT.toString()); // "Grape Fruit"

Section 35.17: Enums with static fields

If your enum class is required to have static fields, keep in mind they are created after the enum values
themselves. That means, the following code will result in a NullPointerException:

enum Example {
ONE(1), TWO(2);

static Map<String, Integer> integers = new HashMap<>();

private Example(int value) {

INFOBYTE CAREER INSTITUTE 203

 integers.put(this.name(), value);
}
}

A possible way to fix this:

enum Example {
ONE(1), TWO(2);

static Map<String, Integer> integers;

private Example(int value) {

putValue(this.name(), value);
}

private static void putValue(String name, int value) { if (integers ==

null)
integers = new HashMap<>();
integers.put(name, value);
}
}

Do not initialize the static field:

enum Example {
ONE(1), TWO(2);

after initialisisation integers is null!! static Map<String,

Integer> integers = null;

private Example(int value) {

putValue(this.name(), value);
}

private static void putValue(String name, int value) { if (integers ==

null)
integers = new HashMap<>();
integers.put(name, value);
}
!!this may lead to null poiner exception!! public int
getValue(){
return (Example.integers.get(this.name()));
}
}

initialisisation:

create the enum values

as side effect putValue() called that initializes integers
the static values are set
integers = null; // is executed after the enums so the content of integers is lost

INFOBYTE CAREER INSTITUTE 204

Chapter 36: Enum Map
Java EnumMap class is the specialized Map implementation for enum keys. It inherits Enum and AbstractMap
classes.

the Parameters for java.util.EnumMap class.

K: It is the type of keys maintained by this map. V: It is the type of mapped values.

Section 36.1: Enum Map Book Example

import java.util.*;
class Book {
int id;
String name,author,publisher;
int quantity;
public Book(int id, String name, String author, String publisher, int quantity) { this.id = id;

this.name = name;
this.author = author;
this.publisher = publisher;
this.quantity = quantity;
}
}
public class EnumMapExample {
Creating enum public
enum Key{
One, Two, Three };

public static void main(String[] args) {

EnumMap<Key, Book> map = new EnumMap<Key, Book>(Key.class); //
Creating Books
Book b1=new Book(101,"Let us C","Yashwant Kanetkar","BPB",8);
Book b2=new Book(102,"Data Communications & Networking","Forouzan","Mc Graw Hill",4); Book b3=new
Book(103,"Operating System","Galvin","Wiley",6);
Adding Books to Map
map.put(Key.One, b1);
map.put(Key.Two, b2);
map.put(Key.Three, b3);
Traversing EnumMap
for(Map.Entry<Key, Book> entry:map.entrySet()){ Book
b=entry.getValue();
System.out.println(b.id+" "+b.name+" "+b.author+" "+b.publisher+" "+b.quantity);
}
}
}

INFOBYTE CAREER INSTITUTE 205

Chapter 37: EnumSet class
Java EnumSet class is the specialized Set implementation for use with enum types. It inherits AbstractSet class and
implements the Set interface.

Section 37.1: Enum Set Example

import java.util.*;
enum days {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}
public class EnumSetExample {
public static void main(String[] args) {
Set<days> set = EnumSet.of(days.TUESDAY, days.WEDNESDAY); //
Traversing elements
Iterator<days> iter = set.iterator();
while (iter.hasNext())
System.out.println(iter.next());
}
}

INFOBYTE CAREER INSTITUTE 206

Chapter 38: Enum starting with number
Java does not allow the name of enum to start with number like 100A, 25K. In that case, we can append the code with
_ (underscore) or any allowed pattern and make check of it.

Section 38.1: Enum with name at beginning

public enum BookCode {
_10A("Simon Haykin", "Communication System"),
_42B("Stefan Hakins", "A Brief History of Time"),
E1("Sedra Smith", "Electronics Circuits");

private String author;

private String title;

BookCode(String author, String title) {

this.author = author;
this.title = title;
}

public String getName() {

String name = name();
if (name.charAt(0) == '_') {
name = name.substring(1, name.length());
}
return name;
}

public static BookCode of(String code) {

if (Character.isDigit(code.charAt(0))) {
code = "_" + code;
}
return BookCode.valueOf(code);
}
}

INFOBYTE CAREER INSTITUTE 207

Chapter 39: Hashtable
Hashtable is a class in Java collections which implements Map interface and extends the Dictionary Class

Contains only unique elements and its synchronized

Section 39.1: Hashtable

import java.util.*;
public class HashtableDemo {
public static void main(String args[]) {
// create and populate hash table
Hashtable<Integer, String> map = new Hashtable<Integer, String>();
map.put(101,"C Language");
map.put(102, "Domain");
map.put(104, "Databases");
System.out.println("Values before remove: "+ map);
Remove value for key 102 map.remove(102);
System.out.println("Values after remove: "+ map);

}
}

INFOBYTE CAREER INSTITUTE 208

Chapter 40: 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 40.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
x++; // adds 1
System.out.println(x); // prints 3

Section 40.2: The Conditional Operator (? :)

Syntax

INFOBYTE CAREER INSTITUTE 209

{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();
}

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

INFOBYTE CAREER INSTITUTE 210

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 40.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:

AB~AA&BA|BA^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.

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.

INFOBYTE CAREER INSTITUTE 211

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 40.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
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

INFOBYTE CAREER INSTITUTE 212

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();

tmp.append("Hello ")
tmp.append(s1 == null ? "null" + s1);
tmp.append("Welcome to ");

INFOBYTE CAREER INSTITUTE 213

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 40.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.

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 (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.

INFOBYTE CAREER INSTITUTE 214

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:

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.

INFOBYTE CAREER INSTITUTE 215

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, or
the calculation has been programmed incorrectly.

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

The Java language provides three operator for performing bitwise shifting on 32 and 64 bit integer values. These

INFOBYTE CAREER INSTITUTE 216

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:

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.)

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.)

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.

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

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

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

Section 40.7: The Instanceof Operator

This operator checks whether the object is of a particular class/interface type. instanceof operator is written as:

INFOBYTE CAREER INSTITUTE 217

 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 40.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.

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

INFOBYTE CAREER INSTITUTE 218

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

+=

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

-=

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

*=

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

/=

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

%=

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

<<=

The "left shift and assign" operator.

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

INFOBYTE CAREER INSTITUTE 219

 >>=

The "arithmetic right shift and assign" operator.

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

>>>=

The "logical right shift and assign" operator.

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

&=

The "bitwise and and assign" operator.

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

|=

The "bitwise or and assign" operator.

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

^=

The "bitwise exclusive or and assign" operator.

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

Section 40.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:

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

INFOBYTE CAREER INSTITUTE 220

 }

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);
}

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 40.10: The Relational Operators (<, <=, >, >=)

The operators <, <=, > and >= are binary operators for comparing numeric types. The meaning of the operators is as

INFOBYTE CAREER INSTITUTE 221

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:

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

If either of the operands now a byte, short or char, it is promoted to an int.
If the types of the operands are not the same, then the operand with the "smaller" type is promoted to the
"larger" type.
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 40.11: The Equality Operators (==, !=)

The == 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.

INFOBYTE CAREER INSTITUTE 222

 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:

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

If either of the operands now a byte, short or char, it is promoted to an int.
If the types of the operands are not the same, then the operand with the "smaller" type is promoted to the
"larger" type.
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 == 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:

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

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

B A==BA!=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.

INFOBYTE CAREER INSTITUTE 223

String s1 = "We are equal";
String s2 = new String("We are equal");

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 40.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.)

INFOBYTE CAREER INSTITUTE 224

Chapter 41: 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 41.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:

INFOBYTE CAREER INSTITUTE 225

TestClass testClass = new TestClass();

Section 41.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?).

INFOBYTE CAREER INSTITUTE 226

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 41.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");

INFOBYTE CAREER INSTITUTE 227

TestClass testClass2 = new TestClass();

INFOBYTE CAREER INSTITUTE 228

Chapter 42: 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 42.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);
}

INFOBYTE CAREER INSTITUTE 229

 @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

INFOBYTE CAREER INSTITUTE 230

 @Override
public boolean equals(Object obj) {
// ...
}

@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 42.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

INFOBYTE CAREER INSTITUTE 231

same thing:

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 42.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;
}

@Override

INFOBYTE CAREER INSTITUTE 232

 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()) { return false;

INFOBYTE CAREER INSTITUTE 233

 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.

Section 42.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.

INFOBYTE CAREER INSTITUTE 234

(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();

}
}
}
};

threadA.start();
threadB.start();

threadA.join();
threadB.join();

INFOBYTE CAREER INSTITUTE 235

 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 42.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;
}
}

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"

INFOBYTE CAREER INSTITUTE 236

 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 42.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
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) {

INFOBYTE CAREER INSTITUTE 237

 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 42.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?

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 {

INFOBYTE CAREER INSTITUTE 238

 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

Constructors - JLS - 8.8

Section 42.8: finalize() method

This is a protected and non-static method of the Object class. This method is used to perform some final operations

INFOBYTE CAREER INSTITUTE 239

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.

INFOBYTE CAREER INSTITUTE 240

Chapter 43: 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 43.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 43.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.

INFOBYTE CAREER INSTITUTE 241

@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 @MyAnnotation lic MyClass() {}
FIELD fields, enum constants @XmlAttribute vate int count;
for (@LoopVariable int i = 0; i < 100; i++) {
variable declarations inside @Unused
LOCAL_VARIABLE methods String resultVariable;
}
package (in package-
PACKAGE @Deprecated kage very.old;
info.java )

METHOD methods @XmlElement lic int getCount() {...}

public Rectangle( @NamedArg("width") double width,
method/constructor @NamedArg("height") double height) {
PARAMETER parameters ...
}
TYPE classes, interfaces, enums @XmlRootElement lic 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 be
SOURCE
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

INFOBYTE CAREER INSTITUTE 242

annotation in the documentation.

@Inherited

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 43.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 43.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,

INFOBYTE CAREER INSTITUTE 243

classes and code.

@Override

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 {

INFOBYTE CAREER INSTITUTE 244

 public void drive() {
System.out.println("I am driving");
}
}

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.

INFOBYTE CAREER INSTITUTE 245

This annotation can be applied to a whole class, method or line. It takes the category of warning as a parameter.

@SuppressWarnings("deprecation")
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 43.5: Compile time processing using

annotation processor
This example demonstrates how to do compile time checking of an annotated element.

The annotation

INFOBYTE CAREER INSTITUTE 246

The @Setter annotation is a marker can be applied to methods. The annotation will be discarded during
compilation not be available afterwards.

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;

INFOBYTE CAREER INSTITUTE 247

 }

private void checkMethod(ExecutableElement method) { // 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;

INFOBYTE CAREER INSTITUTE 248

public class AnnotationProcessorTest {

@Setter
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:

go to Project Properties > Build > Compiling

add check marks for Enable Annotation Processing and Enable Annotation Processing in Editor

click Add next to the annotation processor list

in the popup that appears enter the fully qualified class name of the annotation processor and click Ok.

Result

INFOBYTE CAREER INSTITUTE 249

Section 43.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

INFOBYTE CAREER INSTITUTE 250

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 43.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));

INFOBYTE CAREER INSTITUTE 251

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 43.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) {

INFOBYTE CAREER INSTITUTE 252

 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 43.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) { // ...

INFOBYTE CAREER INSTITUTE 253

 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 43.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")

INFOBYTE CAREER INSTITUTE 254

Chapter 44: 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 44.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 44.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 44.3: Rules to define immutable classes

The following rules define a simple strategy for creating immutable objects.

Don't provide "setter" methods - methods that modify fields or objects referred to by fields.
Make all fields final and private.
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.
If the instance fields include references to mutable objects, don't allow those objects to be changed:
Don't provide methods that modify the mutable objects.
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.

INFOBYTE CAREER INSTITUTE 255

Section 44.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;

INFOBYTE CAREER INSTITUTE 256

Chapter 45: Immutable Objects
Section 45.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 45.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;
}

INFOBYTE CAREER INSTITUTE 257

 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 45.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;

INFOBYTE CAREER INSTITUTE 258

 }

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:

INFOBYTE CAREER INSTITUTE 259

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;}

INFOBYTE CAREER INSTITUTE 260

}

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.

INFOBYTE CAREER INSTITUTE 261

Chapter 46: Visibility (controlling access to
members of a class)
Section 46.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 46.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);
}

INFOBYTE CAREER INSTITUTE 262

}

Section 46.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 46.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.

INFOBYTE CAREER INSTITUTE 263

Note that this modifier only works on members of a class, not on the class itself.

Section 46.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 46.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.

INFOBYTE CAREER INSTITUTE 264

Chapter 47: 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 47.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;

INFOBYTE CAREER INSTITUTE 265

 }
}

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);

INFOBYTE CAREER INSTITUTE 266

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 47.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")

INFOBYTE CAREER INSTITUTE 267

 T if you need both ("modify")

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:

INFOBYTE CAREER INSTITUTE 268

 Producer uses "Extends" and Consumer uses "Super".

(Producer has only write access, and Consumer has only read access)

Section 47.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 47.4: Declaring a Generic Method

Methods can also have generic type parameters.

public class Example {

INFOBYTE CAREER INSTITUTE 269

 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) {
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 47.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 47.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

INFOBYTE CAREER INSTITUTE 270

thread type information through every call.

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 47.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);

INFOBYTE CAREER INSTITUTE 271

When re-written to use generics, the code does not require casting:

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 47.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 47.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:

INFOBYTE CAREER INSTITUTE 272

public abstract class Animal {
public abstract String getSound();
}

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());
}
}

INFOBYTE CAREER INSTITUTE 273

}

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 47.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);

INFOBYTE CAREER INSTITUTE 274

 }

@Override
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 47.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. */

INFOBYTE CAREER INSTITUTE 275

 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.
}
}

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 47.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 47.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> {

INFOBYTE CAREER INSTITUTE 276

 public boolean isTypeAString(String s) {
return s instanceof T; // Compilation error, cannot use T as class type here
}
}

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
}
}

INFOBYTE CAREER INSTITUTE 277

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:

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 47.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

INFOBYTE CAREER INSTITUTE 278

Declare a non-generic class which implements MyGenericInteface as a raw type (not using generic at all), as follows:

public class MyGenericSubclass implements MyGenericInterface {

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.

INFOBYTE CAREER INSTITUTE 279

Chapter 48: 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 48.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:

Based on the number of parameters passed.

Example: method(String s) and method(String s1, String s2).

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.

INFOBYTE CAREER INSTITUTE 280

Section 48.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.

INFOBYTE CAREER INSTITUTE 281

 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;
}

INFOBYTE CAREER INSTITUTE 282

}

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 be same or Return type must be same or covariant in method
different in method overloading. But you must have to overriding.
change the parameter.

Section 48.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);

INFOBYTE CAREER INSTITUTE 283

 }
}
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:

Constructors can only take the modifiers public, private, and protected, and cannot be declared abstract, final, static,
or synchronized.

Constructors do not have a return type.

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.

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 48.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);
}

INFOBYTE CAREER INSTITUTE 284

}

Section 48.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;
}

INFOBYTE CAREER INSTITUTE 285

 //Get the Car color
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

INFOBYTE CAREER INSTITUTE 286

are thrown.

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 48.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 48.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();

INFOBYTE CAREER INSTITUTE 287

System.out.println("o1 static counter " + o1.staticCounter);
System.out.println("o1 member counter " + o1.memberCounter);
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.

INFOBYTE CAREER INSTITUTE 288

Chapter 49: 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 49.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();
}
}

INFOBYTE CAREER INSTITUTE 289

Chapter 50: 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 50.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 50.2: Static vs Non Static Nested Classes

When creating a nested class, you face a choice of having that nested class static:

INFOBYTE CAREER INSTITUTE 290

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

INFOBYTE CAREER INSTITUTE 291

 }
}

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 50.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 {

INFOBYTE CAREER INSTITUTE 292

 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 50.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

INFOBYTE CAREER INSTITUTE 293

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 50.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();
}
}

INFOBYTE CAREER INSTITUTE 294

Note the usage as outer.new.

Section 50.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 50.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);

INFOBYTE CAREER INSTITUTE 295

 }
}
}

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;
}
}
}

INFOBYTE CAREER INSTITUTE 296

Chapter 51: The java.util.Objects Class
Section 51.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 51.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);

INFOBYTE CAREER INSTITUTE 297

Chapter 52: 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 52.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 52.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 {

INFOBYTE CAREER INSTITUTE 298

 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 52.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 52.4: Accessing other interface methods within

default method
You can as well access other interface methods from within your default method.

INFOBYTE CAREER INSTITUTE 299

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 52.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"); }

INFOBYTE CAREER INSTITUTE 300

}

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 52.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

INFOBYTE CAREER INSTITUTE 301

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

INFOBYTE CAREER INSTITUTE 302

Chapter 53: 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 53.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 53.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

INFOBYTE CAREER INSTITUTE 303

}

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
}

INFOBYTE CAREER INSTITUTE 304

Chapter 54: 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 54.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:

INFOBYTE CAREER INSTITUTE 305

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 54.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:

INFOBYTE CAREER INSTITUTE 306

 //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:

INFOBYTE CAREER INSTITUTE 307

Component myAnonymousComponent = new Component() {
@Override
public void render() {
// render a quick 1-time use component
}
}

Section 54.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

INFOBYTE CAREER INSTITUTE 308

The final modifier can also be applied to methods to prevent them being overridden in sub-classes:

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 54.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.

INFOBYTE CAREER INSTITUTE 309

Section 54.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

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{

INFOBYTE CAREER INSTITUTE 310

 public Dog(String name,int age){
super(name,age);
}
public void remember(){
System.out.println(this.getClass().getSimpleName()+" can remember for 5 minutes");
}
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(){

INFOBYTE CAREER INSTITUTE 311

 return "Man :"+name+":Age:"+age;
}
}

output:

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:

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.

Cat can climb() but Dog cannot. Dog can think() but Cat cannot. These specific capabilities are added to Cat and Dog by
implementation.

Man is not an Animal but he can Think , Learn, Apply, and Climb.

Cat is not a Man but it can Climb.

Dog is not a Man but it can Learn

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.

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...

You want to share code among several closely related classes.

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).
You want to declare non-static or non-final fields.

Consider using interfaces if...

You expect that unrelated classes would implement your interface. For example, many unrelated objects can
implement the Serializable interface.

INFOBYTE CAREER INSTITUTE 312

 You want to specify the behaviour of a particular data type but are not concerned about who implements its
behaviour.
You want to take advantage of multiple inheritance of type.

Section 54.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

INFOBYTE CAREER INSTITUTE 313

 Hello
Hey
Static says Hi
StaticOverride's num: test

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 54.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

INFOBYTE CAREER INSTITUTE 314

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 {

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);
}

INFOBYTE CAREER INSTITUTE 315

}

Generally, a builder can also be generated using a tool like FreeBuilder.

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 54.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:

INFOBYTE CAREER INSTITUTE 316

 B

Section 54.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 54.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 {

INFOBYTE CAREER INSTITUTE 317

 public static void main(String[] args) {

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 54.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() {

INFOBYTE CAREER INSTITUTE 318

 System.out.println("Inside Child");
}
}
}

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.

INFOBYTE CAREER INSTITUTE 319

Chapter 55: Reference Types
Section 55.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.

INFOBYTE CAREER INSTITUTE 320

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);

INFOBYTE CAREER INSTITUTE 321

Chapter 56: Console I/O
Section 56.1: Reading user input from the console
Using BufferedReader:
System.out.println("Please type your name and press Enter.");

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); try {

String name = reader.readLine();

System.out.println("Hello, " + name + "!");
} catch(IOException e) {
System.out.println("An error occurred: " + e.getMessage());
}

The following imports are needed for this code:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

Using Scanner:
Version ≥ Java SE 5
System.out.println("Please type your name and press Enter");

Scanner scanner = new Scanner(System.in);

String name = scanner.nextLine();

System.out.println("Hello, " + name + "!");

The following import is needed for this example:

import java.util.Scanner;

To read more than one line, invoke scanner.nextLine() repeatedly:

System.out.println("Please enter your first and your last name, on separate lines.");

Scanner scanner = new Scanner(System.in);

String firstName = scanner.nextLine();
String lastName = scanner.nextLine();

System.out.println("Hello, " + firstName + " " + lastName + "!");

There are two methods for obtaining Strings, next() and nextLine(). next() returns text up until the first space (also known
as a "token"), and nextLine() returns all text that the user inputted until pressing enter.

Scanner also provides utility methods for reading data types other than String. These include:

scanner.nextByte();
scanner.nextShort();
scanner.nextInt();
scanner.nextLong();
scanner.nextFloat();
scanner.nextDouble();
scanner.nextBigInteger();

INFOBYTE CAREER INSTITUTE 322

scanner.nextBigDecimal();

Prefixing any of these methods with has (as in hasNextLine(), hasNextInt()) returns true if the stream has any more of the
request type. Note: These methods will crash the program if the input is not of the requested type (for example, typing
"a" for nextInt() ). You can use a try {} catch() {} to prevent this (see: Exceptions)

Scanner scanner = new Scanner(System.in); //Create the scanner

scanner.useLocale(Locale.US); //Set number format excepted
System.out.println("Please input a float, decimal separator is .");
if (scanner.hasNextFloat()){ //Check if it is a float
float fValue = scanner.nextFloat(); //retrive the value directly as float System.out.println(fValue + "
is a float");
}else{
String sValue = scanner.next(); //We can not retrive as float
System.out.println(sValue + " is not a float");
}

Using System.console:
Version ≥ Java SE 6
String name = System.console().readLine("Please type your name and press Enter%n");

System.out.printf("Hello, %s!", name);

//To read passwords (without echoing as in unix terminal)

char[] password = System.console().readPassword();

Advantages:

Reading methods are synchronized

Format string syntax can be used

Note: This will only work if the program is run from a real command line without redirecting the standard input and output
streams. It does not work when the program is run from within certain IDEs, such as Eclipse. For code that works within
IDEs and with stream redirection, see the other examples.

Section 56.2: Aligning strings in console

The method PrintWriter.format (called through System.out.format) can be used to print aligned strings in console. The
method receives a String with the format information and a series of objects to format:

String rowsStrings[] = new String[] {"1",

"1234",
"1234567",
"123456789"};

String column1Format = "%-3s"; // min 3 characters, left aligned

String column2Format = "%-5.8s"; // min 5 and max 8 characters, left aligned
String column3Format = "%6.6s"; // fixed size 6 characters, right aligned
String formatInfo = column1Format + " " + column2Format + " " + column3Format;

for(int i = 0; i < rowsStrings.length; i++) {

System.out.format(formatInfo, rowsStrings[i], rowsStrings[i], rowsStrings[i]);
System.out.println();
}

Output:

INFOBYTE CAREER INSTITUTE 323

1 1 1
1234 1234 1234
1234567 1234567 123456
123456789 12345678 123456

Using format strings with fixed size permits to print the strings in a table-like appearance with fixed size columns:

String rowsStrings[] = new String[] {"1",

"1234",
"1234567",
"123456789"};

String column1Format = "%-3.3s"; // fixed size 3 characters, left aligned

String column2Format = "%-8.8s"; // fixed size 8 characters, left aligned
String column3Format = "%6.6s"; // fixed size 6 characters, right aligned
String formatInfo = column1Format + " " + column2Format + " " + column3Format;

for(int i = 0; i < rowsStrings.length; i++) {

System.out.format(formatInfo, rowsStrings[i], rowsStrings[i], rowsStrings[i]);
System.out.println();
}

Output:

1 1 1
123 1234 1234
123 1234567 123456
123 12345678 123456

Format strings examples

%s: just a string with no formatting

%5s: format the string with a minimum of 5 characters; if the string is shorter it will be padded to 5
characters and right aligned
%-5s: format the string with a minimum of 5 characters; if the string is shorter it will be padded to 5
characters and left aligned
%5.10s: format the string with a minimum of 5 characters and a maximum of 10 characters; if the string is
shorter than 5 it will be padded to 5 characters and right aligned; if the string is longer than 10 it will be
truncated to 10 characters and right aligned
%-5.5s: format the string with a fixed size of 5 characters (minimum and maximum are equals); if the string is
shorter than 5 it will be padded to 5 characters and left aligned; if the string is longer than 5 it will be truncated
to 5 characters and left aligned

Section 56.3: Implementing Basic Command-Line Behavior

For basic prototypes or basic command-line behavior, the following loop comes in handy.

public class ExampleCli {

private static final String CLI_LINE = "example-cli>"; //console like string

private static final String CMD_QUIT = "quit"; //string for exiting the program
private static final String CMD_HELLO = "hello"; //string for printing "Hello World!" on
the screen
private static final String CMD_ANSWER = "answer"; //string for printing 42 on the screen

INFOBYTE CAREER INSTITUTE 324

 public static void main(String[] args) {
ExampleCli claimCli = new ExampleCli(); // creates an object of this class

try {
claimCli.start(); //calls the start function to do the work like console
}
catch (IOException e) {
e.printStackTrace(); //prints the exception log if it is failed to do get
the user
input or something like that
}
}

private void start() throws IOException {

String cmd = "";

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

while (!cmd.equals(CMD_QUIT)) { // terminates console if user input is "quit"
System.out.print(CLI_LINE); //prints the console-like string

cmd = reader.readLine(); //takes input from user. user input should be started
with
"hello", "answer" or "quit"
String[] cmdArr = cmd.split(" ");

if (cmdArr[0].equals(CMD_HELLO)) { //executes when user input starts with "hello"

hello(cmdArr);
}
else if (cmdArr[0].equals(CMD_ANSWER)) { //executes when user input starts with
"answer"
answer(cmdArr);
}
}
}

prints "Hello World!" on the screen if user input starts with "hello" private void hello(String[]
cmdArr) {
System.out.println("Hello World!");
}

prints "42" on the screen if user input starts with "answer"

private void answer(String[] cmdArr) {
System.out.println("42");
}
}
INFOBYTE CAREER INSTITUTE 325
Chapter 57: Streams
A Stream represents a sequence of elements and supports different kind of operations to perform computations upon
those elements. With Java 8, Collection interface has two methods to generate a Stream: stream() and parallelStream().
Stream operations are either intermediate or terminal. Intermediate operations return a Stream so multiple intermediate
operations can be chained before the Stream is closed. Terminal operations are either void or return a non-stream result.

Section 57.1: Using Streams

A Stream is a sequence of elements upon which sequential and parallel aggregate operations can be performed. Any
given Stream can potentially have an unlimited amount of data flowing through it. As a result, data received from a
Stream is processed individually as it arrives, as opposed to performing batch processing on the data altogether.
When combined with lambda expressions they provide a concise way to perform operations on sequences of data
using a functional approach.

Example: (see it work on Ideone)

Stream<String> fruitStream = Stream.of("apple", "banana", "pear", "kiwi", "orange");

fruitStream.filter(s -> s.contains("a"))

.map(String::toUpperCase)
.sorted()
.forEach(System.out::println);

Output:

APPLE
BANANA
ORANGE
PEAR

The operations performed by the above code can be summarized as follows:

Create a Stream<String> containing a sequenced ordered Stream of fruit String elements using the static factory
method Stream.of(values).

The filter() operation retains only elements that match a given predicate (the elements that when tested by the
predicate return true). In this case, it retains the elements containing an "a". The predicate is given as a lambda
expression.

The map() operation transforms each element using a given function, called a mapper. In this case, each fruit String is
mapped to its uppercase String version using the method-reference String::toUppercase.

Note that the map() operation will return a stream with a different generic type if the mapping function
returns a type different to its input parameter. For example on a Stream<String> calling
.map(String::isEmpty) returns a Stream<Boolean>

4. The sorted() operation sorts the elements of the Stream according to their natural ordering

INFOBYTE CAREER INSTITUTE 326

 (lexicographically, in the case of String).

Finally, the forEach(action) operation performs an action which acts on each element of the Stream, passing it to a
Consumer. In the example, each element is simply being printed to the console. This operation is a terminal
operation, thus making it impossible to operate on it again.

Note that operations defined on the Stream are performed because of the terminal operation.
Without a terminal operation, the stream is not processed. Streams can not be reused. Once a
terminal operation is called, the Stream object becomes unusable.

Operations (as seen above) are chained together to form what can be seen as a query on the data.

Closing Streams

Note that a Stream generally does not have to be closed. It is only required to close streams that
operate on IO channels. Most Stream types don't operate on resources and therefore don't require
closing.

The Stream interface extends AutoCloseable. Streams can be closed by calling the close method or by using try-with-
resource statements.

An example use case where a Stream should be closed is when you create a Stream of lines from a file:

try (Stream<String> lines = Files.lines(Paths.get("somePath"))) {

lines.forEach(System.out::println);
}

The Stream interface also declares the Stream.onClose() method which allows you to register Runnable handlers which will
be called when the stream is closed. An example use case is where code which produces a stream needs to know when
it is consumed to perform some cleanup.

public Stream<String>streamAndDelete(Path path) throws IOException { return

Files.lines(path).onClose(() -> someClass.deletePath(path));
}

The run handler will only execute if the close() method gets called, either explicitly or implicitly by a try-with-
resources statement.

Processing Order

INFOBYTE CAREER INSTITUTE 327

A Stream object's processing can be sequential or parallel.

In a sequential mode, the elements are processed in the order of the source of the Stream. If the Stream is ordered (such
as a SortedMap implementation or a List) the processing is guaranteed to match the ordering of the source. In other cases,
however, care should be taken not to depend on the ordering (see: is the Java HashMap keySet() iteration order
consistent?).

Example:

List<Integer> integerList = Arrays.asList(0, 1, 2, 3, 42);

// sequential
long howManyOddNumbers = integerList.stream()
.filter(e -> (e % 2) == 1)
.count();

System.out.println(howManyOddNumbers); // Output: 2

Live on Ideone

Parallel mode allows the use of multiple threads on multiple cores but there is no guarantee of the order in which
elements are processed.

If multiple methods are called on a sequential Stream, not every method has to be invoked. For example, if a Stream is
filtered and the number of elements is reduced to one, a subsequent call to a method such as sort will not occur. This can
increase the performance of a sequential Stream — an optimization that is not possible with a parallel Stream.

Example:

// parallel
long howManyOddNumbersParallel = integerList.parallelStream()
.filter(e -> (e % 2) == 1)
.count();

System.out.println(howManyOddNumbersParallel); // Output: 2

Live on Ideone

Differences from Containers (or Collections)

While some actions can be performed on both Containers and Streams, they ultimately serve different purposes and
support different operations. Containers are more focused on how the elements are stored and how those elements can
be accessed efficiently. A Stream, on the other hand, doesn't provide direct access and manipulation to its elements; it is
more dedicated to the group of objects as a collective entity and performing operations on that entity as a whole. Stream
and Collection are separate high-level abstractions for these differing purposes.

Section 57.2: Consuming Streams

A Stream will only be traversed when there is a terminal operation, like count(), collect() or forEach(). Otherwise, no
operation on the Stream will be performed.

In the following example, no terminal operation is added to the Stream, so the filter() operation will not be invoked
and no output will be produced because peek() is NOT a terminal operation.

INFOBYTE CAREER INSTITUTE 328

IntStream.range(1, 10).filter(a -> a % 2 == 0).peek(System.out::println);

Live on Ideone

This is a Stream sequence with a valid terminal operation, thus an output is produced.

You could also use forEach instead of peek:

IntStream.range(1, 10).filter(a -> a % 2 == 0).forEach(System.out::println);

Live on Ideone

Output:

2
4
6
8

After the terminal operation is performed, the Stream is consumed and cannot be reused.

Although a given stream object cannot be reused, it's easy to create a reusable Iterable that delegates to a stream
pipeline. This can be useful for returning a modified view of a live data set without having to collect results into a
temporary structure.

List<String> list = Arrays.asList("FOO", "BAR");

Iterable<String> iterable = () -> list.stream().map(String::toLowerCase).iterator();

for (String str : iterable) {

System.out.println(str);
}
for (String str : iterable) {
System.out.println(str);
}

Output:

foo
bar