Contents

• Inheritance
  • Inheritance
  • Implementing multiple interfaces
  • Abstract Classes
  • Declaring and Implementing an Interface
  • Using final to restrict inheritance and overriding
  • The Liskov Substitution Principle
  • Static Inheritance
  • Abstract class and Interface usage Is-a relation vs Has-a capability
  • Inheritance and Static Methods
  • Variable shadowing
  • Narrowing and Widening of object references
  • Programming to an interface
  • Overriding in Inheritance
• Getting started with Java
  • Getting started with Java Language
  • Creating Your First Java Program
  • Setting PATH and JAVA HOME after installing on Windows
• Streams
  • Streams
  • Using Streams
  • Consuming Streams
  • Creating a Frequency Map
  • Infinite Streams
  • Collect Elements of a Stream into a Collection
  • Using Streams to Implement Mathematical Functions
  • Parallel Stream
  • Flatten Streams with flatMap
  • Creating a Stream
  • Finding Statistics about Numerical Streams
  • Using IntStream to iterate over indexes
  • Converting an iterator to a stream
  • Concatenate Streams
  • Using Streams of Map.Entry to Preserve Initial Values after Mapping
  • Using Streams and Method References to Write Self-Documenting Processes
  • Finding the First Element that Matches a Predicate
  • Reduction with Streams
  • IntStream to String
  • Get a Slice of a Stream
  • Converting a Stream of Optional to a Stream of Values
  • Create a Map based on a Stream
  • Joining a stream to a single String
  • Streams of Primitives
  • Sort Using Stream
  • Stream operations categories
  • Generating random Strings using Streams
  • Collect Results of a Stream into an Array
  • Closing Streams
• Exceptions
  • Exceptions and exception handling
  • Catching an exception with try-catch
  • The try-with-resources statement
  • Custom Exceptions
  • Handling InterruptedException
  • Return statements in try catch block
  • Introduction
  • The Java Exception Hierarchy - Unchecked and Checked Exceptions
  • Creating and reading stacktraces
  • Throwing an exception
  • Advanced features of Exceptions
  • The try-finally and try-catch-finally statements
  • The throws clause in a method declaration
• Collections
  • Collections
  • Removing items from a List within a loop
  • Constructing collections from existing data
  • Declaring an ArrayList and adding objects
  • Iterating over Collections
  • Usage of HashMap
  • Immutable Empty Collections
  • Unmodifiable Collection
  • Sub Collections
  • Pitfall concurrent modification exceptions
  • Removing matching items from Lists using Iterator.
  • Join lists
  • Creating your own Iterable structure for use with Iterator or for-each loop.
  • Collections and Primitive Values
  • Sorting a generic list
  • The usage of the PriorityQueue
  • BlockingQueue
  • LinkedList as a FIFO Queue
  • Stacks
  • Types and Usage of Sets
  • Declaring a HashSet with values
  • Concurrent Collections
  • Queue Interface
  • Thread-safe Collections
  • Insertion into ConcurrentHashMap
• Lambda Expressions
  • Lambda Expressions
  • Introduction to Java lambdas
  • Using Lambda Expressions to Sort a Collection
  • Method References
  • Implementing multiple interfaces
  • Lambda - Listener Example
  • Java Closures with lambda expressions.
  • Lambdas and memory utilization
  • Using lambda expression with your own functional interface
  • Traditional style to Lambda style
  • return only returns from the lambda not the outer method
  • Lambdas and Execute-around Pattern
  • Using lambda expressions predicates to get a certain values from a list
• Generics
  • Generics
  • Creating a Generic Class
  • Deciding between T super T and extends T
  • The Diamond
  • Declaring a Generic Method
  • Requiring multiple upper bounds extends A B
  • Instantiating a generic type
  • Benefits of Generic class and interface
  • Obtain class that satisfies generic parameter at runtime
  • Creating a Bounded Generic Class
  • Referring to the declared generic type within its own declaration
  • Using Generics to auto-cast
  • Binding generic parameter to more than 1 type
  • Use of instanceof with Generics
  • Different ways for implementing a Generic Interface or extending a Generic Class
• File I/O
  • File IO
  • Migrating from java.io.File to Java 7 NIO java.nio.file.Path
  • Reading an image from a file
  • File ReadWrite Using FileInputStreamFileOutputStream
  • Reading all bytes to a byte
  • Copying a file using Channel
  • Writing a byte to a file
  • Stream vs WriterReader API
  • Reading a file with a Scanner
  • Copying a file using InputStream and OutputStream
  • Locking
  • Reading from a binary file
  • Reading a file using Channel and Buffer
  • Reading a whole file at once
  • Reading a file using BufferedInputStream
  • Writing a file using Channel and Buffer
  • Writing a file using PrintStream
  • Adding Directories
  • Iterating over a directory and filter by file extension
  • Iterate over a directory printing subdirectories in it
  • Blocking or redirecting standard output error
  • Accessing the contents of a ZIP file
• Arrays
  • Arrays
  • Creating and Initializing Arrays
  • Creating a List from an Array
  • Creating an Array from a Collection
  • Multidimensional and Jagged Arrays
  • ArrayIndexOutOfBoundsException
  • Array Covariance
  • Arrays to Stream
  • Iterating over arrays
  • Arrays to a String
  • Sorting arrays
  • How do you change the size of an array
  • Getting the Length of an Array
  • Converting arrays between primitives and boxed types
  • Remove an element from an array
  • Finding an element in an array
  • Comparing arrays for equality
  • Copying arrays
  • Casting Arrays
• Interfaces
  • Interfaces
  • Implementing multiple interfaces
  • Declaring and Implementing an Interface
  • Extending an interface
  • Usefulness of interfaces
  • Default methods
  • Modifiers in Interfaces
  • Using Interfaces with Generics
  • Strengthen bounded type parameters
  • Implementing interfaces in an abstract class
• Maps
  • Maps
  • Iterating Map Entries Efficiently
  • Using Default Methods of Map from Java 8
  • Usage of HashMap
  • Iterating through the contents of a Map
  • Merging combine and composing Maps
  • Add multiple items
  • Add an element
  • Clear the map
  • Check if key exists
  • Use custom object as key
  • Creating and Initializing Maps
• Strings
  • Strings
  • Comparing Strings
  • Changing the case of characters within a String
  • Finding a String Within Another String
  • String pool and heap storage
  • Splitting Strings
  • Joining Strings with a delimiter
  • String concatenation and StringBuilders
  • Platform independent new line separator
  • Substrings
  • Converting String to other datatypes.
  • Reversing Strings
  • Adding toString method for custom objects
  • Remove Whitespace from the Beginning and End of a String
  • Case insensitive switch
  • Replacing parts of Strings
  • Base64 Encoding Decoding
  • Conversion to from bytes
  • Getting the nth character in a String
  • Getting the length of a String
  • Counting occurrences of a substring or character in a string
  • Converting other datatypes to String
  • Getting a String from an InputStream
  • Parsing Strings to a Numerical Value
• InputStreams and OutputStreams
  • InputStreams and OutputStreams
  • Closing Streams
  • Reading InputStream into a String
  • Wrapping InputOutput Streams
  • Writing bytes to an OutputStream
  • Copying Input Stream to Output Stream
  • DataInputStream Example
• Default Methods
  • Default Methods
  • Basic usage of default methods
  • Accessing overridden default methods from implementing class
  • Why use Default Methods
  • Accessing other interface methods within default method
  • Default method multiple inheritance collision
  • Class Abstract class and Interface method precedence
• Classes and Objects
  • Classes and Objects
  • Overloading Methods
  • Explaining what is method overloading and overriding.
  • Object Member vs Static Member
  • Basic Object Construction and Use
  • Constructors
  • Initializing static final fields using a static initializer
  • Simplest Possible Class
• Basic Control structures
  • Basic Control Structures
  • Switch statement
  • do...while Loop
  • For Each
  • Continue Statement in Java
  • For Loops
  • If Else If Else Control
  • Ternary Operator
  • While Loops
  • Break
  • Try ... Catch ... Finally
  • Nested break continue
  • If Else
• Concurrent Programming Threads
  • Concurrent Programming Threads
  • Callable and Future
  • CountDownLatch
  • Basic Multithreading
  • Locks as Synchronisation aids
  • Semaphore
  • Runnable Object
  • Creating basic deadlocked system
  • Synchronization
  • Creating a java.lang.Thread instance
  • Atomic operations
  • Exclusive write Concurrent read access
  • Visualizing readwrite barriers while using synchronized volatile
  • Get status of all threads started by your program excluding system threads
  • Producer-Consumer
  • Multiple producerconsumer example with shared global queue
  • Using ThreadLocal
  • Add two int arrays using a Threadpool
  • Pausing Execution
  • Thread Interruption Stopping Threads
• Console I/O
  • Console IO
  • Reading user input from the console
  • Implementing Basic Command-Line Behavior
  • Aligning strings in console
• Singletons
  • Singletons
  • Enum Singleton
  • Singleton without use of Enum eager initialization
  • Thread-safe lazy initialization using holder class Bill Pugh Singleton implementation
  • Thread safe Singleton with double checked locking
  • Extending singleton singleton inheritance
• Visibility controlling access to members of a class
  • Visibility controlling access to members of a class
  • Private Visibility
  • Public Visibility
  • Package Visibility
  • Protected Visibility
  • Summary of Class Member Access Modifiers
  • Interface members
• Regular Expressions
  • Regular Expressions
  • Using capture groups
  • Using regex with custom behaviour by compiling the Pattern with flags
  • Escape Characters
  • Not matching a given string
  • Matching with a regex literal.
  • Matching a backslash
• Autoboxing
  • Autoboxing
  • Using int and Integer interchangeably
  • Auto-unboxing may lead to NullPointerException
  • Using Boolean in if statement
  • Memory and Computational Overhead of Autoboxing
  • Different Cases When Integer and int can be used interchangeably
• Documenting Java Code
  • Documenting Java Code
  • Building Javadocs From the Command Line
  • Class Documentation
  • Method Documentation
  • Package Documentation
  • Links
  • Field Documentation
  • Code snippets inside documentation
  • Inline Code Documentation
• Executor, ExecutorService and Thread pools
  • Executor ExecutorService and Thread pools
  • ThreadPoolExecutor
  • Retrieving value from computation - Callable
  • submit vs execute exception handling differences
  • Fire and Forget - Runnable Tasks
  • Handle Rejected Execution
  • Use cases for different types of concurrency constructs
  • Wait for completion of all tasks in ExecutorService
  • Use cases for different types of ExecutorService
  • Scheduling tasks to run at a fixed time after a delay or repeatedly
  • Using Thread Pools
• Object Class Methods and Constructor
  • Object Class Methods and Constructor
  • hashCode method
  • toString method
  • equals method
  • wait and notify methods
  • getClass method
  • clone method
  • finalize method
  • Object constructor
• JAXB
  • JAXB
  • Reading an XML file unmarshalling
  • Writing an XML file marshalling an object
  • Manual fieldproperty XML mapping configuration
  • Binding an XML namespace to a serializable Java class.
  • Using XmlAdapter to generate desired xml format
  • Automatic fieldproperty XML mapping configuration XmlAccessorType
  • Specifying a XmlAdapter instance to reuse existing data
  • Using XmlAdapter to trim string.
• Primitive Data Types
  • Primitive Data Types
  • Comparing floating point values
  • The char primitive
  • Primitive Types Cheatsheet
  • Using underscore to improve readability
  • The float primitive
  • Converting Primitives
  • The int primitive
  • Memory consumption of primitives vs. boxed primitives
  • The double primitive
  • The byte primitive
  • The boolean primitive
  • The long primitive
  • Hexadecimal Octal and Binary literals
  • Negative value representation
  • The short primitive
• Networking
  • Networking
  • Basic Client and Server Communication using a Socket
  • Basic ClientServer Communication using UDP Datagram
  • Loading TrustStore and KeyStore from InputStream
  • Socket example - reading a web page using a simple socket
  • Multicasting
  • Temporarily disable SSL verification for testing purposes
  • Downloading a file using Channel
• Optional
  • Optional
  • Map
  • Return default value if Optional is empty
  • Throw an exception if there is no value
  • Lazily provide a default value using a Supplier
  • Filter
  • Using Optional containers for primitive number types
  • Run code only if there is a value present
  • FlatMap
• Enums
  • Enums
  • Declaring and using a basic enum
  • Enums with constructors
  • Enums with Abstract Methods
  • Implements Interface
  • Implement Singleton pattern with a single-element enum
  • Using methods and static blocks
  • Zero instance enum
  • Documenting enums
  • Enum constant specific body
  • Enum as a bounded type parameter
  • Getting the values of an enum
  • Compare and Contains for Enum values
  • Enum Polymorphism Pattern
  • Enum with properties fields
  • Get enum constant by name
  • Convert enum to String
  • Enums with static fields
• HttpURLConnection
  • HttpURLConnection
  • Get response body from a URL as a String
  • POST data
  • Delete resource
  • Check if resource exists
• Annotations
  • Annotations
  • The idea behind Annotations
  • Defining annotation types
  • Runtime annotation checks via reflection
  • Built-in annotations
  • Compile time processing using annotation processor
  • Repeating Annotations
  • Inherited Annotations
  • Getting Annotation values at run-time
  • Annotations for this and receiver parameters
  • Add multiple annotation values
• Audio
  • Audio
  • Play a MIDI file
  • Play an Audio file Looped
  • Basic audio output
  • Bare metal sound
• Data Class
  • Date Class
  • Convert java.util.Date to java.sql.Date
  • A basic date output
  • Java 8 LocalDate and LocalDateTime objects
  • Converting Date to a certain String format
  • Creating a Specific Date
  • Creating Date objects
  • Time Zones and java.util.Date
  • Comparing Date objects
  • LocalTime
  • Converting String into Date
  • Convert formatted string representation of date to Date object
• Calendar and its Subclasses
  • Calendar and its Subclasses
  • Creating Calendar objects
  • Increasing Decreasing calendar fields
  • Finding AMPM
  • Subtracting calendars
• Nashorn JavaScript engine
  • Nashorn JavaScript engine
  • Execute JavaScript file
  • Intercept script output
  • Hello Nashorn
  • Evaluate Arithmetic Strings
  • Set global variables
  • Set and get global variables
  • Usage of Java objects in JavaScript in Nashorn
  • Implementing an interface from script
• Java Native Interface (JNI)
  • Java Native Interface
  • Calling C methods from Java
  • Calling Java methods from C callback
  • Loading native libraries
• Remote Method Invocation (RMI)
  • Remote Method Invocation RMI
  • Callback invoking methods on a client
  • Client-Server invoking methods in one JVM from another
  • Simple RMI example with Client and Server implementation
• Iterator and Iterable
  • Iterator and Iterable
  • Creating your own Iterable.
  • Removing elements using an iterator
  • Using Iterable in for loop
  • Using the raw iterator
• Operators
  • Operators
  • The IncrementDecrement Operators --
  • The Conditional Operator
  • The Bitwise and Logical Operators
  • Checking setting clearing and toggling individual bits. Using long as bit mask
  • Operator Precedence
  • The Arithmetic Operators -
  • The String Concatenation Operator
  • The Instanceof Operator
  • The Assignment Operators - and
  • The conditional-and and conditional-or Operators and
  • The Shift Operators and
  • The Equality Operators
  • The Lambda operator -
  • The Relational Operators
• Asserting
  • Asserting
  • Checking arithmetic with assert
• Scanner
  • Scanner
  • General Pattern that does most commonly asked about tasks
  • Using custom delimiters
  • Reading system input using Scanner
  • Reading file input using Scanner
  • Read the entire input as a String using Scanner
  • Read an int from the command line
  • Carefully Closing a Scanner
• Properties Class
  • Properties Class
  • Loading properties
  • Property files caveat trailing whitespace
  • Saving Properties as XML
• Preferences
  • Preferences
  • Using preferences
  • Adding event listeners
  • Getting sub-nodes of Preferences
  • Exporting preferences
  • Importing preferences
  • Removing event listeners
  • Coordinating preferences access across multiple application instances
  • Getting preferences values
  • Setting preferences values
• Reflection API
  • Reflection API
  • Introduction
  • Dynamic Proxies
  • Misuse of Reflection API to change private and final variables
  • Getting and Setting fields
  • Evil Java hacks with Reflection
  • Call constructor
  • Get Class given its fully qualified name
  • Call overloaded constructors using reflection
  • Invoking a method
  • Call constructor of nested class
  • Getting the Constants of an Enumeration
• Constructors
  • Constructors
  • Default Constructor
  • Call parent constructor
  • Constructor with Arguments
• ByteBuffer
  • ByteBuffer
  • Basic Usage - Creating a ByteBuffer
  • Basic Usage - Using DirectByteBuffer
  • Basic Usage - Write Data to the Buffer
• Serialization
  • Serialization
  • Basic Serialization in Java
  • Custom Serialization
  • Versioning and serialVersionUID
  • Serialization with Gson
  • Custom JSON Deserialization with Jackson
  • Serialization with Jackson 2
• JSON in Java
  • JSON in Java
  • Using Jackson Object Mapper
  • JSON To Object Gson Library
  • JSONObject.NULL
  • JSON Builder - chaining methods
  • Object To JSON Gson Library
  • JSON Iteration
  • optXXX vs getXXX methods
  • Encoding data as JSON
  • Decoding JSON data
  • Extract single element from JSON
  • JsonArray to Java List Gson Library
  • Deserialize JSON collection to collection of Objects using Jackson
• Random Number Generation
  • Random Number Generation
  • Pseudo Random Numbers
  • Pseudo Random Numbers in Specific Range
  • Generating cryptographically secure pseudorandom numbers
  • Generating Random Numbers with a Specified Seed
  • Select random numbers without duplicates
  • Generating Random number using apache-common lang3
• Recursion
  • Recursion
  • The basic idea of recursion
  • Deep recursion is problematic in Java
  • Types of Recursion
  • Computing the Nth Fibonacci Number
  • Computing the Nth power of a number
  • Traversing a Tree data structure with recursion
  • StackOverflowError recursion to loop
  • Reverse a string using Recursion
  • Computing the sum of integers from 1 to N
• Polymorphism
  • Polymorphism
  • Method Overriding
  • Method Overloading
  • Polymorphism and different types of overriding
  • Adding behaviour by adding classes without touching existing code
  • Virtual functions
• StringBuilder
  • StringBuilder
  • Comparing StringBuffer StringBuilder Formatter and StringJoiner
  • Repeat a String n times
• Refernce Data Types
  • Reference Data Types
  • Instantiating a reference type
  • Dereferencing
• Bit Manipulation
  • Bit Manipulation
  • Checking setting clearing and toggling individual bits. Using long as bit mask
  • java.util.BitSet class
  • Checking if a number is a power of 2
  • Packing unpacking values as bit fragments
  • Expressing the power of 2
  • Signed vs unsigned shift
• Java Agents
  • Java Agents
  • Modifying classes with agents
  • Adding an agent at runtime
  • Setting up a basic agent
• Encapsulation
  • Encapsulation
  • Encapsulation to maintain invariants
  • Encapsulation to reduce coupling
• Type Conversion
  • Type Conversion
  • Numeric primitive casting
  • Basic Numeric Promotion
  • Non-numeric primitive casting
  • Object casting
  • Testing if an object can be cast using instanceof
• BigInteger
  • BigInteger
  • Initialization
  • BigInteger Mathematical Operations Examples
  • Comparing BigIntegers
  • Binary Logic Operations on BigInteger
  • Generating random BigIntegers
• BigDecimal
  • BigDecimal
  • Comparing BigDecimals
  • Using BigDecimal instead of float
  • Mathematical operations with BigDecimal
  • BigDecimal.valueOf
  • Initialization of BigDecimals with value zero one or ten
  • BigDecimal objects are immutable
• RSA Encryption
  • RSA Encryption
  • An example using a hybrid cryptosystem consisting of OAEP and GCM
• Varargs Variable Arguments
  • Varargs Variable Argument
  • Specifying a varargs parameter
  • Working with Varargs parameters
• ThreadLocal
  • ThreadLocal
  • Basic ThreadLocal usage
  • ThreadLocal Java 8 functional initialization
  • Multiple threads with one shared object
• Logging
  • Logging java.util.logging
  • Using the default logger
  • Logging complex messages efficiently
  • Logging levels
• static keyword
  • Using the static keyword
  • Reference to non-static member from static context
  • Using static to declare constants
  • Using static with this
• Disassembling and Decompling
  • Disassembling and Decompiling
  • Viewing bytecode with javap
• Resources on classpath
  • Resources on classpath
  • Loading default configuration
  • Loading an image from a resource
  • Finding and reading resources using a classloader
  • Loading same-name resource from multiple JARs
• log4j, log4j2
  • log4j log4j2
  • How to get Log4j
  • Setting up property file
  • Properties-File to log to DB
  • How to use Log4j in Java code
  • Basic log4j2.xml configuration file
  • Migrating from log4j 1.x to 2.x
  • Filter Logoutput by level log4j 1.x
• JVM Flags
  • JVM Flags
  • -XXaggressive
  • -XXallocClearChunks
  • -XXallocClearChunkSize
  • -XXcallProfiling
  • -XXdisableFatSpin
  • -XXdisableGCHeuristics
  • -XXdumpSize
  • -XXexitOnOutOfMemory
• Oracle Official Code Standard
  • Oracle Official Code Standard
  • Naming Conventions
  • Class Structure
  • Annotations
  • Import statements
  • Redundant Parentheses
  • Braces
  • Modifiers
  • Indentation
  • Literals
  • Lambda Expressions
  • Package declaration
  • Whitespace
  • Wrapping statements
  • Java Source Files
  • Wrapping Expressions
  • Wrapping Method Declarations
  • Variable Declarations
  • Special Characters
• Character encoding
  • Character encoding
  • Reading text from a file encoded in UTF-8
  • Writing text to a file in UTF-8
  • Getting byte representation of a string in UTF-8
• Java Memory Management
  • Java Memory Management
  • Setting the Heap PermGen and Stack sizes
  • Garbage collection
  • Memory leaks in Java
  • Finalization
  • Manually triggering GC
• Immutable Objects
  • Immutable Objects
  • Creating an immutable version of a type using defensive copying.
  • The recipe for an immutable class
  • Typical design flaws which prevent a class from being immutable
• Object Cloning
  • Object Cloning
  • Cloning performing a deep copy
  • Cloning using a copy constructor
  • Cloning by implementing Clonable interface
  • Cloning performing a shallow copy
  • Cloning using a copy factory
• Alternative Collections
  • Alternative Collections
  • Multimap in Guava Apache and Eclipse Collections
  • Apache HashBag Guava HashMultiset and Eclipse HashBag
  • Compare operation with collections - Create collections
• Lists
  • Lists
  • Sorting a generic list
  • Convert a list of integers to a list of strings
  • Classes implementing List - Pros and Cons
  • Finding common elements between 2 lists
  • Creating a List
  • Positional Access Operations
  • Iterating over elements in a list
  • Removing elements from list B that are present in the list A
  • Creating Adding and Removing element from an ArrayList
  • In-place replacement of a List element
  • Making a list unmodifiable
  • Moving objects around in the list
• BufferedWriter
  • BufferedWriter
  • Write a line of text to File
• LocalTime
  • LocalTime
  • Amount of time between two LocalTime
  • Intro
  • Time Modification
  • Time Zones and their time difference
• Sets
  • Sets
  • Initialization
  • Basics of Set
  • Types and Usage of Sets
  • Create a list from an existing Set
  • Eliminating duplicates using Set
  • Declaring a HashSet with values
• Comparable and Comparator
  • Comparable and Comparator
  • Sorting a List using ComparableT or a ComparatorT
  • The compareTo and compare Methods
  • Natural comparable vs explicit comparator sorting
  • Creating a Comparator using comparing method
  • Sorting Map entries
• JVM Tool Interface
  • JVM Tool Interface
  • Iterate over objects reachable from object Heap 1.0
  • Get JVMTI environment
  • Example of initialization inside of Agent OnLoad method
• Nested and Inner Classes
  • Nested and Inner Classes
  • A Simple Stack Using a Nested Class
  • Static vs Non Static Nested Classes
  • Access Modifiers for Inner Classes
  • Anonymous Inner Classes
  • Create instance of non-static inner class from outside
  • Method Local Inner Classes
  • Accessing the outer class from a non-static inner class
• Apache Commons Lang
  • Apache Commons Lang
  • Implement equals method
  • Implement hashCode method
  • Implement toString method
• Getters and Setter
  • Getters and Setters
  • Using a setter or getter to implement a constraint
  • Adding Getters and Setters
  • Why Use Getters and Setters
• The Classpath
  • The Classpath
  • Different ways to specify the classpath
  • Adding all JARs in a directory to the classpath
  • Load a resource from the classpath
  • Classpath path syntax
  • Dynamic Classpath
  • What the classpath means how searches work
  • The bootstrap classpath
  • Mapping classnames to pathnames
• Bytecode Modification
  • Bytecode Modification
  • What is Bytecode
  • How to edit jar files with ASM
  • How to load a ClassNode as a Class
  • How to rename classes in a jar file
  • Javassist Basic
• XML Parsing using JAXP
  • XML Parsing using the JAXP APIs
  • Parsing a document using the StAX API
  • Parsing and navigating a document using the DOM API
• Reference Types
  • Reference Types
  • Different Reference Types
• Localization and Internationalization
  • Localization and Internationalization
  • Automatically formatted Dates using locale
  • String Comparison
  • Locale
• JAX-WS
  • JAX-WS
  • Basic Authentication
• XML XPath Evaluation
  • XML XPath Evaluation
  • Evaluating a NodeList in an XML document
  • Parsing multiple XPath Expressions in a single XML
  • Parsing single XPath Expression multiple times in an XML
• Performance Tuning
  • Java Performance Tuning
  • Reducing amount of Strings
  • An evidence-based approach to Java performance tuning
  • General approach
• Parallel programming with ForkJoin framework
  • Parallel programming with ForkJoin framework
  • ForkJoin Tasks in Java
• Common Pitfalls
  • Common Java Pitfalls
  • Pitfall using to compare primitive wrappers objects such as Integer
  • Pitfall using to compare strings
  • Pitfall forgetting to free resources
  • Pitfall testing a file before attempting to open it.
  • Pitfall thinking of variables as objects
  • Pitfall memory leaks
  • Pitfall - Catching Throwable Exception Error or RuntimeException
  • Pitfall Not understanding that String is an immutable class
  • Pitfall - Missing a break in a switch case
  • Pitfall - Ignoring or squashing exceptions
  • Pitfall combining assignment and side-effects
  • Pitfall - String concatenation in a loop does not scale
  • Pitfall - Throwing Throwable Exception Error or RuntimeException
  • Pitfall concurrent modification exceptions
  • Pitfall - Ignoring method visibility
  • Pitfall Runtime.exec Process and ProcessBuilder dont understand shell syntax
  • Pitfall - Using new to create primitive wrapper instances is inefficient
  • Pitfall - Misplaced semicolons and missing braces
  • Pitfall incorrect use of wait notify
  • Pitfall - The overheads of creating log messages
• Non-Access Modifiers
  • Non-Access Modifiers
  • final
  • static
  • abstract
  • strictfp
  • synchronized
  • transient
  • volatile
• Java Compiler
  • Java Compiler - javac
  • The javac command - getting started
  • Mapping classnames to pathnames
  • Compiling for a different version of Java
• XJC
  • XJC
  • Generating Java code from simple XSD file
• Installing Java Standard Edition
  • Installing Java Standard Edition
  • Setting %PATH% and %JAVA_HOME% after installing on Windows
  • Installing a Java JDK on Linux
  • Installing a Java JDK on macOS
  • Differences between Java SE JRE or Java SE JDK distributions
  • Installing a Java JDK or JRE on Windows
  • Selecting an appropriate Java SE release
  • Java release and version naming
  • Configuring and switching Java versions on Linux using alternatives
  • What do I need for Java Development
  • Post-installation checking and configuration on Linux
  • Installing oracle java on Linux with latest tar file
  • What is the difference between Oracle Hotspot and OpenJDK
• Process
  • Process
  • Pitfall Runtime.exec Process and ProcessBuilder dont understand shell syntax
  • Simple example Java version 1.5
  • ch.vorburger.exec
  • Using the ProcessBuilder class
  • Blocking vs. Non-Blocking Calls
• Command line argument processing
  • Command line Argument Processing
  • Argument processing using GWT ToolBase
  • Processing arguments by hand
• Dates and Time using java.time
  • Dates and Time java.time.
  • Calculate Difference between 2 LocalDates
  • Operations on dates and times
  • Instant
  • Simple Date Manipulations
  • Usage of various classes of Date Time API
  • Date Time Formatting
  • Date and time
• Fluent Interface
  • Fluent Interface
  • Fluent programming style
  • Truth - Fluent Testing Framework
• XOM - XML Object Model
  • XOM - XML Object Model
  • Reading a XML file
  • Writing to a XML File
• Just in Time JIT compiler
  • Just in Time JIT compiler
  • Overview
• FTP File Transfer Protocol
  • FTP File Transfer Protocol
  • Connecting and Logging Into a FTP Server
• Java Native Access JNI
  • Java Native Access
  • Introduction to JNA
• Modules
  • Modules
  • Defining a basic module
• Pitfalls - exceptions
  • Java Pitfalls - Exception usage
  • Pitfall - Catching Throwable Exception Error or RuntimeException
  • Pitfall - Ignoring or squashing exceptions
  • Pitfall - Throwing Throwable Exception Error or RuntimeException
  • Pitfall - Using exceptions for normal flowcontrol
  • Pitfall - Catching InterruptedException
  • Pitfall - Excessive or inappropriate stacktraces
  • Pitfall - Directly subclassing Throwable
• Pitfalls - language syntax
  • Java Pitfalls - Language syntax
  • Pitfall - Missing a break in a switch case
  • Pitfall - Leaving out braces the dangling if and dangling else problems
  • Pitfall - Declaring classes with the same names as standard classes
  • Pitfall - Ignoring method visibility
  • Pitfall - Octal literals
  • Pitfall - Using to test a boolean
  • Pitfall - Misplaced semicolons and missing braces
  • Pitfall - Wildcard imports can make your code fragile
  • Pitfall Using assert for argument or user input validation
  • Pitfall - Overloading instead of overriding
  • Pitfall of Auto-Unboxing Null Objects into Primitives
• ServiceLoader
  • ServiceLoader
  • Logger Service
  • Simple ServiceLoader Example
• ClasssLoader
  • Classloaders
  • Implementing a custom classLoader
  • Loading an external .class file
  • Instantiating and using a classloader
• Object References
  • Object References
  • Object References as method parameters
• Pitfalss - performance
  • Java Pitfalls - Performance Issues
  • Pitfall - String concatenation in a loop does not scale
  • Pitfall - Using size to test if a collection is empty is inefficient.
  • Pitfall - Using new to create primitive wrapper instances is inefficient
  • Pitfall - Interning strings so that you can use is a bad idea
  • Pitfall - Efficiency concerns with regular expressions
  • Pitfall - Small reads writes on unbuffered streams are inefficient
  • Pitfall - Over-use of primitive wrapper types is inefficient
  • Pitfall - Iterating a Maps keys can be inefficient
  • Pitfall - The overheads of creating log messages
  • Pitfall - Calling new StringString is inefficient
  • Pitfall - Calling System.gc is inefficient
• Creating Images Programmatically
  • Creating Images Programmatically
  • Creating a simple image programmatically and displaying it
  • Save an Image to disk
  • Setting individual pixels color in BufferedImage
  • Specifying image rendering quality
  • Creating an image with BufferedImage class
  • Editing and re-using image with BufferedImage
  • How to scale a BufferedImage
• Applets
  • Applets
  • Minimal Applet
  • Creating a GUI
  • Open links from within the applet
  • Loading images audio and other resources
• NIO Networking
  • NIO - Networking
  • Using Selector to wait for events example with OP CONNECT
• New File I/O
  • New File IO
  • Creating paths
  • Manipulating paths
  • Retrieving information about a path
  • Retrieving information using the filesystem
  • Reading files
  • Writing files
• Secure objects
  • Secure objects
  • SealedObject javax.crypto.SealedObject
  • SignedObject (java.security.SignedObject)
• Pitfalls - threads and concurrency
  • Java Pitfalls - Threads and Concurrency
  • Pitfall - Extending java.lang.Thread
  • Pitfall - Too many threads makes an application slower.
  • Pitfall - Thread creation is relatively expensive
  • Pitfall Shared variables require proper synchronization
  • Pitfall incorrect use of wait notify
• Splitting a string into fixed length parts
  • Splitting a string into fixed length parts
  • Break a string up into substrings all of a known length
  • Break a string up into substrings all of variable length
• Pitfalls - nulls and NullPointerException
  • Java Pitfalls - Nulls and NullPointerException
  • Pitfall - Making good unexpected nulls
  • Pitfall - Using null to represent an empty array or collection
  • Pitfall - Returning null instead of throwing an exception
  • Pitfall - Not checking if an IO stream isnt even initialized when closing it
  • Pitfall - Using Yoda notation to avoid NullPointerException
  • Pitfall - Unnecessary use of Primitive Wrappers can lead to NullPointerExceptions
• SecurityManager
  • SecurityManager
  • Sandboxing classes loaded by a ClassLoader
  • Enabling the SecurityManager
  • Implementing policy deny rules
• JNDI
  • JNDI
  • RMI through JNDI
• super keyword
  • super keyword
  • Super keyword use with examples
• java.util.Objects class
  • The java.util.Objects Class
  • Basic use for object null check
  • Objects.nonNull method reference use in stream api
• Java command: java and javaw
  • The Java Command - java and javaw
  • Entry point classes
  • Running an executable JAR file
  • Running a Java applications via a main class
  • Troubleshooting the java command
  • Running a Java application with library dependencies
  • Spaces and other special characters in arguments
  • Java Options
• Atomic types
  • Atomic Types
  • Creating Atomic Types
  • Motivation for Atomic Types
• Floating Point Operations
  • Java Floating Point Operations
  • Comparing floating point values
  • OverFlow and UnderFlow
  • Formatting the floating point values
  • Strict Adherence to the IEEE Specification
• Converting to and from strings
  • Converting to and from Strings
  • Converting String to other datatypes.
  • Conversion to from bytes
  • Base64 Encoding Decoding
  • Converting other datatypes to String
  • Getting a String from an InputStream
  • Parsing Strings to a Numerical Value
• sun.misc.Unsafe
  • sun.misc.Unsafe
  • Instantiating sun.misc.Unsafe via reflection
  • Getting Instance of Unsafe
  • Uses of Unsafe
  • Instantiating sun.misc.Unsafe via bootclasspath
• Java Memory Model
  • Java Memory Model
  • Motivation for the Memory Model
  • Happens-before relationships
  • Happens-before reasoning applied to some examples
  • How to avoid needing to understand the Memory Model
• Java deployment
  • Java deployment
  • Making an executable JAR from the command line
  • Creating JAR WAR and EAR files
  • Introduction to Java Web Start
  • Creating an UberJAR for an application and its dependencies
• Java plugin system implementations
  • Java plugin system implementations
  • Using URLClassLoader
• Queues and deques
  • Queues and Deques
  • The usage of the PriorityQueue
  • LinkedList as a FIFO Queue
  • Stacks
  • BlockingQueue
  • Deque
  • Queue Interface
• Runtime commands
  • Runtime Commands
  • Adding shutdown hooks
• NumberFormat
  • NumberFormat
  • NumberFormat
• Security and Cryptograhy
  • Security Cryptography
  • Compute Cryptographic Hashes
  • Generate Cryptographically Random Data
  • Generate Public Private Key Pairs
  • Compute and Verify Digital Signatures
  • Encrypt and Decrypt Data with Public Private Keys
• Java Virtual Machine JVM
  • Java Virtual Machine JVM
  • These are the basics.
• Unit Testing
  • Unit Testing
  • What is Unit Testing
• JavaBean
  • JavaBean
  • Basic Java Bean
• Expressions
  • Expressions
  • Operator Precedence
  • Expression evaluation order
  • Expression Basics
  • Constant Expressions
• Literals
  • Literals
  • Using underscore to improve readability
  • Hexadecimal Octal and Binary literals
  • Boolean literals
  • Escape sequences in literals
  • Decimal Integer literals
  • String literals
  • The Null literal
  • Floating-point literals
  • Character literals
• Java SE 8 Features
  • Java SE 8 Features
  • New Java SE 8 programming language features
  • New Java SE 7 programming language features
• Java SE 7 Features
  • Java SE 7 Features
  • New Java SE 7 programming language features
  • Binary Literals
  • The try-with-resources statement
  • Underscores in Numeric Literals
  • Type Inference for Generic Instance Creation
  • Strings in switch Statements
• Packages
  • Packages
  • Using Packages to create classes with the same name
  • Using Package Protected Scope
• Concurrency and Money
  • Currency and Money
  • Add custom currency
• Concurrent Collections
  • Concurrent Collections
  • Thread-safe Collections
  • Concurrent Collections
  • Insertion into ConcurrentHashMap
• Using ThreadPoolExecutor in multi-threaded applications
  • Using ThreadPoolExecutor in MultiThreaded applications.
  • Performing Asynchronous Tasks Where No Return Value Is Needed Using a Runnable Class Instance
  • Performing Asynchronous Tasks Where a Return Value Is Needed Using a Callable Class Instance
  • Defining Asynchronous Tasks Inline using Lambdas
• Java Editions, versions, releases and distributions
  • Java Editions Versions Releases and Distributions
  • Differences between Java SE JRE or Java SE JDK distributions
  • Java SE Versions
  • Differences between Java EE Java SE Java ME and JavaFX
  • What is the difference between Oracle Hotspot and OpenJDK
• Dynamic method dispatch
  • Dynamic Method Dispatch
  • Dynamic Method Dispatch - Example Code
• JMX
  • JMX
  • Simple example with Platform MBean Server
• Security and cryptography
  • Security Cryptography
  • The JCE
  • Keys and Key Management
  • Common Java vulnerabilities
  • Networking Concerns
  • Randomness and You
  • Hashing and Validation
• Generating Java Code
  • Generating Java Code
  • Generate POJO From JSON
• JShell
  • JShell
  • Editting Snippets
  • Entering and Exiting JShell
  • Expressions
  • Methods and Classes
  • Variables
• Benchmarks
  • Benchmarks
  • Simple JMH example
• Collection Factory Methods
  • Collection Factory Methods
  • ListE Factory Method Examples
  • SetE Factory Method Examples
  • MapK V Factory Method Examples
• Multi-release JAR files
  • Multi-Release JAR Files
  • Example of a multi-release Jar files contents
  • Creating a multi-release Jar using the jar tool
  • URL of a loaded class inside a multi-release Jar
• Stack-Walking API
  • Stack-Walking API
  • Print all stack frames of the current thread
  • Print current caller class
  • Showing reflection and other hidden frames
• TreeMap and TreeSet
  • TreeMap and TreeSet
  • TreeMap of a simple Java type
  • TreeSet of a simple Java Type
  • TreeMapTreeSet of a custom Java type
  • TreeMap and TreeSet Thread Safety
• Sockets
  • Sockets
  • Read from socket
• Java Sockets
  • Java Sockets
  • A simple TCP echo back server
• Using other scripting languages in Java
  • Using Other Scripting Languages in Java
  • Evaluating A javascript file in -scripting mode of nashorn
• Functional interfaces
  • Functional Interfaces
  • List of standard Java Runtime Library functional interfaces by signature
• List vs. set
  • List vs SET
  • List vs Set
• 2D graphics
  • 2D Graphics in Java
  • Example 1 Draw and Fill a Rectangle Using Java
  • Example 2 Drawing and Filling Oval
• Reflection
  • Class - Java Reflection
  • getClass method of Object class
• Deque interface
  • Dequeue Interface
  • Adding Elements to Deque
  • Removing Elements from Deque
  • Retrieving Element without Removing
  • Iterating through Deque
• Enum Map
  • Enum Map
  • Enum Map Book Example
• EnumSet class
  • EnumSet class
  • Enum Set Example
• Local Inner class
  • Local Inner Class
  • Local Inner Class
• Java Print Service
  • Java Print Service
  • Building the Doc that will be printed
  • Discovering the available print services
  • Defining print request attributes
  • Discovering the default print service
  • Creating a print job from a print service
  • Listening print job request status change
• Immutable class
  • Immutable Class
  • Example without mutable refs
  • What is the advantage of immutability
  • Rules to define immutable classes
  • Example with mutable refs
• String Tokenizer
  • String Tokenizer
  • StringTokenizer Split by space
  • StringTokenizer Split by comma
• File upload to S3 / AWS
  • FileUpload to AWS
  • Upload file to s3 bucket
• Readers and writers
  • Readers and Writers
  • BufferedReader
  • StringWriter Example
• Hashtable
  • Hashtable
  • Hashtable
• Enum starting with a number
  • Enum starting with number
  • Enum with name at begining
• SortedMap
  • SortedMap
  • Introduction to sorted Map.
• WeakHashMap
  • WeakHashMap
  • Concepts of WeakHashmap
• LinkedHashMap
  • LinkedHashMap
  • Java LinkedHashMap class
• StringBuffer
  • StringBuffer
  • String Buffer class
• Choosing Collections
  • Choosing Collections
  • Java Collections Flowchart
• C++ Comparison
  • C++ Comparison
  • Static Class Members
  • Classes Defined within Other Constructs
  • Pass-by-value Pass-by-reference
  • Inheritance vs Composition
  • Outcast Downcasting
  • Abstract Methods Classes
• CompletableFuture
  • CompletableFuture
  • Simple Example of CompletableFuture
  • Convert blocking method to asynchonous
• Contributors