Topics

• Getting started with Java Language
• Inheritance
• Streams
• Exceptions and exception handling
• Collections
• Lambda Expressions
• Generics
• File I/O
• Arrays
• Interfaces
• Maps
• Strings
• InputStreams and OutputStreams
• Default Methods
• Basic Control Structures
• Concurrent Programming (Threads)
• Console I/O
• Singletons
• Visibility (controlling access to members of a class)
• Autoboxing
• Documenting Java Code
• Executor, ExecutorService and Thread pools
• Object Class Methods and Constructor
• Primitive Data Types
• Networking
• Optional
• HttpURLConnection
• Annotations
• Date Class
• Java Native Interface
• Remote Method Invocation (RMI)
• Iterator and Iterable
• Operators
• Scanner
• Properties Class
• Reflection API
• Random Number Generation
• Recursion
• Polymorphism
• Getting started with Design patterns
• StringBuilder
• Bit Manipulation
• Strategy Pattern
• Singleton
• Resources (on classpath)
• Java Memory Management
• Immutable Objects
• Debugging ssh problems
• Lists
• Comparable and Comparator
• Nested and Inner Classes
• Getters and Setters
• The Classpath
• Java Performance Tuning
• Common Java Pitfalls
• Java Compiler - 'javac'
• Installing Java (Standard Edition)
• Command line Argument Processing
• Just in Time (JIT) compiler
• Java Native Access
• Java Pitfalls - Exception usage
• Java Pitfalls - Language syntax
• Classloaders
• Java Pitfalls - Performance Issues
• Java Pitfalls - Threads and Concurrency
• Java Pitfalls - Nulls and NullPointerException
• The java.util.Objects Class
• The Java Command - 'java' and 'javaw'
• Atomic Types
• Java Floating Point Operations
• Converting to and from Strings
• sun.misc.Unsafe
• Java Memory Model
• Java deployment
• Java RESTful Web Services (JAX-RS)
• The WebSockets API
• Java Messaging Service (JMS)
• Configuring JAX-RS in Jersey
• Iterator Pattern
• Queues and Deques
• Publish-Subscribe
• MVC, MVVM, MVP
• The Javamail API
• JavaBean
• Expressions
• Literals
• Java Editions, Versions, Releases and Distributions
• TreeMap and TreeSet
• Readers and Writers

Examples

• Creating Your First Java Program
• Catching an exception with try-catch
• Using Lambda Expressions to Sort a Collection
• Creating a Generic Class
• Throwing an exception
• Creating and Initializing Arrays
• Creating an Array from a Collection
• Reading all bytes to a byte[]
• Comparing Strings
• Basic usage of default methods
• The Diamond
• Basic Multithreading
• Creating a List from an Array
• Changing the case of characters within a String
• ThreadPoolExecutor
• Retrieving value from computation - Callable
• Scheduling tasks to run at a fixed time, after a delay or repeatedly
• Basic Client and Server Communication using a Socket
• hashCode() method
• Built-in annotations
• Sorting a generic list
• Simple Resource
• Comparing floating point values
• The String Concatenation Operator (+)
• The Arithmetic Operators (+, -, *, /, %)
• The Equality Operators (==, !=)
• The Increment/Decrement Operators (++/--)
• Reading an image from a file
• The try-with-resources statement
• Using 'final' to restrict inheritance and overriding
• Creating and reading stacktraces
• Enum Singleton
• Writing a byte[] to a file
• GET method types
• Hiding strategy implementation details
• Defining annotation types
• Merging, combine and composing Maps
• Building Javadocs From the Command Line
• Introduction to Java lambdas
• The basic idea of recursion
• The Java Exception Hierarchy - Unchecked and Checked Exceptions
• Reading a whole file at once
• Finalization
• Thread safe Singleton with double checked locking
• Copying arrays
• Reading a file with a Scanner
• Packing / unpacking values as bit fragments
• Why use Default Methods?
• Reversing Strings
• Setting %PATH% and %JAVA_HOME% after installing on Windows
• The Conditional Operator (? :)
• Java Jersey CORS filter for Cross Origin Requests
• Introduction
• Iterating Map Entries Efficiently
• Comparing StringBuffer, StringBuilder, Formatter and StringJoiner
• Pitfall - Unnecessary use of Primitive Wrappers can lead to NullPointerExceptions
• The Iterator Pattern
• Publish-Subscribe in Java
• BufferedReader
• Hexadecimal, Octal and Binary literals
• Removing elements using an iterator
• Computing the Nth Fibonacci Number
• How do you change the size of an array?
• Lazily provide a default value using a Supplier
• Finding an element in an array
• Computing the sum of integers from 1 to N
• Computing the Nth power of a number
• Parsing Strings to a Numerical Value
• Pitfall: using == to compare primitive wrappers objects such as Integer
• Operator Precedence
• Creating an immutable version of a type using defensive copying.
• The recipe for an immutable class
• Garbage collection
• The Bitwise and Logical Operators (~, &, |, ^)
• Positional Access Operations
• Iterating over elements in a list
• Reading from a binary file
• Narrowing and Widening of object references
• Memory consumption of primitives vs. boxed primitives
• Sorting a List using Comparable<T> or a Comparator<T>
• Memory and Computational Overhead of Autoboxing
• finalize() method
• Converting String to other datatypes.
• Primitive Types Cheatsheet
• Create a Map based on a Stream
• Reverse a string using Recursion
• The Instanceof Operator
• The Assignment Operators (=, +=, -=, *=, /=, %=, <<=, >>= , >>>=, &=, |= and ^=)
• DELETE method
• POST Method
• Modifiers in Interfaces
• Using Java 8 functional interfaces to implement the Strategy pattern
• The conditional-and and conditional-or Operators ( && and || )
• Copying a file using InputStream and OutputStream
• Reading a file using Channel and Buffer
• Using underscore to improve readability
• Java Jersey Configuration
• Different ways to specify the classpath
• Adding all JARs in a directory to the classpath
• Classpath path syntax
• Copying a file using Channel
• Reading a file using BufferedInputStream
• Writing a file using Channel and Buffer
• Writing a file using PrintStream
• The Shift Operators (<<, >> and >>>)
• Java Closures with lambda expressions.
• Model View Controller (MVC)
• Exception Mapper
• The usage of the PriorityQueue
• LinkedList as a FIFO Queue
• Deep recursion is problematic in Java
• Stacks
• Pitfall - Ignoring method visibility
• Pitfall - Missing a ‘break’ in a 'switch' case
• Pitfall: forgetting to free resources
• Pitfall: memory leaks
• Pitfall - Ignoring or squashing exceptions
• Pitfall: concurrent modification exceptions
• Sending an email to a POP3 email server
• Singleton (Java)
• The 'javac' command - getting started
• Creating a WebSocket communication
• UriInfo
• Pitfall: using == to compare strings
• Pitfall - The overheads of creating log messages
• Using a setter or getter to implement a constraint
• Pitfall - String concatenation in a loop does not scale
• Selecting an appropriate Java SE release
• Java release and version naming
• BlockingQueue
• SubResources
• Pitfall - Catching Throwable, Exception, Error or RuntimeException
• Lambdas and memory utilization
• Add two `int` arrays using a Threadpool
• Differences between Java SE JRE or Java SE JDK distributions
• What is the difference between Oracle Hotspot and OpenJDK
• What do I need for Java Development
• Custom parameter converters
• Name binding
• Creating ConnectionFactory
• Evil Java hacks with Reflection
• Pitfall - Throwing Throwable, Exception, Error or RuntimeException
• Setting the Heap, PermGen and Stack sizes
• FlatMap
• Connection Refused
• Connection timed out
• Blocking or redirecting standard output / error
• Queue Interface
• Pitfall: testing a file before attempting to open it.
• Installing a Java JDK on Linux
• Installing a Java JDK or JRE on Windows
• Installing a Java JDK on macOS
• Making an executable JAR from the command line
• Pitfall - Misplaced semicolons and missing braces
• Configuring and switching Java versions on Linux using alternatives
• In-place replacement of a List element
• Anonymous Inner Classes
• Accessing the contents of a ZIP file
• Post-installation checking and configuration on Linux
• Pitfall - Catching InterruptedException
• Pitfall - Leaving out braces: the "dangling if" and "dangling else" problems
• Argument processing using GWT ToolBase
• Pitfall: incorrect use of wait() / notify()
• Instantiating and using a classloader
• Implementing a custom classLoader
• Pitfall - Using 'new' to create primitive wrapper instances is inefficient
• Pitfall - Calling 'new String(String)' is inefficient
• Pitfall - Using exceptions for normal flowcontrol
• Check if resource exists
• Pitfall - Calling System.gc() is inefficient
• Pitfall - Overloading instead of overriding
• Pitfall - Octal literals
• Pitfall - Extending 'java.lang.Thread'
• Pitfall - Too many threads makes an application slower.
• Pitfall - Declaring classes with the same names as standard classes
• Mapping classnames to pathnames
• What the classpath means: how searches work
• Pitfall - Excessive or inappropriate stacktraces
• Compiling for a different version of Java
• Pitfall - Over-use of primitive wrapper types is inefficient
• Pitfall - Iterating a Map's keys can be inefficient
• Pitfall - Using size() to test if a collection is empty is inefficient.
• Pitfall - Using '==' to test a boolean
• The bootstrap classpath
• Pitfall - Using null to represent an empty array or collection
• Pitfall - "Making good" unexpected nulls
• Pitfall - Returning null instead of throwing an exception
• Pitfall - Thread creation is relatively expensive
• Pitfall: Runtime.exec, Process and ProcessBuilder don't understand shell syntax
• Basic use for object null check
• Objects.nonNull() method reference use in stream api
• Pitfall: Shared variables require proper synchronization
• Pitfall - Wildcard imports can make your code fragile
• Running an executable JAR file
• Running a Java applications via a "main" class
• Entry point classes
• Troubleshooting the 'java' command
• Running a Java application with library dependencies
• Processing arguments by hand
• Spaces and other special characters in arguments
• Annotations for 'this' and receiver parameters
• Java Options
• Pitfall: Using 'assert' for argument or user input validation
• Creating JAR, WAR and EAR files
• Introduction to Java Web Start
• Motivation for the Memory Model
• Pitfall - Using "Yoda notation" to avoid NullPointerException
• Happens-before relationships
• Happens-before reasoning applied to some examples
• Pitfall - Efficiency concerns with regular expressions
• Pitfall - Interning strings so that you can use == is a bad idea
• Pitfall: thinking of variables as objects
• How to avoid needing to understand the Memory Model
• Introduction
• Memory leaks in Java
• Advanced features of Exceptions
• The try-finally and try-catch-finally statements
• The 'throws' clause in a method declaration
• An evidence-based approach to Java performance tuning
• Constant Expressions
• Expression evaluation order
• Finding and reading resources using a classloader
• Expression Basics
• Escape sequences in literals
• Decimal Integer literals
• Boolean literals
• String literals
• The Null literal
• Floating-point literals
• Character literals
• The Lambda operator ( -> )
• Pitfall: combining assignment and side-effects
• Creating an UberJAR for an application and its dependencies
• Motivation for Atomic Types
• Differences between Java EE, Java SE, Java ME and JavaFX
• Pitfall: Not understanding that String is an immutable class
• Pitfall - Small reads / writes on unbuffered streams are inefficient
• Java SE Versions
• Pitfall - Directly subclassing `Throwable`
• Classes implementing List - Pros and Cons
• TreeMap and TreeSet Thread Safety
• The Relational Operators (<, <=, >, >=)
• StringWriter Example
• DataInputStream Example