Core Java – All Topics

TopicSub-Topics
JVM Architecture & Garbage CollectionJava Virtual Machine Architecture
Class Loading
Linking
Reflection
Runtime Data Areas
Method Area & Heap
Method Table
Garbage Collection: Introduction
Garbage Collection Algorithms
GC: Generational Collections
Demo: Tuning Heap & Analyzing GC Cycles
gc() and finalise() methods
Mark and Sweep
Detecting soft leaks
Permgen and Metaspace
Heap Size
Permgen Size
Garbage Collection and Generation sizes
Generating Heap Dumps
Choosing a garbage collector
Memory Leak Example
OOPsClass & Objects
Variables: Primitive Types
Variables: Type Casting
Autoboxing
Encapsulation – Access Specifiers
InheritanceDiamond Problem
Final Keyword
PolymorphismCompile Time Polymorphism
Runtime Polymorphism
AbstractionAbstract Class
Interfaces
Marker Interface
Functional Interface
default and static methods in Interfaces
ArraysLinear Array
2D Array
StringString
String Pool
StringBuilder
StringBuffer
ExceptionsChecked & Unchecked Exceptions
Throws
Throw
Finally
try-with-resources
Suppressed Exceptions
How to Create Custom Exception for your Project
CollectionsCollection Interface
List Interface
ArrayList
LinkedList
Dequeues
Iterator
ArrayDeque
Hash Table
LinkedHashSet
Set Interface & HashSet + Demo + Overriding hashCode & Equals
SortedSet & NavigableSet
TreeSet (Comparable & Comparator)
Exploring NavigableSet Methods
LinkedHashMap
SortedMap, NavigableMap and TreeMap
Concurrent Collections
Synchronized Collections
Latch
Cyclic barrier
Blocking queue
Delay queue
Priority queue
Concurrent maps
Exchanger
GenericsGeneric & Parameterized Types
Generic Methods & Generic Constructors
Generics Restrictions
Enum Class
enums with State & Behavior
Concurrency & MultithreadingMultithreading Theory
Processes and threads introduction
Starting threads I – Runnable
Starting threads II – Thread class
Launching Threads and Making them to Sleep!
What is time-slicing algorithm?
Benefits of multithreading
Downside of multithreading
Thread life cycle in Java
Thread Naming, Prioritization and Joining
Race Condition
Join
Java Memory Model (JMM)
Volatile Variables + Demo
Atomic Variables + Demo
Volatile
Producer and consumer
Locks
Producer consumer with locks
Thread Cooperation & Management
Sleep,Wait,Notify
Thread Interruption
Explicit Locks (Reentrant Lock)
Executor Framework
Executor Service & Future
Asynchronous ProgrammingCallable and future
Deadlock
Synchronized I
Synchronized blocks
Synchronization Best Practices
Synchronization + Demo : Synchronize access to shared mutable data
Locks VS synchronization
Semaphores
StreamsFunctional-style Programming:
Lambda Functions
Functional Interfaces
Streams
Demo: Slicing a Stream
Demo: Stream Matching Operations
Demo: Stream Finding Operations & Optional Class
Stream Reduction Operations + Demo
Mutable Reduction with Collection Operations + Demo
collect() with Collector
Demo: Collecting Stream into List & Set
Optional Class
Classic ProblemsDining Philosopher Problem
Students Library Simulation
Miner Game Simulation
Parallel Algorithms
Parallel methods versus multithreading
Merge sort
Sequential merge sort
Parallel merge sort
Comparing sorting implementations
Sum problem introduction
Sum problem – sequential approach
Sum problem – parallel implementation
Comparing sum implementations
Fork-Join Framework
Fork-join framework introduction
Fork-join framework simple example – RecursiveAction
Fork-join framework simple example – RecursiveTask<T>
Maximum finding – the algorithm
Maximum finding – running the application
Fork-join merge sort I
–MapReduce and Parallelization
MapReduce introduction – basics
MapReduce introduction – example
MapReduce and Fork-Join