Cheatsheet

Minimal program

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

Compile and run

javac Hello.java
java Hello
java -cp . Hello

Scanner / printf essentials

import java.util.Scanner;

Scanner in = new Scanner(System.in);
int n = in.nextInt();
double x = in.nextDouble();
in.nextLine();                      // consume leftover newline
String s = in.nextLine();
System.out.printf("%d %.2f%n", n, x);

Tip: File name must match the public class. Prefer try-with-resources for Scanner on files.

Primitives (typical)

final / static / wrappers

final int MAX = 100;
Integer boxed = 42;               // autobox
int raw = boxed;                   // unbox — NPE if null
Integer.parseInt("42");
enum Color { RED, GREEN, BLUE }

== on objects is identity. Use equals for content. Integer division: 5/2 == 2.

if (x > 0) { ... }
else if (x == 0) { ... }
else { ... }

switch (k) {
  case 1: ...; break;
  default: ...;
}

for (int i = 0; i < n; i++) { ... }
while (cond) { ... }
do { ... } while (cond);
for (var x : list) { ... }
break; continue;

int[] a = {1, 2, 3};
int[] b = new int[5];
int[][] m = new int[2][3];
a.length;                          // not a method
java.util.Arrays.sort(a);
java.util.Arrays.toString(a);

Arrays have a fixed length after creation. Prefer ArrayList when the size grows.

String s = "hi";
s.length(); s.isEmpty(); s.charAt(0);
s.substring(0, 2); s.contains("h");
s.equals(t);                       // not ==
StringBuilder sb = new StringBuilder();
sb.append("hi").append(42);
Integer.parseInt("42");

String is immutable and interned for literals. Use StringBuilder in loops. == on wrappers in the cache range can lie — always equals.

package com.demo.util;

public static int add(int a, int b) {
    return a + b;
}

int fact(int n) {
    return n <= 1 ? 1 : n * fact(n - 1);
}

void log(String... parts) { }  // varargs

Overload = same name, different parameters. static methods have no this.

public class Account {
    private int balance;
    private static int count;

    public Account(int balance) {
        this.balance = balance;
        count++;
    }

    public int getBalance() { return balance; }
}

abstract class Shape {
    abstract double area();
}

interface Drawable {
    void draw();
    default void hint() { }
}

class Circle extends Shape implements Drawable {
    @Override public double area() { return 0; }
    @Override public void draw() { }
}

Shape s = new Circle();
s.area();                          // runtime dispatch

Keywords: extends, implements, abstract, @Override, super. One superclass; many interfaces. Overload = compile-time; override = runtime.

try (var in = new java.io.FileReader("in.txt")) {
    throw new IllegalArgumentException("bad");
} catch (java.io.IOException e) {
    e.printStackTrace();
} finally {
    // cleanup if not using try-with-resources
}

void read() throws java.io.IOException { }

List<Integer> list = new ArrayList<>();
list.add(1);

Map<String, Integer> freq = new HashMap<>();
freq.merge("hi", 1, Integer::sum);

for (var it = list.iterator(); it.hasNext(); ) {
    it.next();
}

Runnable task = () -> System.out.println("hi");
Thread t = new Thread(task);
t.start();                         // not run()
t.join();

synchronized (this) { count++; }
volatile boolean ready;

class Box<T> { private T value; }

Predicate<String> ok = s -> !s.isBlank();
list.stream()
    .filter(ok)
    .map(String::toUpperCase)
    .toList();

Optional<String> maybe = Optional.ofNullable(name);

Generics erase at runtime. A functional interface has one abstract method. Streams are lazy until a terminal operation.