Java

Core types, equals and hashCode, collections, generics, streams, the JVM heap and concurrency — the Java an interview actually probes, with the mistakes almost everyone makes once.

Start the course Practise this with real questions

In this course

Primitives, wrappers, and the == trapWhy int and Integer are not interchangeable, and the caching quirk that makes == look like it works.7 min
equals, hashCode, and the contract between themWhy overriding one without the other breaks every hash-based collection silently.9 min
Lists, sets, maps, and picking the right oneArrayList against LinkedList, HashMap against LinkedHashMap and TreeMap, and what each one actually costs.8 min
Interfaces, abstract classes, and polymorphismWhat each one can do that the other cannot, and why calling through an interface is the default.8 min
Checked exceptions, unchecked exceptions, and try-with-resourcesThe one real difference between the two families, and the resource leak try-with-resources exists to prevent.9 min
Strings, the string pool, and StringBuilderWhy String is immutable, when == happens to work on strings, and why concatenating in a loop is the classic hidden O(n²).9 min
Generics: erasure, invariance, and wildcardsWhy a List<Integer> is not a List<Number>, what erasure removes at runtime, and how ? extends and ? super make an API accept more.10 min
Inside HashMap, and why iterators fail fastBuckets, hash spreading, resizing and treeified bins — then the ConcurrentModificationException every Java developer meets once.10 min
Immutability: final, unmodifiable views, and defensive copiesWhy final does not make an object immutable, why an unmodifiable view can still change, and how to write a value that truly cannot.9 min
Enums and switch expressionsEnums as real classes with fields and an order, and the switch expression that replaced fall-through with exhaustiveness checks.9 min
Records, sealed types, and pattern matchingModelling "one of these shapes of data" with sealed interfaces and records, and taking it apart with an exhaustive pattern-matching switch.10 min
Lambdas and streamsFunctional interfaces, effectively final captures, lazy one-shot pipelines, and the collectors that turn a stream back into a map.11 min
Optional and null handlingWhat Optional is for, the get() and Optional.of(null) traps, and why orElse runs its fallback even when a value is present.9 min
JVM memory: stack, heap, and garbage collectionWhere locals and objects live, why Java is always pass-by-value, how a tracing collector decides what is garbage, and what a Java memory leak really is.10 min
Threads, races, synchronized, and volatileWhy count++ loses updates, what synchronized guarantees beyond mutual exclusion, what volatile does and does not fix, and the check-then-act race.11 min
Executors, CompletableFuture, and virtual threadsThread pools and futures, composing async work with CompletableFuture, the wrapper exceptions both put around a failure, and what Java 21's virtual threads change.11 min