Java Notes for Professionals

[Pages:982]Java

Java Notes for Professionals

?

Notes for Professionals

900+ pages

of professional hints and tricks



Free Programming Books

Disclaimer This is an unocial free book created for educational purposes and is

not aliated with ocial Java? group(s) or company(s). All trademarks and registered trademarks are the property of their respective owners

Contents

About ................................................................................................................................................................................... 1 Chapter 1: Getting started with Java Language .......................................................................................... 2

Section 1.1: Creating Your First Java Program ........................................................................................................... 2

Chapter 2: Type Conversion .................................................................................................................................... 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 dierent 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: StringBuer ......................................................................................................................................... 68

Section 12.1: String Buer class .................................................................................................................................. 68

Chapter 13: StringBuilder ........................................................................................................................................ 69

Section 13.1: Comparing StringBuer, 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 Dierence 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 dierence ................................................................................................. 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 Eciently ......................................................................................................... 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: Dierent 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

 ................
................

In order to avoid copyright disputes, this page is only a partial summary.

Google Online Preview   Download