The labs on this site need JavaScript to run. The same content is written out below.

Learn

Java

From syntax to object-oriented programming, collections, threads, and the JVM. See what happens inside when code runs.

Basic syntax

• Variables and types — What is copied when you assign one variable to another?
• Operators and type conversion — Why is 7 / 2 equal to 3 and not 3.5?
• Conditionals and loops — How many times does a loop run, and where does it stop?
• Arrays — Does assigning an array variable copy the array?

Classes and objects

• Classes, objects, and constructors — What happens, and in what order, when you use new?
• static and instance — Why does the value of a change when only b was touched?
• Inheritance and overriding — When does the superclass constructor run when a subclass object is created?
• Polymorphism and method selection — Who decides which method runs, and when?
• Interfaces and abstract classes — Neither can be created with new, so how do they differ?
• Access modifiers and encapsulation — How far do private, protected, and public open up access?
• Inner classes and anonymous classes — How is a class declared inside a class connected to the outer object?
• Immutability and defensive copies — The field is final, but its value changed
• Strategy pattern — What you have to change when one more payment method is added

Commonly used classes

• == and equals — Why is == false when the values are the same?
• equals and hashCode — Why can HashMap not find the key when you override only equals?
• String, StringBuilder — Why is the original unchanged after you call a string method?
• Dates and times — What date do you get when you add one month to January 31?
• Optional — Why does the default-value code in orElse run even when a value is present?

Exceptions

• Exceptions and finally — When an exception is thrown, which blocks run, and in what order?
• Checked and unchecked exceptions — Why do some exceptions keep the code from even compiling unless you handle them?

Generics, enums, and annotations

• Generics — What does the <Integer> in List<Integer> protect you from?
• Enum classes — Why does an enum saved as a number come back as a different constant?
• Annotations — What really happens when you just add an annotation with @?

Collections

• ArrayList and LinkedList — The same operation takes a different amount of work
• Inside HashMap — Where does a HashMap put a key, and how does it find it?
• Kinds of Set and Map — Why do the same values come out in a different order?
• Stack, queue, priority queue — Insertion order and removal order
• Removing during iteration — What happens when you remove elements inside a loop
• Sorting and Comparator — Who decides the sort order, and why is comparing by subtraction wrong?

Lambdas and streams

• Lambda expressions and functional interfaces — When does the code in a lambda expression run?
• Lazy evaluation in streams — A stream does not run in the order in which it is written
• Collecting a stream — Into what shape do you collect the result of a stream?
• Parallel streams and the common pool — Someone else's parallel stream slows down my code

Threads and concurrency

• Processes and threads — Two ways to add more workers
• Creating threads and thread states — Why does calling run() directly not create a new thread?
• Race condition — Why does count++ lose increments?
• Deadlock — Two threads wait for each other, and both stop
• Thread pool — What changes when you add more threads
• Thread count and context switching — Adding threads does not keep making things faster
• Sequential and parallel calls — Several external calls: one after another, or all at once?
• Blocking, non-blocking, and virtual threads — What a thread does while it waits

JVM

• Stack and heap — What happens in memory each time a method is called
• GC and memory leaks — Who reclaims discarded objects, and when?
• JIT warmup — Why are the first requests right after a deployment slow?
• Class loading and initialization — When does the static initializer of a class run?

I/O

• I/O streams and buffers — I called write, so why is the file empty?
• Serialization — What comes back when you restore a saved object?