Java Notes for Professionals

Contents for java program

 

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