Java Basics

The JVM executes bytecode, the JRE = JVM + core libraries, and the JDK = JRE + developer tools (javac, jar, jlink, jshell).

• JVM: class loading, bytecode verification, interpretation + JIT compilation, garbage collection.
• Since Java 11 there is no separate JRE download; use the JDK, or build a trimmed runtime with jlink.

Always pass-by-value. For objects, the value copied is the reference, so a method can mutate the object but cannot make the caller's variable point elsewhere.

static void change(StringBuilder sb, String s) {
    sb.append("!");   // visible to caller
    sb = new StringBuilder("new"); // not visible
    s = s + "?";      // not visible, Strings are immutable
}

Class loader subsystem, runtime data areas, execution engine, and native interface.

• Class loader subsystem: loads, links and initializes classes.
• Runtime data areas: heap, per-thread stacks, program counter registers, native method stacks, metaspace (method area).
• Execution engine: bytecode interpreter, JIT compilers, garbage collector.
• JNI connects Java code to native libraries.

Loading, linking (verification, preparation, resolution) and initialization.

• Loading: read the .class bytes and create a Class object.
• Verification: check bytecode structure and type safety.
• Preparation: allocate static fields and set them to default values (0, null, false).
• Resolution: replace symbolic references with direct ones (may be lazy).
• Initialization: run static initializers and assign static field initializer values, in textual order.

Loaders delegate to their parent first; a child loads a class only if every ancestor failed. This prevents user code from replacing core classes like java.lang.String.

• Bootstrap loader: core java.base classes, written in native code (getClassLoader() returns null).
• Platform loader (extension loader before Java 9): other JDK modules.
• Application (system) loader: classpath/module path.

Heap (objects), thread stacks (frames with locals and operand stack), metaspace (class metadata), PC registers, native stacks, plus off-heap memory such as direct buffers and the code cache.

• Heap and metaspace are shared; stacks are per-thread.
• Total process memory = heap + metaspace + thread stacks + code cache + direct memory + GC overhead.

Young generation (Eden + two survivor spaces) and old generation. New objects go to Eden; survivors of minor GCs are copied between survivor spaces and promoted to old after reaching a tenuring threshold.

• Based on the weak generational hypothesis: most objects die young.
• G1 uses equal-sized regions that play the eden/survivor/old roles dynamically.

Each method call pushes a frame holding local variables, an operand stack and a reference to the constant pool. The frame is popped on return or exception unwinding.

• Size is set with -Xss (default typically 1 MB on 64-bit Linux).
• Too-deep recursion causes StackOverflowError.

Metaspace stores class metadata in native memory and replaced PermGen in Java 8. It grows dynamically instead of having a fixed size inside the Java heap.

• Limit it with -XX:MaxMetaspaceSize; unlimited by default.
• Metadata is freed when the defining class loader becomes unreachable.
• Interned strings and static field values moved to the heap (Java 7/8).

byte 8-bit, short 16, int 32, long 64, float 32, double 64, char 16 (unsigned), boolean (JVM-dependent size, one bit of information).

• Fields default to 0, 0.0, '\u0000', false; references default to null.
• Local variables have no default and must be definitely assigned before use.

The compiler inserts Integer.valueOf(int) for boxing and intValue() for unboxing. No magic at runtime, just generated calls.

• Integer, Long, Short, Byte, Character (0..127) cache small values; Boolean has two constants.
• Float and Double have no cache.

Widening (int to long) is implicit and safe in range; narrowing (long to int) needs an explicit cast and can lose data via truncation of high bits.

• int to float and long to double are widening but can lose precision.
• Compound assignment (+=) includes an implicit narrowing cast.

Binary floating point cannot represent most decimal fractions exactly (0.1), so errors accumulate. Use BigDecimal (constructed from a String) or integer minor units.

• IEEE 754: 1 sign bit, exponent, mantissa.
• BigDecimal needs an explicit RoundingMode for non-terminating divisions.

char is a 16-bit UTF-16 code unit, and arithmetic on it promotes to int. Characters outside the BMP take two chars (a surrogate pair).

• Use String.codePoints() or codePointAt for real characters.
• 'a' + 1 is the int 98; (char) ('a' + 1) is 'b'.

String is final with a private final value array, which makes it thread-safe, cacheable by hash and safe as a map key. Literals are interned into a pool on the heap so identical literals share one instance.

• Immutability enables the pool, hash caching and security (class names, paths).
• Since Java 9 strings use compact Latin-1/UTF-16 byte arrays.

String is immutable; StringBuilder is a mutable, unsynchronized builder; StringBuffer is the synchronized legacy version.

• Use StringBuilder for loops that append; + in a loop creates a builder per iteration.
• Java 9+ compiles + using invokedynamic (StringConcatFactory).

== compares primitives by value and references by identity; equals compares logical content if overridden. The default Object.equals is identity.

&& and || skip evaluating the right operand when the left already decides the result. & and | on booleans always evaluate both sides.

if (s != null && s.length() > 3) { /* safe */ }

++i increments then yields the new value; i++ yields the old value then increments. As standalone statements they are equivalent.

It wraps silently in two's complement; no exception. Integer.MAX_VALUE + 1 equals Integer.MIN_VALUE.

• Use Math.addExact, multiplyExact, toIntExact to throw ArithmeticException.
• Floating point overflows to Infinity instead.

<< shifts left filling zeros, >> is an arithmetic shift that preserves the sign bit, and >>> is a logical shift that fills with zeros.

• The shift distance is masked: int uses the low 5 bits, long the low 6 bits.
• x >> 1 equals floor division by 2; -7 >> 1 is -4, while -7 / 2 is -3.

If both operands are numeric, binary numeric promotion applies; if one is a boxed type and the other a primitive, the result is unboxed. So true ? 1 : 2.0 yields 1.0.

• Mixed Integer/int with a null operand can cause an unboxing NPE.
• With two references the result is the lub (least upper bound) type.

Execution jumps to the matching case and continues through subsequent cases until a break or the end. default can appear anywhere.

• Supported selector types: byte, short, char, int, their wrappers, enum, String (Java 7), and patterns (Java 21).

Since Java 14 switch can be an expression that produces a value, uses -> arms without fall-through, and must be exhaustive.

int days = switch (month) {
    case FEB -> 28;
    case APR, JUN, SEP, NOV -> 30;
    default -> { int d = 31; yield d; }
};

• Over an enum or sealed type exhaustiveness is checked without default.
• Java 21 adds pattern matching and case null.

For arrays it compiles to an index loop; for Iterable it uses iterator(). You cannot see the index or remove elements safely.

A label names an enclosing statement; break label exits it and continue label jumps to the next iteration of that labeled loop. It is structured, not a goto.

outer:
for (int i = 0; i < 3; i++)
    for (int j = 0; j < 3; j++) {
        if (j == 1) continue outer;
        if (i == 2) break outer;
    }

static members belong to the class, not to instances; they exist once per class loader and are initialized when the class is initialized.

• Static methods cannot access instance members directly and have no this.
• A static nested class has no implicit reference to an outer instance, unlike an inner class.

A static {} block runs once during class initialization; an instance {} block runs on every construction, before the constructor body (after super()).

• Both run in textual order together with field initializers.
• Instance initializers are rarely useful; constructors or field initializers are clearer.

A final variable can be assigned once, a final method cannot be overridden, and a final class cannot be extended.

• A blank final field must be assigned in every constructor or initializer.
• Final fields get special safe-publication guarantees in the Java Memory Model.

No. final fixes the reference, not the object's state; final List<String> l can still have elements added.

• True immutability: final class, private final fields, no setters, defensive copies in and out.
• List.of, Map.of and records (shallowly) support this style.

transient excludes a field from default Java serialization; on deserialization it gets the type default (null, 0, false).

• Used for derived data, caches, and secrets such as passwords.
• Does not apply to static fields, which are never serialized anyway.
• JSON libraries such as Jackson ignore transient unless configured; JPA treats it as non-persistent.

Visibility and ordering: a write to a volatile variable happens-before every subsequent read of it, and reads/writes are not reordered across it. It does not provide atomicity for compound actions.

• Good for flags and safe publication of immutable objects.
• long and double volatile reads/writes are atomic (non-volatile may tear on 32-bit JVMs per spec).

A local variable is effectively final if it is never reassigned after initialization. Lambdas and inner classes capture the value, so captured locals must not change.

Class init: superclass static initializers, then subclass static, once. For each instance: superclass instance initializers and constructor body, then subclass instance initializers and constructor body.

• Within one class, static fields/blocks and instance fields/blocks run in textual order.
• Fields not yet initialized hold defaults, which is why calling an overridable method from a constructor is dangerous.

Every constructor starts with this(...) or super(...), explicit or implicit (super()). The call must be the first statement (Java 22 preview relaxes this for code that does not reference this).

• If a class declares any constructor, the compiler does not add the default one.
• If the superclass lacks a no-arg constructor, the subclass must call another explicitly.

var lets the compiler infer the type of a local variable from its initializer (Java 10). The type is still static and fixed; var is not dynamic typing.

• Allowed: locals, for-loop variables, lambda parameters (Java 11).
• Not allowed: fields, method parameters/returns, no initializer, null initializer, array initializer {1,2}.
• var is a reserved type name, not a keyword; var var = 1; compiles.

A record is a transparent, shallowly immutable data carrier (Java 16). The compiler generates private final fields, a canonical constructor, accessors (name(), not getName()), equals, hashCode and toString.

record Point(int x, int y) {
    Point {                       // compact constructor
        if (x < 0) throw new IllegalArgumentException();
    }
}

• Records are implicitly final, cannot extend classes, but can implement interfaces and have static members.
• No instance fields beyond the components.

Multi-line string literals delimited by """ (Java 15). Incidental indentation is stripped based on the least-indented line (including the closing delimiter), and trailing spaces are removed.

String json = """
    {"name": "A"}
    """;

• Line endings are normalized to \n.
• \ at line end suppresses the newline; \s keeps a trailing space.

When it is no longer reachable from any GC root (thread stacks, static fields, JNI references, active class loaders). The GC traces reachability; it does not count references.

• Cyclic references among unreachable objects are collected.
• System.gc() is only a hint.

Serial (single thread), Parallel (throughput), G1 (balanced, default since Java 9 on server-class machines), ZGC and Shenandoah (low pause, concurrent compaction).

• Select with -XX:+UseSerialGC, -XX:+UseParallelGC, -XX:+UseG1GC, -XX:+UseZGC.
• Generational ZGC arrived in Java 21 (-XX:+ZGenerational, default in 23).
• Java 8 default is Parallel GC.

A stop-the-world pause halts all application threads at a safepoint so the GC can work with a consistent heap. GC roots are the starting points for tracing: local variables on thread stacks, static fields, JNI handles, and live class loaders.

• Concurrent collectors shrink pauses but still need short pauses for root scanning.
• Time-to-safepoint can be long when a thread is in a counted loop.

Strong references block collection. Soft references are cleared under memory pressure (caches), weak ones at the next GC when only weakly reachable (WeakHashMap), phantom ones are enqueued after finalization and used for cleanup via Cleaner.

The JVM starts by interpreting bytecode, profiles invocation and loop counts, and compiles hot methods to native code. Tiered compilation uses C1 (fast, light optimization) first and C2 (aggressive, profile-guided) for the hottest code.

• Compiled code lives in the code cache.
• Deoptimization falls back to the interpreter when an assumption (e.g., a monomorphic call site) breaks.
• -XX:+PrintCompilation shows compile events.

Method inlining, escape analysis (scalar replacement, lock elision), loop unrolling, dead code elimination, range-check elimination and devirtualization.

• Inlining is limited by bytecode size (MaxInlineSize, FreqInlineSize).
• Escape analysis can avoid heap allocation for objects that do not leave a method.

-Xms initial heap, -Xmx max heap, -Xss thread stack size, -XX:MaxMetaspaceSize metaspace cap, -XX:MaxDirectMemorySize direct buffers.

• Setting -Xms equal to -Xmx avoids resize pauses.
• In containers use -XX:MaxRAMPercentage (default 25%).

Overloads are chosen at compile time using the static argument types; overrides are dispatched at runtime using the object's actual class.

• Overload phases: exact/widening, then boxing, then varargs.
• Overriding requires the same signature, a compatible return type (covariant) and no weaker access.

private (class), package-private (default, same package), protected (package plus subclasses), public (everywhere). With modules (Java 9) a package must also be exportsed.

void f(String... a) is compiled to String[] a; the compiler packs the arguments into an array. It must be the last parameter, and only one is allowed.

Default methods (Java 8) let interfaces evolve without breaking implementors; static methods hold utilities; private methods (Java 9) share code between defaults. Interfaces still cannot hold instance state.

• If two interfaces supply the same default, the class must override and may pick one via A.super.m().
• A class method always wins over an interface default.

Equal objects must have equal hash codes; equals must be reflexive, symmetric, transitive, consistent and false for null. Unequal objects may share a hash code.

• Override both together; hash collections break otherwise.
• Do not use mutable fields in hashCode for objects stored in hash sets/maps.

if (o instanceof String s) tests and binds in one step (Java 16). sealed classes/interfaces (Java 17) restrict permitted subtypes, which enables exhaustive switch without default.

sealed interface Shape permits Circle, Square {}
record Circle(double r) implements Shape {}
record Square(double a) implements Shape {}
double area(Shape s) {
    return switch (s) {
        case Circle c -> Math.PI * c.r() * c.r();
        case Square q -> q.a() * q.a();
    };
}

(The switch pattern form is final in Java 21.)

equals, hashCode, toString, getClass, clone, finalize (deprecated), wait, notify, notifyAll. Typically equals, hashCode and toString are overridden.

• getClass, wait, notify and notifyAll are final.
• wait/notify require holding the object's monitor.

true false. Autoboxing uses Integer.valueOf, which caches values from -128 to 127, so a and b are the same object while c and d are different objects. Always compare boxed values with equals.

Trace the code below.

String a = "hi";
String b = "hi";
String c = new String("hi");
System.out.println((a == b) + " " + (a == c) + " " + (a == c.intern()) + " " + a.equals(c));

true false true true. Both literals share one pooled instance, new String creates a distinct object, intern() returns the pooled instance, and equals compares content.

Trace the code below.

final String f = "a";
String n = "a";
System.out.println(((f + "b") == "ab") + " " + ((n + "b") == "ab"));

true false. f is a constant variable, so f + "b" is a compile-time constant folded to the pooled "ab". n is not final, so the concatenation runs at runtime and creates a new object.

It can reduce duplicates but is usually the wrong tool. The JVM string table is a fixed-bucket native hash table; heavy interning adds contention and GC cost. Prefer a bounded application-level dedup map, or on G1 enable -XX:+UseStringDeduplication, which shares the backing arrays of duplicate strings in the background.

• Measure first with a heap histogram or a heap dump (duplicate strings view in MAT).
• Better still: parse into enums, ints or dictionary IDs.

Trace the code below.

int i = 5;
i = i++;
System.out.println(i);

5. i++ yields the old value 5 and increments i to 6, then the assignment overwrites i with the old value 5.

s += 1 compiles; s = s + 1 does not. s + 1 is an int and assigning to short needs a cast, while a compound assignment is defined as s = (short) (s + 1).

short s = 1;
s += 1;          // ok, s == 2
// s = s + 1;    // error: incompatible types: possible lossy conversion from int to short
s = (short) (s + 1);

false; the sum is 0.30000000000000004. Compare with a tolerance (Math.abs(a - b) < 1e-9) or use BigDecimal for exact decimals.

Trace the code below.

System.out.println(Integer.MAX_VALUE + 1);
long l = 1_000_000 * 1_000_000;
System.out.println(l);
System.out.println(Integer.MAX_VALUE + 1L);

-2147483648, -727379968, 2147483648. The multiplication of two int literals is done in 32-bit before widening to long, so it already overflowed; make one operand long (1_000_000L).

Trace the code below.

char c = 'a';
System.out.println(c + 1);
System.out.println((char) (c + 1));
System.out.println("" + c + 1);
System.out.println('a' + 'b');

98, b, a1, 195. Arithmetic promotes char to int; string concatenation uses the character itself.

1.0. Binary numeric promotion makes the conditional's type double, so the chosen 1 is widened.

Trace the code below.

Integer x = null;
boolean flag = false;
int y = flag ? 1 : x;

The operands are int and Integer, so the expression type is int and x is unboxed when the false branch is selected; x.intValue() on null throws. Fix by keeping the type boxed (flag ? Integer.valueOf(1) : x) or testing null explicitly.

Trace the code below.

class Parent {
    static { System.out.println("P-static"); }
    { System.out.println("P-init"); }
    Parent() { System.out.println("P-ctor"); }
}
class Child extends Parent {
    static { System.out.println("C-static"); }
    { System.out.println("C-init"); }
    Child() { System.out.println("C-ctor"); }
}
// main: new Child(); new Child();

P-static, C-static, P-init, P-ctor, C-init, C-ctor, P-init, P-ctor, C-init, C-ctor. Static blocks run once, superclass first; each instance runs super initializers and constructor before the subclass ones.

Trace the code below.

class A {
    A() { show(); }
    void show() { }
}
class B extends A {
    int x = 5;
    void show() { System.out.println(x); }
}

0. A's constructor runs before B's field initializers, and the overridden show is dispatched virtually, so it sees the default value. Never call overridable methods from constructors.

Trace the code below.

static int f() {
    try { return 1; }
    finally { return 2; }
}

2. A return in finally overrides the earlier return and also discards any pending exception; compilers warn about it.

Nearly always. It runs after normal completion, return, break or an exception. It does not run if the JVM exits (System.exit, Runtime.halt, crash, kill -9), or the thread is killed or hangs forever in try.

try { System.exit(0); } finally { System.out.println("never printed"); }

Trace the code below.

int n = 2;
switch (n) {
    case 1: System.out.print("one ");
    case 2: System.out.print("two ");
    case 3: System.out.print("three "); break;
    default: System.out.print("other ");
}

two three . Execution starts at case 2 and falls through into case 3 until break.

Trace the code below.

String r = switch (day) {
    case 1, 7 -> "weekend";
    case 2, 3, 4, 5, 6 -> "weekday";
};

Compile error: the switch expression does not cover all possible input values. For int a default is mandatory; only enums and sealed types can be exhaustive without it.

Trace the code below.

String s = null;
switch (s) { case "a": break; default: break; }

NullPointerException, since the classic switch calls hashCode/equals on the selector. Java 21 pattern switches allow case null -> ... to handle it explicitly.

String r = switch (s) {
    case null -> "none";
    case "a" -> "A";
    default -> "other";
};

Trace the code below.

List<Integer> l = new ArrayList<>(List.of(1, 2, 3));
for (Integer i : l) if (i == 1) l.remove(i);

ConcurrentModificationException on the next next() call. With if (i == 2) instead it silently ends without error, because after removal size == cursor and hasNext() returns false. Use removeIf or Iterator.remove.

Trace the code below.

static void swap(int a, int b) { int t = a; a = b; b = t; }
// main: int x = 1, y = 2; swap(x, y); System.out.println(x + " " + y);

It prints 1 2. The method swaps its own copies. The same applies to Integer parameters, since the references are copied.

Trace the code below.

static void f(int[] a) { a[0] = 99; a = new int[]{7}; a[0] = 5; }
// main: int[] arr = {1, 2}; f(arr); System.out.println(arr[0]);

99. The first write goes through the shared reference; the reassignment affects only the local copy of the reference.

Trace the code below.

static void up(String s) { s.toUpperCase(); }
// main: String t = "abc"; up(t); System.out.println(t);

Strings are immutable: toUpperCase() returns a new string, which was discarded. Even s = s.toUpperCase() inside would only rebind the local parameter, so return the result and assign it in the caller.

Trace the code below.

final int[] a = {1, 2};
a[0] = 9;
a = new int[0];

a[0] = 9 compiles and works; a = new int[0] fails with "cannot assign a value to final variable a". final freezes the reference, not the array contents.

Usually less than 200,000. count++ is three steps (read, add, write); volatile gives visibility but not atomicity, so updates are lost. Use AtomicInteger, LongAdder under contention, or synchronized.

Trace the code below.

static boolean running = true;
// worker: while (running) { work(); }
// main:   Thread.sleep(100); running = false;

Without volatile there is no happens-before between the write and the worker's reads, so the JIT may hoist the read out of the loop and the worker never sees false. Declare the flag volatile (or use AtomicBoolean, or interruption).

Trace the code below.

class User implements Serializable {
    String name = "ann";
    transient String password = "secret";
    transient int attempts = 3;
}

name is "ann", password is null, attempts is 0. Transient fields are skipped and get type defaults; field initializers do not run because the constructor of a Serializable class is not invoked.

Trace the code below.

class T { static void hi() { System.out.println("hi"); } }
// main: ((T) null).hi();

No, it prints hi. A static method is bound to the declared type at compile time; the null reference is never dereferenced (the expression is evaluated, then discarded). Call it as T.hi() to avoid confusion.

Trace the code below.

static void m(Object o) { System.out.println("Object"); }
static void m(String s) { System.out.println("String"); }
// m(null);

String, the most specific applicable overload. If you add m(Integer i), m(null) fails to compile with "reference to m is ambiguous", since neither String nor Integer is more specific.

Trace the code below.

static void m(long x)    { System.out.println("long"); }
static void m(Integer x) { System.out.println("Integer"); }
static void m(int... x)  { System.out.println("varargs"); }
// m(5);

long. Resolution tries phase 1 (strict: widening, no boxing) first and int widens to long; boxing is phase 2 and varargs phase 3.

Trace the code below.

class A { String n = "A"; static String s() { return "A"; } String i() { return "A"; } }
class B extends A { String n = "B"; static String s() { return "B"; } String i() { return "B"; } }
// A a = new B();
// System.out.println(a.n + a.s() + a.i());

AAB. Fields and static methods are resolved by the declared type (A), only the instance method i() is dispatched dynamically.

Trace the code below.

var a = 10;
var list = new ArrayList<>();
var n = null;
var arr = {1, 2};
var f = () -> 1;

Only the first two. a is int; list is ArrayList<Object>. var n = null has no inferable type, var arr = {1, 2} needs an explicit int[] or new int[]{...}, and a lambda has no target type.

Trace the code below.

record Person(String name, int age) {
    Person {
        if (age < 0) throw new IllegalArgumentException("age");
        name = name.trim();
    }
}
// var p = new Person(" Ann ", 30);
// System.out.println(p + " " + p.equals(new Person("Ann", 30)));

Person[name=Ann, age=30] true. The compact constructor normalizes the parameter before the generated field assignment, and generated equals compares all components.

Trace the code below.

record Team(List<String> members) {}
var l = new ArrayList<String>(List.of("a"));
var t = new Team(l);
l.add("b");
System.out.println(t.members().size());

Prints 2. Records are only shallowly immutable, so the caller's list is shared. Fix with a defensive copy in the compact constructor: members = List.copyOf(members);.

Trace the code below.

String a = """
    Hello
      World
    """;
String b = """
    Hello
      World""";

a is "Hello\n World\n" (length 14); b is "Hello\n World" (length 13). The closing delimiter's line participates in indentation stripping, and putting it on its own line adds the final newline.

Capture evidence, then find what retains memory. Start with -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=... and GC logs (-Xlog:gc*).

• Open the dump in Eclipse MAT or VisualVM; look at the dominator tree and "leak suspects".
• Distinguish a leak (old gen grows after every full GC) from a sizing problem (live set simply exceeds -Xmx).
• Use JFR allocation profiling to see where objects are created.
• Raising -Xmx is a stopgap, not a fix.

Trace the code below.

static int depth(int n) { return depth(n + 1); }

There is no base case, so frames pile up until the thread stack (-Xss) is exhausted. Add a terminating condition; for legitimately deep recursion convert it to an iterative loop with an explicit stack. Java does not perform tail-call optimization.

Classloader leak. Each redeploy creates a new webapp class loader; if anything outside it still references one of its classes or the loader itself (a JDBC driver registered in DriverManager, a ThreadLocal, a thread started by the app, a static in a shared library), the whole loader and its classes stay in metaspace.

• Find it via a heap dump: look for multiple instances of the webapp class loader and their GC root path.
• Fix: deregister drivers, stop threads, clear ThreadLocals on shutdown.

Trace the code below.

static final Map<String, byte[]> CACHE = new HashMap<>();
static byte[] get(String k) { return CACHE.computeIfAbsent(k, Loader::load); }

A static map is reachable from a GC root, so entries are never collected; with unbounded keys the heap fills and ends in OutOfMemoryError. Use a bounded cache with eviction (Caffeine, size/time based), or soft/weak references where semantics fit. HashMap is also not thread-safe here.

Trace the code below.

Object a = new Object();
Object b = a;
a = null;
b = null;

After a = null the object is still reachable through b; after b = null there are no references and it becomes eligible (assuming no other path). Eligibility is not collection; the GC decides when to reclaim.

The heap alone can use the full 1 GB, and the JVM also needs metaspace, thread stacks, code cache, direct buffers and GC structures, so the process exceeds the cgroup limit and the kernel kills it. Leave headroom: -XX:MaxRAMPercentage=60 to 75 (default is 25%), and cap -XX:MaxMetaspaceSize and -Xss where sensible.

Class loading, interpretation and tiered JIT compilation. Early calls run in the interpreter, then C1, then C2-optimized code. Naive timing with System.nanoTime also suffers from dead-code elimination and constant folding. Use JMH, which handles warm-up, forks and Blackhole.

Trace the code below.

System.out.println(1 / 2 * 3.0);
System.out.println(3.0 * 1 / 2);
System.out.println(-5 / 2 + " " + -5 % 3 + " " + 5 % -3);
System.out.println(Math.floorMod(-5, 3));

0.0, 1.5, -2 -2 2, 1. Integer division truncates toward zero, evaluation is left to right so 1 / 2 is 0 before the double multiplication, and % takes the sign of the dividend; floorMod takes the sign of the divisor.

Trace the code below.

System.out.println(1 / 0);
System.out.println(1.0 / 0);
System.out.println(0.0 / 0);
System.out.println(5.0 % 0);

The first throws ArithmeticException: / by zero and nothing after it runs. Floating-point forms give Infinity, NaN and NaN respectively. Integer remainder by zero also throws.

Trace the code below.

double nan = Double.NaN;
System.out.println(nan == nan);
System.out.println(Double.valueOf(nan).equals(nan));
System.out.println(0.0 == -0.0);
System.out.println(Double.valueOf(0.0).equals(-0.0));

false, true, true, false. Primitive == follows IEEE 754 (NaN is unequal to itself, 0.0 equals -0.0); Double.equals compares the bit patterns (canonicalized NaN), so it is consistent with compare and hash codes.

Trace the code below.

int x = 5;
x += x++ * 2;
System.out.println(x);
int[] a = {0, 0};
int i = 0;
a[i] = i = 1;
System.out.println(Arrays.toString(a));

15 and [1, 0]. Java evaluates left to right: x += ... saves the left value 5 first, x++ * 2 is 5 * 2 = 10, and the result 15 overwrites the incremented x. For the array, the index a[i] is evaluated first (i was 0), then the right side assigns i = 1, so element 0 gets 1.

Trace the code below.

System.out.println(1 << 33);
System.out.println(-8 >> 1);
System.out.println(-8 >>> 28);
System.out.println(1L << 33);

2, -4, 15, 8589934592. The int shift distance is masked to 5 bits (33 & 31 = 1); >> keeps the sign; -8 is 0xFFFFFFF8, and a logical shift by 28 leaves 0xF.

Trace the code below.

Long l = 127L;
System.out.println(l.equals(127));
System.out.println(l.equals(127L));
System.out.println(l == 127);
Set<Long> s = new HashSet<>(List.of(1L));
System.out.println(s.contains(1));

false, true, true, false. l.equals(127) boxes to Integer, and Long.equals requires a Long; l == 127 unboxes l and compares numerically; contains(1) boxes an Integer, so it never matches a Long.

-2147483648, because +2147483648 does not fit in an int. Code like Math.abs(key.hashCode()) % n can therefore produce a negative index for a hash of Integer.MIN_VALUE. Use Math.floorMod(hash, n) or (hash & 0x7fffffff) % n.

ClassNotFoundException is a checked exception thrown when explicit loading by name fails (Class.forName, loadClass). NoClassDefFoundError is an Error thrown when a class that was present at compile time cannot be found or initialized at runtime, such as a missing dependency jar or a failed static initializer earlier.

Trace the code below.

class Config { static final int V = 1 / Integer.parseInt("0"); }
// first use of Config.V, then second use

The first access throws ExceptionInInitializerError wrapping the ArithmeticException. The class is marked erroneous, so every later access throws NoClassDefFoundError: Could not initialize class Config, hiding the root cause that is only in the first stack trace.

Trace the code below.

System.out.println(Math.round(-2.5) + " " + Math.round(2.5));
System.out.println((int) 3.99 + " " + (int) -3.99);
System.out.println((int) 1e20 + " " + (int) Double.NaN);

-2 3, 3 -3, 2147483647 0. Math.round is floor(x + 0.5), so ties go toward positive infinity; casting to int truncates toward zero and saturates out-of-range values, with NaN becoming 0.

Trace the code below.

double x = 2.567;
System.out.println(Math.round(x * 100) / 100);

It prints 3. Math.round(double) returns a long, so dividing by 100 is integer division and truncates. Divide by 100.0 to get 2.57, or better use BigDecimal.setScale(2, RoundingMode.HALF_UP) for money.