Core Java – All Topics | slothnerds.com

Topic	Sub-Topics
JVM Architecture & Garbage Collection	Java 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
OOPs	Class & Objects
	Variables: Primitive Types
	Variables: Type Casting
	Autoboxing
	Encapsulation – Access Specifiers
Inheritance	Diamond Problem
	Final Keyword
Polymorphism	Compile Time Polymorphism
	Runtime Polymorphism
Abstraction	Abstract Class
	Interfaces
	Marker Interface
	Functional Interface
	default and static methods in Interfaces
Arrays	Linear Array
	2D Array
String	String
	String Pool
	StringBuilder
	StringBuffer
Exceptions	Checked & Unchecked Exceptions
	Throws
	Throw
	Finally
	try-with-resources
	Suppressed Exceptions
	How to Create Custom Exception for your Project
Collections	Collection 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


Generics	Generic & Parameterized Types
	Generic Methods & Generic Constructors
	Generics Restrictions
	Enum Class
	enums with State & Behavior

Concurrency & Multithreading	Multithreading 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 Programming	Callable and future
	Deadlock
	Synchronized I
	Synchronized blocks
	Synchronization Best Practices
	Synchronization + Demo : Synchronize access to shared mutable data
	Locks VS synchronization
	Semaphores
Streams	Functional-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 Problems	Dining 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