Java Cheat Sheet

Updated 2026-07-17

🎯Take a practice test on this topic9 practice tests · 357 questions→

🧠Study flashcards on this topic202 cards · spaced repetition→

Java is a class-based, object-oriented programming language designed for write once, run anywhere (WORA) portability through the Java Virtual Machine (JVM). Originally released in 1995, Java combines strong static typing with automatic memory management, making it a foundation for enterprise applications, Android development, and distributed systems. The language prioritizes readability, stability, and backward compatibility, allowing decades-old code to run on modern JVMs. As of Java 25 (LTS, September 2025) and Java 26 (March 2026), the language continues to evolve rapidly with virtual threads, records, pattern matching, sealed classes, stream gatherers, scoped values, and HTTP/3 support, making it one of the most actively developed platforms in the industry.

What This Cheat Sheet Covers

This topic spans 28 focused tables and 285 indexed concepts, 202 flashcards, 9 practice tests with 357 questions. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Primitive Data TypesTable 2: Reference Data TypesTable 3: OperatorsTable 4: Control Flow StatementsTable 5: Object-Oriented ProgrammingTable 6: Access ModifiersTable 7: Non-Access ModifiersTable 8: String OperationsTable 9: StringBuilder OperationsTable 10: Collections FrameworkTable 11: Exception HandlingTable 12: Lambda Expressions and Functional ProgrammingTable 13: Streams APITable 14: Collectors APITable 15: Concurrency and MultithreadingTable 16: GenericsTable 17: AnnotationsTable 18: Input/Output (I/O)Table 19: Date and Time APITable 20: Modern Java Features (Java 10 to 26)Table 21: OptionalTable 22: Reflection APITable 23: Nested ClassesTable 24: SerializationTable 25: Modules (JPMS)Table 26: Enum FeaturesTable 27: Packages and ImportsTable 28: Type Casting and Conversion

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: Primitive Data Types

Java's eight primitives are the only values that aren't objects. They hold raw numbers, characters, and booleans directly rather than as references, which is also why none of them can be null. The practical advice is short: reach for int and double by default, and drop to long, byte, or float only when range, binary handling, or memory genuinely calls for it.

Type	Example	Description
int	`int count = 100;`	• 32-bit signed integer • default choice for whole numbers • range approximately ±2.1 billion • overflow wraps silently, it never throws.
long	`long big = 9876543210L;`	• 64-bit signed integer • a literal past the `int` range needs the L suffix • used for timestamps, large counts, or IDs.
double	`double price = 99.99;`	• 64-bit floating-point (IEEE 754 binary64) • default for decimal numbers • never for money, use `BigDecimal`.
boolean	`boolean active = true;`	• Logical type holding true or false • no conversion to or from integers, so `if (count)` will not compile.
char	`char letter = 'A';`	• 16-bit UTF-16 code unit • single quotes only • range U+0000 to U+FFFF, so an emoji needs two `char`s.
byte	`byte b = 127;`	• 8-bit signed integer • range -128 to 127 • a literal outside that range is a compile error, not a warning.
short	`short s = 32000;`	• 16-bit signed integer • range -32,768 to 32,767 • mainly for large arrays where the memory saving actually matters.
float	`float pi = 3.14f;`	• 32-bit floating-point • requires f suffix • only ~7 significant digits against `double`'s ~15.

Table 2: Reference Data Types

Everything that isn't a primitive is a reference type: the variable holds a pointer to an object on the heap rather than the object itself, which is why two variables can quietly share one object and why Java's "pass-by-value" applies to the reference, not the thing it points at. Strings, arrays, classes, and interfaces are the foundation, while records and sequenced collections show how Java keeps adding richer ways to model data.

Type	Example	Description
String	`String name = "Java";`	• Immutable sequence of characters • most commonly used reference type • because it can never change, one `String` is safely shared across threads with no locking • literals are interned in the string pool.

The rest of this section is part of the full cheat sheet

Table 3: Operators

The symbols that combine and compare values: arithmetic, assignment, comparison, and logical operators, plus the bitwise tools for working at the bit level. Three things trip people up more than anything else here. == compares references for objects, so reach for .equals() when you care about contents. && and || short-circuit, stopping the moment the result is known, while & and | never do. And integer division truncates, so 1 / 2 is 0.

Operator	Example	Description
Arithmetic	`int sum = a + b;` `int rem = 10 % 3;`	• `+` `-` `` `/` `%` for basic math* • integer division truncates toward zero (`5 / 2` is `2`) • `%` returns a remainder that keeps the dividend's sign (`-7 % 3` is `-1`).

The rest of this section is part of the full cheat sheet

Table 4: Control Flow Statements

These statements decide which code runs and how many times: branching with if and switch, looping with for, while, and do-while, and jumping out with break, continue, and return. Two rules cause most of the bugs here: an old-style switch falls straight through every arm below the match unless you write break, and a break inside that switch escapes only the switch, never the loop around it. The modern switch expression fixes the first one by design.

Statement	Example	Description
if-else	`if (x > 0) { ... }` `else { ... }`	• Executes a block based on a boolean condition (an `int` will not compile) • in an `else if` chain the first true condition wins and the rest are never evaluated.

The rest of this section is part of the full cheat sheet

Table 1: Primitive Data Types

Type	Example	Description
int	`int count = 100;`	• 32-bit signed integer • default choice for whole numbers • range approximately ±2.1 billion • overflow wraps silently, it never throws.
long	`long big = 9876543210L;`	• 64-bit signed integer • a literal past the `int` range needs the L suffix • used for timestamps, large counts, or IDs.
double	`double price = 99.99;`	• 64-bit floating-point (IEEE 754 binary64) • default for decimal numbers • never for money, use `BigDecimal`.
boolean	`boolean active = true;`	• Logical type holding true or false • no conversion to or from integers, so `if (count)` will not compile.
char	`char letter = 'A';`	• 16-bit UTF-16 code unit • single quotes only • range U+0000 to U+FFFF, so an emoji needs two `char`s.
byte	`byte b = 127;`	• 8-bit signed integer • range -128 to 127 • a literal outside that range is a compile error, not a warning.
short	`short s = 32000;`	• 16-bit signed integer • range -32,768 to 32,767 • mainly for large arrays where the memory saving actually matters.
float	`float pi = 3.14f;`	• 32-bit floating-point • requires f suffix • only ~7 significant digits against `double`'s ~15.

Table 2: Reference Data Types

Type	Example	Description
String	`String name = "Java";`	• Immutable sequence of characters • most commonly used reference type • because it can never change, one `String` is safely shared across threads with no locking • literals are interned in the string pool.

Table 3: Operators

Operator	Example	Description
Arithmetic	`int sum = a + b;` `int rem = 10 % 3;`	• `+` `-` `` `/` `%` for basic math* • integer division truncates toward zero (`5 / 2` is `2`) • `%` returns a remainder that keeps the dividend's sign (`-7 % 3` is `-1`).

Table 4: Control Flow Statements

Statement	Example	Description
if-else	`if (x > 0) { ... }` `else { ... }`	• Executes a block based on a boolean condition (an `int` will not compile) • in an `else if` chain the first true condition wins and the rest are never evaluated.