Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Essential Java formulas, time complexity reference, bit manipulation tricks, and mathematical concepts used in programming and DSA.
Time Complexity (Big-O Notation)
What is Big-O?
Big-O notation describes the upper bound of an algorithm's growth rate. It tells us how the runtime or space grows as input size (n) increases.
| Notation | Name | Example | n=1000 Operations |
|---|---|---|---|
| O(1) | Constant | Array access by index | 1 |
| O(log n) | Logarithmic | Binary Search | ~10 |
| O(n) | Linear | Linear Search | 1,000 |
| O(n log n) | Linearithmic | Merge Sort | ~10,000 |
| O(n²) | Quadratic | Bubble Sort | 1,000,000 |
| O(n³) | Cubic | Matrix Multiplication | 1,000,000,000 |
| O(2ⁿ) | Exponential | Recursive Fibonacci | 1.07 × 10³⁰⁰ |
| O(n!) | Factorial | Traveling Salesman (brute) | 4.02 × 10²⁵⁶⁷ |
Growth Rate Comparison
Example
O(1) < O(log n) < O(√n) < O(n) < O(n log n) < O(n²) < O(n³) < O(2ⁿ) < O(n!)
Practical Limits (for 1 second execution)
| Complexity | Max n (approx) |
|---|---|
| O(n!) | n ≤ 12 |
| O(2ⁿ) | n ≤ 25 |
| O(n³) | n ≤ 500 |
| O(n²) | n ≤ 10,000 |
| O(n log n) | n ≤ 10,000,000 |
| O(n) | n ≤ 100,000,000 |
| O(log n) | n ≤ 10¹⁸ |
Sorting Algorithms Complexity
| Algorithm | Best | Average | Worst | Space | Stable |
|---|---|---|---|---|---|
| Bubble Sort | O(n) | O(n²) | O(n²) | O(1) | Yes |
| Selection Sort | O(n²) | O(n²) | O(n²) | O(1) | No |
| Insertion Sort | O(n) | O(n²) | O(n²) | O(1) | Yes |
| Merge Sort | O(n log n) | O(n log n) | O(n log n) | O(n) | Yes |
| Quick Sort | O(n log n) | O(n log n) | O(n²) | O(log n) | No |
| Heap Sort | O(n log n) | O(n log n) | O(n log n) | O(1) | No |
| Counting Sort | O(n + k) | O(n + k) | O(n + k) | O(k) | Yes |
| Radix Sort | O(d × (n + k)) | O(d × (n + k)) | O(d × (n + k)) | O(n + k) | Yes |
| Tim Sort | O(n) | O(n log n) | O(n log n) | O(n) | Yes |
| Bucket Sort | O(n + k) | O(n + k) | O(n²) | O(n) | Yes |
Tim Sort is used byArrays.sort()for objects andCollections.sort()in Java. Dual-Pivot Quick Sort is used byArrays.sort()for primitives.
k = range of input values, d = number of digits
Searching Algorithms Complexity
| Algorithm | Best | Average | Worst | Space | Requirements |
|---|---|---|---|---|---|
| Linear Search | O(1) | O(n) | O(n) | O(1) | None |
| Binary Search | O(1) | O(log n) | O(log n) | O(1) | Sorted array |
| Binary Search (recursive) | O(1) | O(log n) | O(log n) | O(log n) | Sorted array |
| Jump Search | O(1) | O(√n) | O(√n) | O(1) | Sorted array |
| Interpolation Search | O(1) | O(log log n) | O(n) | O(1) | Uniform distribution |
| Exponential Search | O(1) | O(log n) | O(log n) | O(1) | Sorted, unbounded |
| Ternary Search | O(1) | O(log₃ n) | O(log₃ n) | O(1) | Sorted array |
Graph Algorithm Complexity
| Algorithm | Time | Space | Use Case |
|---|---|---|---|
| BFS | O(V + E) | O(V) | Shortest path (unweighted) |
| DFS | O(V + E) | O(V) | Cycle detection, topological sort |
| Dijkstra (min-heap) | O((V + E) log V) | O(V) | Shortest path (positive weights) |
| Bellman-Ford | O(V × E) | O(V) | Shortest path (negative weights) |
| Floyd-Warshall | O(V³) | O(V²) | All-pairs shortest path |
| Kruskal's MST | O(E log E) | O(V) | Minimum spanning tree |
| Prim's MST (min-heap) | O((V + E) log V) | O(V) | Minimum spanning tree |
| Topological Sort | O(V + E) | O(V) | Task scheduling (DAG) |
| Tarjan's SCC | O(V + E) | O(V) | Strongly connected components |
| A* Search | O(E) | O(V) | Heuristic-guided pathfinding |
V = vertices (nodes), E = edges
Tree Algorithm Complexity
| Operation | BST (avg) | BST (worst) | AVL Tree | Red-Black Tree |
|---|---|---|---|---|
| Search | O(log n) | O(n) | O(log n) | O(log n) |
| Insert | O(log n) | O(n) | O(log n) | O(log n) |
| Delete | O(log n) | O(n) | O(log n) | O(log n) |
| Traversal | O(n) | O(n) | O(n) | O(n) |
| Height | O(log n) avg | O(n) | O(log n) | O(log n) |
Tree Height Formula:
| Minimum height of BST with n nodes | ⌊log₂(n)⌋ |
| Maximum height of BST with n nodes | n - 1 (degenerate/skewed) |
| Height of complete binary tree | ⌊log₂(n)⌋ |
| Number of nodes in complete binary tree of height h | 2^(h+1) - 1 |
| Number of leaf nodes in complete binary tree | ⌈n/2⌉ |
Dynamic Programming Patterns
| Problem | Time | Space | Approach |
|---|---|---|---|
| Fibonacci | O(n) | O(1) with optimization | Bottom-up tabulation |
| Longest Common Subsequence | O(m × n) | O(m × n) or O(min(m,n)) | 2D table |
| Longest Increasing Subsequence | O(n log n) | O(n) | Binary search + patience sort |
| 0/1 Knapsack | O(n × W) | O(n × W) or O(W) | 2D or 1D DP |
| Coin Change (min coins) | O(n × amount) | O(amount) | 1D DP |
| Edit Distance | O(m × n) | O(m × n) | 2D table |
| Matrix Chain Multiplication | O(n³) | O(n²) | Interval DP |
| Subset Sum | O(n × sum) | O(sum) | Boolean DP |
Java String Pool & Memory Formulas
String Pool Behavior
java example
// String Literal → Pool
String s1 = "Hello"; // Goes to String Pool
String s2 = "Hello"; // Reuses from Pool
System.out.println(s1 == s2); // true (same reference)
// new String() → Heap
String s3 = new String("Hello"); // New object in Heap
System.out.println(s1 == s3); // false (different reference)
System.out.println(s1.equals(s3)); // true (same content)
// intern() → Returns Pool reference
String s4 = s3.intern();
System.out.println(s1 == s4); // true (pool reference)Memory created for String s = new String("Hello"):
- If "Hello" is NOT in pool: 2 objects created (1 in pool + 1 in heap)
- If "Hello" IS already in pool: 1 object created (only in heap)
String Memory Calculation
Example
String object memory = 12 bytes (header) + 4 bytes (hash) + 4 bytes (char[] ref)
= ~24 bytes (with padding)
char[] memory = 12 bytes (array header) + (n × 2 bytes for characters) + padding
Total for "Hello" (5 chars):
= 24 + 12 + (5 × 2) + 2(padding) = 48 bytes approximately
Note: Java 9+ uses compact strings (Latin-1 = 1 byte per char, UTF-16 = 2 bytes)
StringBuilder vs String Concatenation
String concatenation in loop (n iterations)
Memory: O(n²) — creates n intermediate String objects
Time: O(n²) — copies characters repeatedly
StringBuilder in loop (n iterations)
Memory: O(n) — single resizable buffer
Time: O(n) — amortized O(1) per append
StringBuilder initial capacity = 16 characters
Growth formula: newCapacity = (oldCapacity * 2) + 2
JVM Memory Formulas
Object Memory Layout (64-bit JVM with CompressedOops)
Code example
Object Header = 12 bytes (8 mark word + 4 compressed class pointer)
Array Header = 16 bytes (12 + 4 bytes for length)
Object size is padded to multiple of 8 bytes.
Example: class with 1 int and 1 reference
= 12 (header) + 4 (int) + 4 (reference) + 4 (padding) = 24 bytesHeap Memory Calculation
Example
Total Heap = Young Generation + Old Generation
Young Generation = Eden + Survivor0 + Survivor1
Default ratio: Eden:S0:S1 = 8:1:1
If total heap = 1GB:
Young Gen (default 1/3) = ~333MB
Old Gen (default 2/3) = ~667MB
Eden = 333MB × 8/10 = ~266MB
Each Survivor = 333MB × 1/10 = ~33MB
GC Tuning Formulas
| -Xms = Initial heap size (recommended | same as -Xmx for production) |
| -Xmx = Maximum heap size (recommended | 50-70% of available RAM) |
| -Xss = Thread stack size (default | 512KB - 1MB per thread) |
| Example | 200 threads × 1MB = 200MB just for thread stacks |
| -XX | MaxMetaspaceSize = default unlimited (uses native memory) |
Collections Size & Capacity Formulas
ArrayList Capacity
java example
// Default initial capacity
private static final int DEFAULT_CAPACITY = 10;
// Growth formula (Java 11+)
int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5x growth
// 10 → 15 → 22 → 33 → 49 → 73 → 109 → ...
// Memory for ArrayList of n elements
// = 12 (object header) + 4 (size) + 4 (array ref) + padding
// + 16 (array header) + (capacity × 4) bytes for referencesHashMap Capacity
java example
// Default initial capacity
static final int DEFAULT_INITIAL_CAPACITY = 16; // Must be power of 2
// Default load factor
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// Resize threshold
threshold = capacity × loadFactor;
// 16 × 0.75 = 12 → resize to 32 when 13th entry added
// Capacity sequence: 16 → 32 → 64 → 128 → 256 → ...
// Optimal initial capacity to avoid resizing:
initialCapacity = (int)(expectedSize / loadFactor) + 1;
// For 100 entries: (100 / 0.75) + 1 = 134 → rounds up to 256 (next power of 2)
// Memory per entry (approximate):
// Node: 12 (header) + 4 (hash) + 4 (key ref) + 4 (value ref) + 4 (next ref) = 32 bytes
// Total HashMap memory ≈ 48 + (capacity × 4) + (entries × 32) bytesHashSet
Example
// HashSet is backed by HashMap
// Each element is stored as key, with a dummy value (static Object PRESENT)
// Memory = HashMap memory + overhead of dummy PRESENT values (shared single object)
Thread & Concurrency Formulas
Thread States in Java
| NEW | RUNNABLE → (BLOCKED | WAITING | TIMED_WAITING) → TERMINATED |
| - new Thread() | NEW |
| - thread.start() | RUNNABLE |
| - waiting for monitor lock | BLOCKED |
| - Object.wait() / join() | WAITING |
| - Thread.sleep(ms) / wait(ms) | TIMED_WAITING |
| - run() completes / exception | TERMINATED |
Thread Pool Sizing Formulas
| Example: 8 cores | 9 threads |
| Example | 8 cores, task waits 80ms, computes 20ms |
| where | N_cpu = number of CPUs |
Concurrent Collection Performance
ConcurrentHashMap
Concurrency level = 16 (default segments)
Read: O(1) - no lock, uses volatile reads
Write: O(1) - locks only the segment (1/16 of map)
CopyOnWriteArrayList
Read: O(1) - no synchronization needed
Write: O(n) - copies entire array
Best when: reads >> writes
BlockingQueue capacity planning
Optimal size = producer_rate × max_acceptable_latency
Example: 1000 msgs/sec, 5 sec max wait = 5000 capacity
Bit Manipulation Formulas
Common Bit Operations
Example
// Check if number is even or odd
(n & 1) == 0 → even
(n & 1) == 1 → odd
// Multiply by 2
n << 1 // n × 2
// Divide by 2
n >> 1 // n / 2 (integer division)
// Multiply by 2^k
n << k // n × 2^k
// Check if power of 2
(n & (n - 1)) == 0 // true if n is power of 2 (n > 0)
// Get i-th bit
(n >> i) & 1
// Set i-th bit to 1
n | (1 << i)
// Clear i-th bit (set to 0)
n & ~(1 << i)
// Toggle i-th bit
n ^ (1 << i)
// Count set bits (Brian Kernighan)
int count = 0;
while (n > 0) {
n = n & (n - 1); // Removes lowest set bit
count++;
}
// Alternative: Integer.bitCount(n)
// Swap two numbers without temp
a = a ^ b;
b = a ^ b; // b = original a
a = a ^ b; // a = original b
// Find the only non-repeating element (all others appear twice)
int result = 0;
for (int num : arr) result ^= num;
// XOR of all elements cancels duplicates
// Get lowest set bit
int lowest = n & (-n); // OR: n & (~n + 1)
// Turn off the lowest set bit
n & (n - 1)
// Number of bits needed to represent n
(int)(Math.log(n) / Math.log(2)) + 1
// OR: Integer.SIZE - Integer.numberOfLeadingZeros(n)
// OR: 32 - Integer.numberOfLeadingZeros(n)
Bit Manipulation for Subsets
Example
// Generate all subsets of a set with n elements
// Total subsets = 2^n
for (int mask = 0; mask < (1 << n); mask++) {
for (int i = 0; i < n; i++) {
if ((mask & (1 << i)) != 0) {
// Element i is in this subset
}
}
}
Mathematical Formulas for Programming
Number Theory
| // Time | O(√n) |
| return b == 0 ? a | gcd(b, a % b); |
| // Time | O(log(min(a,b))) |
| // OR | String.valueOf(n).length() |
| // Pascal's triangle | nCr = (n-1)C(r-1) + (n-1)Cr |
Array & Sequence Formulas
Example
// Sum of arithmetic progression
sum = n × (first + last) / 2
= n × (2a + (n-1)d) / 2
// Sum of geometric progression
sum = a × (r^n - 1) / (r - 1) // when r > 1
// Number of subarrays in array of size n
total_subarrays = n × (n + 1) / 2
// Number of subsequences
total_subsequences = 2^n (including empty)
// Number of pairs in array of size n
total_pairs = n × (n - 1) / 2 = nC2
// Maximum subarray sum (Kadane's Algorithm)
// Time: O(n), Space: O(1)
int maxSum = arr[0], currentSum = arr[0];
for (int i = 1; i < n; i++) {
currentSum = Math.max(arr[i], currentSum + arr[i]);
maxSum = Math.max(maxSum, currentSum);
}
Recursion & Recurrence Relations
Common Recurrences and Solutions
| T(n) = T(n/2) + O(1) | O(log n) // Binary Search |
| T(n) = T(n/2) + O(n) | O(n) // Quickselect average |
| T(n) = 2T(n/2) + O(1) | O(n) // Tree traversal |
| T(n) = 2T(n/2) + O(n) | O(n log n) // Merge Sort |
| T(n) = 2T(n/2) + O(n²) | O(n²) // Bad divide and conquer |
| T(n) = T(n-1) + O(1) | O(n) // Linear recursion |
| T(n) = T(n-1) + O(n) | O(n²) // Selection Sort |
| T(n) = 2T(n-1) + O(1) | O(2^n) // Fibonacci (naive) |
| T(n) = T(n-1) + T(n-2) + O(1) | O(1.618^n) // Fibonacci recurrence |
Master Theorem
For recurrences of the form: T(n) = a × T(n/b) + O(n^d)
| If log_b(a) < d | T(n) = O(n^d) |
| If log_b(a) = d | T(n) = O(n^d × log n) |
| If log_b(a) > d | T(n) = O(n^(log_b(a))) |
| - Merge Sort: a=2, b=2, d=1 | log₂(2) = 1 = d → O(n log n) ✓ |
| - Binary Search: a=1, b=2, d=0 | log₂(1) = 0 = d → O(log n) ✓ |
| - Strassen's: a=7, b=2, d=2 | log₂(7) ≈ 2.81 > 2 → O(n^2.81) ✓ |
Hashing Formulas
Hash Function Properties
Example
// Java String hashCode()
int hash = 0;
for (int i = 0; i < str.length(); i++) {
hash = 31 * hash + str.charAt(i);
}
// Why 31? It's an odd prime, allows compiler optimization (31 * i == (i << 5) - i)
// HashMap hash perturbation (Java 8+)
static int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
// XOR with upper 16 bits spreads hash across lower bits
// Collision probability (Birthday Paradox)
// In a hash table with m buckets, after inserting n items:
P(collision) ≈ 1 - e^(-n²/(2m))
// For 50% collision probability: n ≈ √(2m × ln(2)) ≈ 1.177√m
Load Factor and Performance
Expected number of comparisons for successful search
= 1 + α/2 (where α = load factor)
Example: α = 0.75 → 1.375 comparisons on average
Expected number of comparisons for unsuccessful search
= 1 + α
Example: α = 0.75 → 1.75 comparisons on average
When load factor > 0.75, resize to maintain O(1) performance
Important Java-Specific Formulas
Primitive Type Ranges
| byte: -128 to 127 (2^7 - 1) | 1 byte |
| short: -32,768 to 32,767 (2^15 - 1) | 2 bytes |
| int: -2,147,483,648 to 2,147,483,647 (2^31 - 1) | 4 bytes |
| long: -9.2 × 10^18 to 9.2 × 10^18 (2^63 - 1) | 8 bytes |
| float: ±3.4 × 10^38 (7 decimal digits) | 4 bytes |
| double: ±1.7 × 10^308 (15 decimal digits) | 8 bytes |
| char: 0 to 65,535 (2^16 - 1) | 2 bytes |
| boolean: true/false | 1 byte (JVM dependent) |
| Formula | For signed n-bit integer: |
| Math.addExact(a, b) | throws ArithmeticException on overflow |
Array Memory Calculation
Example
// Primitive array memory
int[] arr = new int[n];
Memory = 16 (array header) + (n × 4) + padding = 16 + 4n bytes (approx)
// Object array memory
Object[] arr = new Object[n];
Memory = 16 (array header) + (n × 4 references) + (n × individual object size)
// 2D array memory
int[][] matrix = new int[m][n];
Memory = 16 (outer array header) + (m × 4 row references)
+ m × (16 + n × 4) bytes for each row array
≈ 16 + 4m + m(16 + 4n) = 16 + 20m + 4mn bytes
Collections Memory Estimates
Example
// HashMap<Integer, String> with 1000 entries
= 48 (HashMap object)
+ 4096 × 4 (internal array, capacity 4096 for LF 0.75)
+ 1000 × 32 (Node objects)
+ 1000 × 16 (Integer boxing overhead)
+ 1000 × (40 + string_length × 2) (String values)
≈ 100-150 KB for 1000 entries with short strings
// ArrayList<Integer> with 1000 entries
= 24 (ArrayList object)
+ 16 + 1000 × 4 (internal Object[] array)
+ 1000 × 16 (Integer boxing)
≈ 20 KB
Interview Quick Reference
Complexity Cheat Sheet for Java Collections
Example
╔══════════════════════╦═══════════╦═══════════╦═══════════╗
║ Operation ║ ArrayList ║ LinkedList║ HashSet ║
╠══════════════════════╬═══════════╬═══════════╬═══════════╣
║ add(e) ║ O(1)* ║ O(1) ║ O(1) ║
║ add(index, e) ║ O(n) ║ O(n) ║ N/A ║
║ get(index) ║ O(1) ║ O(n) ║ N/A ║
║ remove(index) ║ O(n) ║ O(n) ║ N/A ║
║ remove(object) ║ O(n) ║ O(n) ║ O(1) ║
║ contains(e) ║ O(n) ║ O(n) ║ O(1) ║
║ size() ║ O(1) ║ O(1) ║ O(1) ║
║ iterator.next() ║ O(1) ║ O(1) ║ O(h/n) ║
╚══════════════════════╩═══════════╩═══════════╩═══════════╝
* amortized
When to Use Which Data Structure
| Need fast lookup by key | HashMap (O(1)) |
| Need sorted keys | TreeMap (O(log n)) |
| Need insertion order preserved | LinkedHashMap (O(1)) |
| Need fast add/remove at both ends | ArrayDeque (O(1)) |
| Need thread-safe map | ConcurrentHashMap |
| Need priority access | PriorityQueue (O(log n)) |
| Need unique elements | HashSet (O(1)) |
| Need sorted unique elements | TreeSet (O(log n)) |
| Need fast random access | ArrayList (O(1)) |
| Need fast insert/delete middle | LinkedList (O(1) if iterator) |
Space Complexity Rules
| - Primitive variable | O(1) |
| - Array of size n | O(n) |
| - 2D array m×n | O(m×n) |
| - HashMap with n entries | O(n) |
| - Recursive call stack depth d | O(d) |
| - Binary tree with n nodes | O(n) storage, O(h) for operations |
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Important Formulas & Concepts.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, notes, important, formulas
Related Java Master Course Topics
Continue learning this concept
NotesImportant Java ProgramsCollection of most important Java programs frequently asked in exams and interviews - patterns, number programs, string programs, and array programs.NotesJava Cheat SheetComplete Java programming cheat sheet with syntax reference, common operations, built-in methods, and code snippets for quick lookup.NotesQuick Revision Notes — Java ProgrammingConcise Java quick revision notes covering all major topics - OOP, Collections, Multithreading, JDBC, Spring Boot in table format for fast review before exams or interviews.Collections FrameworkCollections Framework OverviewComplete guide to Java Collections Framework covering hierarchy, interfaces, implementations, algorithms, and choosing the right collection for your use case.Collections FrameworkCollections Practice ProgramsComprehensive Java Collections practice programs covering List, Set, Map, Queue operations with solutions, explanations, and time complexity analysis.Collections FrameworkComparable vs Comparator in JavaDeep dive into Comparable and Comparator interfaces in Java — natural ordering, custom sorting, lambda expressions, method references, and practical comparisons with examples.