JavaPrintable

Java Cheat Sheet

Program structure, operators, input, strings, formatting, switch, loops, collections, classes, enums, records, generics, exceptions, files, dates, streams and JUnit on one printable page.

Back to the Java tutorial

Program structure

Syntax	What it does	Lesson
`public class Main { }`	A class; file must be Main.java	Introduction
`public static void main(String[] args)`	Where the program starts	Introduction
`System.out.println(x);`	Print and new line	Introduction
`javac Main.java` then `java Main`	Compile and run	Introduction

Variables & input

Syntax	What it does	Lesson
`int` `double` `boolean` `char` `String`	Common types	Variables
`final int MAX = 10;`	Constant	Variables
`(int) 3.9` `Integer.parseInt("7")`	Cast / parse	Variables
`Scanner in = new Scanner(System.in);`	Keyboard input	User input
`in.nextLine()` `in.nextInt()`	Read a line / an int	User input
`System.out.printf("%s %.2f%n", s, d);`	Formatted output	User input

Strings

Syntax	What it does	Lesson
`s.length()` `s.charAt(i)`	Length, one character	Strings
`s.substring(a, b)` `s.indexOf("x")`	Part of text, find text	Strings
`s.trim()` `s.toUpperCase()` `s.replace(a, b)`	Transform (returns new String)	Strings
`s.split(",")` `String.join("-", arr)`	Split / join	Strings
`a.equals(b)` `a.equalsIgnoreCase(b)`	Compare text	Strings
`new StringBuilder().append(x)`	Build text efficiently	Strings

Conditions & loops

Syntax	What it does	Lesson
`if (c) { } else if (d) { } else { }`	Branching	if/else
`switch (v) { case 1 -> ...; default -> ...; }`	Match fixed values	if/else
`for (int i = 0; i < n; i++) { }`	Counted loop	Loops
`while (c) { }` `do { } while (c);`	Condition loops	Loops
`for (int x : arr) { }`	Visit every item	Loops

Arrays & methods

Syntax	What it does	Lesson
`int[] a = {1, 2, 3};` `new int[5]`	Create an array	Arrays
`a.length` `Arrays.toString(a)`	Size / print	Arrays
`Arrays.sort(a)` `Arrays.copyOf(a, n)`	Sort / copy	Arrays
`int[][] g = new int[3][4];`	2D array	Arrays
`static int sq(int n) { return n * n; }`	Method with a result	Methods

Classes & collections

Syntax	What it does	Lesson
`class Dog { String name; Dog(String n) { name = n; } }`	Class and constructor	Classes
`List<String> l = new ArrayList<>();`	Resizable list	ArrayList
`l.add(x)` `l.get(i)` `l.remove(i)` `l.size()`	List methods	ArrayList
`Map<String, Integer> m = new HashMap<>();`	Key-value map	HashMap
`m.put(k, v)` `m.getOrDefault(k, 0)`	Write / read safely	HashMap
`Set<String> s = new HashSet<>();`	Unique values	HashMap

Inheritance & interfaces

Syntax	What it does	Lesson
`class Car extends Vehicle`	Inherit from a class	Inheritance
`super(args);` `super.method()`	Call the parent	Inheritance
`@Override`	Check an override	Inheritance
`interface Payable { void pay(); }`	Define a contract	Interfaces
`class Card implements Payable`	Keep the contract	Interfaces
`abstract class Shape { abstract double area(); }`	Partial blueprint	Interfaces

Exceptions & streams

Syntax	What it does	Lesson
`try { } catch (Exception e) { } finally { }`	Handle errors	Exceptions
`throw new IllegalArgumentException("msg");`	Report a problem	Exceptions
`void load() throws IOException`	Declare a checked exception	Exceptions
`x -> x * 2` `String::length`	Lambda / method reference	Streams
`list.stream().filter(...).map(...).toList()`	Stream pipeline	Streams
`Collectors.groupingBy(f, Collectors.counting())`	Group and count	Streams

Operators, formatting & switch

Syntax	What it does	Lesson
`7 / 2` `7 % 2` `(double) a / b`	Integer division, remainder, decimal division	Operators & Math
`x++` `x += 5`	Update a variable	Operators & Math
`Math.round(x)` `Math.max(a, b)` `Math.pow(a, b)`	Common maths	Operators & Math
`System.out.printf("%-10s%6.2f%n", s, d)`	Aligned, formatted output	Formatting & StringBuilder
`new StringBuilder().append(x).toString()`	Build strings efficiently	Formatting & StringBuilder
`"""` text block `"""`	Multi-line text	Formatting & StringBuilder
`case "A", "B" -> ...`	Arrow case, no fall-through	switch
`int d = switch (m) { case 2 -> 28; default -> 31; };`	Switch expression	switch

Collections, enums & records

Syntax	What it does	Lesson
`new TreeSet<>()` `new LinkedHashSet<>()`	Sorted / insertion-ordered set	Collections
`Deque<T> s = new ArrayDeque<>(); s.push(x); s.pop();`	Stack	Collections
`new PriorityQueue<>()`	Smallest item first	Collections
`list.sort(Comparator.comparing(P::age).reversed())`	Sort objects	Collections
`enum Size { SMALL, LARGE }`	Fixed set of constants	Enums
`Size.values()` `Size.valueOf("LARGE")`	All constants / from text	Enums
`record Point(int x, int y) {}`	Immutable data class	Records
`class Box<T> { }` `static <T> T f(T x)`	Generic class and method	Generics
`List<? extends Number>`	Read-only wildcard	Generics

Files, dates & testing

Syntax	What it does	Lesson
`Files.readAllLines(Path.of("f.txt"))`	Read lines	Files & I/O
`Files.writeString(p, s, CREATE, APPEND)`	Append to a file	Files & I/O
`try (Stream<String> l = Files.lines(p)) { }`	Read a big file lazily	Files & I/O
`LocalDate.of(2024, 7, 5).plusDays(3)`	Create and move a date	Dates & Times
`DateTimeFormatter.ofPattern("dd/MM/yyyy")`	Format and parse dates	Dates & Times
`ChronoUnit.DAYS.between(a, b)`	Days between dates	Dates & Times
`@Test void name() { assertEquals(exp, act); }`	A JUnit test	Unit Testing (JUnit)
`assertThrows(X.class, () -> code())`	Expect an exception	Unit Testing (JUnit)
`@ParameterizedTest @CsvSource({...})`	One test, many inputs	Unit Testing (JUnit)

Beginner companion reference

Topic	Rule to remember	Lesson
Syntax and Statements	Expressions produce values; statements instruct the program	Open lesson
Output: print() vs. println()	println adds a line terminator	Open lesson
Comments and Code Structure	Comments explain intent without executing	Open lesson
Variables, Identifiers and Constants	final prevents reassignment of the variable	Open lesson
Primitive Data Types	Java has eight primitive types	Open lesson
Type Casting and var	var infers a fixed local type	Open lesson
Operators and Precedence	Multiplication binds before addition	Open lesson
Strings, Concatenation and Escapes	String objects are immutable	Open lesson
Boolean Expressions	&& requires both operands to be true	Open lesson
switch Expressions and Statements	A switch expression produces a value	Open lesson
if, else if and Nested Conditions	An else-if chain takes the first matching branch	Open lesson
for, while and do-while Loops	do-while executes its body at least once	Open lesson
Nested and Enhanced for Loops	Enhanced for visits elements rather than indices	Open lesson
break and continue	break exits while continue skips one iteration	Open lesson
Methods and Parameters	Java passes arguments by value	Open lesson
Return Values and Method Overloading	Overloading requires different parameter lists	Open lesson
Variable Scope	A local variable belongs to its enclosing block	Open lesson
Recursion: Base Cases and Calls	Recursion needs a reachable base case	Open lesson
User Input with Scanner	nextLine reads the remainder of a line	Open lesson
Command-Line Arguments	Arguments arrive as strings in args	Open lesson

Intermediate companion reference

Topic	Rule to remember	Lesson
Classes and Objects Explained	An object is an instance of a class	Open lesson
Fields, Attributes and Methods	Instance fields hold each object state	Open lesson
Constructors and Constructor Overloading	Constructors initialize newly created objects	Open lesson
this Keyword	this refers to the current object	Open lesson
Access and Non-Access Modifiers	private restricts access to implementation details	Open lesson
Encapsulation and Validation	Encapsulation protects object invariants	Open lesson
Inheritance and the super Keyword	super can invoke a superclass constructor or method	Open lesson
Polymorphism and Method Overriding	Overridden instance methods dispatch using the actual object	Open lesson
Abstraction and Interfaces	Interfaces define a shared contract	Open lesson
Inner and Anonymous Classes	A non-static inner class has an enclosing instance	Open lesson
Enums and Enum Constructors	Enum constants are fixed named instances	Open lesson
Packages and Imports	An import allows a shorter type name	Open lesson
Single and Multidimensional Arrays	Java multidimensional arrays are arrays of arrays	Open lesson
Array Operations and Sorting	Binary search requires matching sorted order	Open lesson
String Methods Reference	String methods return new text when transforming	Open lesson
StringBuilder and StringBuffer	StringBuilder is a mutable character sequence	Open lesson
Wrapper Classes and Autoboxing	Autoboxing converts primitives to wrapper objects	Open lesson
Collections Framework Explained	List keeps positions while Set models uniqueness	Open lesson
List, ArrayList and LinkedList	ArrayList offers constant-time indexed access	Open lesson
HashSet, TreeSet and LinkedHashSet	LinkedHashSet preserves insertion order	Open lesson
HashMap, TreeMap and LinkedHashMap	A Map associates unique keys with values	Open lesson
Iterators and the Iterable Interface	Iterable provides an Iterator	Open lesson
Collections Sorting and Comparators	Comparator defines an external ordering	Open lesson
Generics and Generic Classes	Generics provide compile-time type checking	Open lesson

Files and I/O companion reference

Topic	Rule to remember	Lesson
Exception Types and Hierarchy	RuntimeException subclasses are unchecked	Open lesson
try, catch, finally, throw and throws	throw raises an exception while throws declares it	Open lesson
Custom Exceptions and Multi-Catch	Custom exceptions express domain-specific failures	Open lesson
Try-with-Resources	Try-with-resources closes AutoCloseable resources	Open lesson
File Handling: Create, Read, Write, Delete	File open options determine overwrite or append behavior	Open lesson
Path and Files APIs	Path models a path while Files performs operations	Open lesson
Byte Streams and Character Streams	Character streams decode or encode text	Open lesson
FileInputStream and FileOutputStream	InputStream.read returns minus one at end of stream	Open lesson
BufferedReader and BufferedWriter	readLine returns null at end of input	Open lesson
Serialization and Deserialization	Serializable marks types for native object serialization	Open lesson
JSON Processing with Jackson	A JSON library parses structured data rather than string splitting	Open lesson

Advanced companion reference

Topic	Rule to remember	Lesson
Lambda Expressions	A lambda implements a functional interface	Open lesson
Functional Interfaces	Function transforms while Predicate tests a value	Open lesson
Method References	A method reference adapts an existing method	Open lesson
Stream API: map, filter and reduce	Stream intermediate operations are lazy	Open lesson
Optional: Handling Missing Values	Optional models a present value or absence	Open lesson
Regular Expressions	matches validates the whole input	Open lesson
Date and Time API: java.time	LocalDate is a date without a time zone	Open lesson
Annotations Explained	Annotations provide metadata for tools or frameworks	Open lesson
Reflection API	Reflection inspects runtime type information	Open lesson
Multithreading and Thread Lifecycle	start begins execution on a new thread	Open lesson
Synchronization and Race Conditions	Synchronization coordinates access using a shared lock	Open lesson
ExecutorService and Thread Pools	ExecutorService manages submitted tasks	Open lesson
Concurrency Utilities	AtomicInteger provides atomic single-variable updates	Open lesson
Debugging and Logging Basics	A debugger pauses execution while logging records events	Open lesson

Developer Tools companion reference

Topic	Rule to remember	Lesson
JDK, JRE and JVM Explained	The JDK includes development tools and runtime capabilities	Open lesson
Installing Java and Setting Up the JDK	JAVA_HOME conventionally points to the JDK root	Open lesson
Compiling and Running Java Programs	javac compiles source and java launches bytecode	Open lesson
Classpath and Package Layout	Classpath entries are roots for locating classes	Open lesson
Maven and Gradle Basics	Build files declare dependencies and repeatable tasks	Open lesson
Unit Testing with JUnit	Unit tests compare observed behavior with explicit expectations	Open lesson
Debugging Java Applications Step by Step	Debugging tests a hypothesis with a reproducible case	Open lesson
Git Basics for Java Projects	A commit records a reviewed change in repository history	Open lesson
Modern Java: Records, Sealed Classes and Patterns	Records are data carriers with generated component accessors	Open lesson
Modules and module-info.java	exports exposes a package from a named module	Open lesson

Java DSA companion reference

Topic	Rule to remember	Lesson
Time and Space Complexity	Big O describes growth with input size	Open lesson
Linear Search and Binary Search	Binary search requires sorted input	Open lesson
Sorting Algorithms Explained	Insertion sort maintains a sorted prefix	Open lesson
Stacks and Queues with ArrayDeque	Stacks use LIFO and ordinary queues use FIFO	Open lesson
Linked Lists: Nodes and Links	A linked list connects nodes through references	Open lesson
Hashing and Hash Tables	Hash collisions still require equality checks	Open lesson
Trees and Binary Search Trees	In-order traversal sorts keys of a valid BST	Open lesson
Heaps and Priority Queues	PriorityQueue exposes the next item by priority	Open lesson
Graphs, BFS and DFS	BFS explores an unweighted graph by edge distance	Open lesson
Recursion and Backtracking	Backtracking explores and then undoes choices	Open lesson
Dynamic Programming Basics	Dynamic programming reuses overlapping subproblem results	Open lesson

Practice and Projects companion reference

Topic	Rule to remember	Lesson
Examples Library for Beginners	An example should expose one behavior and its result	Open lesson
Exercises by Topic	Exercises should state inputs and expected behavior	Open lesson
Quizzes by Chapter	Quizzes diagnose understanding rather than replace coding practice	Open lesson
Coding Challenges with Test Cases	Challenge constraints guide the algorithm choice	Open lesson
Keywords Reference and Glossary	Keywords have reserved language-defined roles	Open lesson
String, Math and Collections Methods	API references should include behavior and edge cases	Open lesson
Common Java Errors and Solutions	Compile errors, runtime failures and logic errors are different	Open lesson
Interview Questions and Answers	equals checks the equality contract while == checks reference identity	Open lesson
Beginner Java Projects with Practice Steps	A small project needs clear acceptance criteria	Open lesson
Intermediate Java Projects: Collections and Files	Domain operations should preserve state invariants	Open lesson
Advanced Java Projects: Testing and Concurrency	Advanced projects need explicit failure and shutdown policies	Open lesson
Learning Roadmap and Study Plan	A roadmap orders skills by prerequisites and practice	Open lesson

How to use this Java cheat sheet

This Java cheat sheet collects the syntax beginners and intermediate programmers look up most often, in the same order as the course: program structure, variables and types, input and output, strings, conditions, loops and arrays, methods, classes, collections, inheritance and interfaces, enums, records, generics, exceptions, files, dates, streams and testing. Each row links to the lesson that explains it with examples and common mistakes.

Keep it beside you while you write programs in IntelliJ IDEA, VS Code or Eclipse. When you can't remember whether arrays use length or length(), how to read a whole line with Scanner, or the shape of a try-with-resources block, a quick glance answers it. Type a keyword into the filter box to jump straight to the right row, or print the page as a one-sheet reference.

Java gotchas worth remembering

Compare strings with equals. == checks whether two references point at the same object. name.equals("Ana") compares the text.
Integer division truncates. 7 / 2 is 3. Use a double on one side for 3.5.
Arrays have length, strings have length(), lists have size(). Mixing them up is the most common compile error for beginners.
Scanner leaves a newline behind. After nextInt(), a following nextLine() returns an empty string. Call nextLine() once to clear it, or read every line and parse it.
Don't remove items while looping with for-each. It throws ConcurrentModificationException. Use removeIf or an Iterator instead.
Override equals and hashCode together. Otherwise your objects behave oddly as HashMap keys or in a HashSet. Records do both for you.

When a snippet surprises you, open the linked lesson for the full explanation, then test yourself with the Java quiz.