1Z0-830 — Oracle Java SE 21 Developer Professional Cheat Sheet

Unless a question explicitly states that preview features are enabled, answer using standard Java SE 21 features only. Java 21 includes preview/incubator features, but exam-safe reasoning should not assume them.

1. Review the tables and decision rules.
2. Mark topics where you hesitate.
3. Drill those topics in a question bank.
4. Read explanations carefully, especially for compile-time errors and small output differences.

The real challenge on 1Z0-830 is rarely remembering one isolated API call. It is usually reading Java code exactly: scope, overload resolution, generics, stream laziness, exception flow, object identity, module visibility, concurrency behavior, and Java SE 21 language features.

## Compile a modular application
javac --module-source-path src -d mods -m com.example.app

## Run a modular application
java --module-path mods -m com.example.app/com.example.app.Main

## Describe a modular JAR
jar --describe-module --file app.jar

Module directives

module com.example.app {
    requires java.sql;
    requires transitive com.example.api;

    exports com.example.app.api;
    opens com.example.app.model to com.fasterxml.jackson.databind;

    uses com.example.spi.Reporter;
}

Module traps

module-info.java

Example:

module com.example.app {
    requires com.example.service;
    exports com.example.api;
    opens com.example.model;
    uses com.example.spi.Plugin;
}

High-yield distinction:

• exports is about ordinary public type accessibility.
• opens is about deep reflection.
• A public class in a non-exported package is not necessarily accessible to other named modules.
• The class path and module path have different visibility rules.

var quick rules

var names = List.of("Ada", "Linus");   // List<String>
var count = 10;                        // int, not Integer

// Valid: all lambda parameters use var
BiFunction<String, String, Integer> len =
        (var a, var b) -> a.length() + b.length();

Numeric, boolean, and text traps

Control flow

int result = switch (grade) {
    case "A", "B" -> 1;
    case "C" -> {
        int adjusted = curve();
        yield adjusted;
    }
    default -> 0;
};

Primitives, wrappers, and promotion

Common trap:

byte b = 1;
// b = b + 1;   // does not compile: int result
b += 1;         // compiles: implicit narrowing conversion

String, StringBuilder, and text blocks

Watch for:

• substring, replace, trim, strip, toLowerCase, and similar methods do not mutate the original String.
• StringBuilder.equals() is not value-based like String.equals(). Unless overridden by a subclass, it uses object identity.
• Text block questions may test spaces and newlines, not just visible words.

var rules

Examples:

var name = "java";        // String
var list = new ArrayList<String>();
// var value;             // does not compile
// var n = null;          // does not compile

var is not dynamic typing. The type is fixed at compile time.

Switch statements vs switch expressions

int score = switch (grade) {
    case "A" -> 5;
    case "B" -> 4;
    default -> 0;
};

With a block:

int score = switch (grade) {
    case "A" -> {
        System.out.println("excellent");
        yield 5;
    }
    default -> 0;
};

Switch traps

class Parent {
    Number value() throws IOException { return 1; }
    static void label() {}
}

class Child extends Parent {
    @Override
    Integer value() throws FileNotFoundException { return 2; } // covariant + narrower
    static void label() {} // hides, does not override
}

Interface rules

Nested, local, and anonymous classes

Enums

Records

Records are transparent data carriers, but they are only shallowly immutable.

record Money(BigDecimal amount, Currency currency) {
    Money {
        Objects.requireNonNull(amount);
        Objects.requireNonNull(currency);
        amount = amount.stripTrailingZeros(); // normalize parameter
    }
}

Sealed classes and interfaces

sealed interface Shape permits Circle, Rectangle {}

record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}

Pattern matching and Java 21 switch

static String describe(Object obj) {
    return switch (obj) {
        case null -> "null";
        case String s when s.isBlank() -> "blank string";
        case String s -> "string: " + s;
        case Integer i -> "integer: " + i;
        case Point(int x, int y) -> "point " + x + "," + y;
        default -> "other";
    };
}

Records

Records are compact carriers for shallowly immutable data.

record Point(int x, int y) {}

The compiler provides:

• private final fields for components
• public accessor methods named x() and y()
• canonical constructor
• equals, hashCode, and toString

Record review table:

Compact constructor trap:

record Range(int start, int end) {
    Range {
        if (start > end) throw new IllegalArgumentException();
        // assignments to components happen automatically after this block
    }
}

Sealed classes and interfaces

Sealed types restrict which classes or interfaces can directly extend or implement them.

sealed interface Shape permits Circle, Rectangle {}

final class Circle implements Shape {}
non-sealed class Rectangle implements Shape {}

Rules to remember:

• A sealed type lists permitted direct subclasses with permits, unless they are discoverable in the same compilation unit.
• Each permitted direct subclass must declare exactly one of final, sealed, or non-sealed.
• Sealed hierarchies support exhaustiveness checks in pattern switches.
• Sealing controls direct inheritance, not object creation by itself.

Pattern matching

instanceof pattern:

if (obj instanceof String s) {
    System.out.println(s.length());
}

Pattern variable scope is flow-sensitive. The variable exists only where the compiler knows the pattern matched.

Common examples:

if (!(obj instanceof String s)) {
    return;
}
System.out.println(s.length()); // valid

Pattern switch:

String result = switch (obj) {
    case Integer i when i > 0 -> "positive integer";
    case Integer i -> "integer";
    case String s -> "string";
    case null -> "null";
    default -> "other";
};

Common traps:

• Put narrower or guarded cases before broader cases.
• case Object o can dominate later cases depending on selector type and exhaustiveness.
• Guarded patterns with when are not the same as unguarded total patterns.
• Record patterns deconstruct records but still follow type and scope rules.

PECS: producer extends, consumer super.

static double total(List<? extends Number> nums) {
    return nums.stream().mapToDouble(Number::doubleValue).sum();
}

static void addDefaults(List<? super Integer> nums) {
    nums.add(1);
    nums.add(2);
}

Arrays vs collections

Collection selection matrix

Mutability and factory traps

Sequenced collections in Java 21

Generic type rules

PECS memory aid:

• Producer extends: use ? extends T when the structure produces T values for you.
• Consumer super: use ? super T when the structure consumes T values from you.

Collection factories and mutability

Ordering and equality

Set/map trap: if compareTo or a comparator says two objects are equal, a TreeSet treats them as duplicates even if equals would differ.

Sequenced collections in Java SE 21

Java SE 21 adds sequenced collection abstractions for collections with a defined encounter order.

Do not assume every collection is sequenced. A hash-based collection without defined encounter order is different from an ordered collection.

Primitive specializations avoid boxing: IntPredicate, IntFunction<R>, ToIntFunction<T>, IntSupplier, IntConsumer, IntUnaryOperator, ObjIntConsumer<T>.

Method reference forms

Stream pipeline rules

Common stream operations

Map<Department, Long> counts =
    employees.stream()
             .filter(Employee::active)
             .collect(Collectors.groupingBy(
                 Employee::department,
                 Collectors.counting()
             ));

Map<String, Integer> salaryByName =
    employees.stream()
             .collect(Collectors.toMap(
                 Employee::name,
                 Employee::salary,
                 Integer::max
             ));

Optional traps

Catching and throwing rules

Try-with-resources

Resources must implement AutoCloseable or Closeable.

try (BufferedReader reader = Files.newBufferedReader(path);
     BufferedWriter writer = Files.newBufferedWriter(out)) {
    writer.write(reader.readLine());
}

Checked vs unchecked

Try-with-resources

try (var in = Files.newBufferedReader(path);
     var out = Files.newBufferedWriter(otherPath)) {
    // use resources
}

Rules:

• Resources must implement AutoCloseable or Closeable.
• Resources close in reverse order of creation.
• If both the try block and close operation throw, close exceptions may become suppressed exceptions.
• Resource variables are effectively final inside the try block.

Catch and finally traps

DateTimeFormatter fmt =
    DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")
                     .withLocale(Locale.US);

LocalDate date = LocalDate.parse("2026-06-18");
String text = LocalDateTime.now().format(fmt);

BigDecimal and numeric precision

BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("1.00");

boolean sameNumber = a.compareTo(b) == 0; // true
boolean sameObjectValue = a.equals(b);    // false: scale differs

Localization

java.time

• java.time classes are immutable.
• Months in LocalDate.of(year, month, day) are 1-based if using integers.
• Prefer Month.JANUARY style in real code when clarity matters.
• Period is date-based; Duration is time-based.
• Time zones and daylight saving transitions can produce non-obvious results.

Formatting and localization

Resource bundle review:

• Lookup uses a fallback chain based on requested locale and base bundle.
• Missing keys can throw MissingResourceException.
• Localization questions often test which bundle is selected, not translation knowledge.

NIO.2 Path and Files

try (Stream<Path> paths = Files.walk(root)) {
    paths.filter(Files::isRegularFile)
         .forEach(System.out::println);
}

Path traversal guard pattern

Path base = Path.of("/app/uploads").toRealPath();
Path candidate = base.resolve(userInput).normalize();

if (!candidate.startsWith(base)) {
    throw new SecurityException("Invalid path");
}

For existing files, use toRealPath() where appropriate to account for symbolic links and actual file-system resolution.

Path and Files

Byte and character streams

• Byte streams are not character streams.
• Character encoding matters when converting bytes to text.
• Many I/O methods throw checked IOException.
• Streams returned by file APIs may be lazy and need explicit closing or try-with-resources.

Executors and futures

Virtual threads in Java 21

Virtual threads are standard in Java 21 and are useful for large numbers of blocking tasks.

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    Future<String> result = executor.submit(() -> fetchRemoteValue());
    System.out.println(result.get());
}

Synchronization and memory visibility

class Counter {
    private final AtomicInteger value = new AtomicInteger();

    int increment() {
        return value.incrementAndGet();
    }
}

Concurrent collections

Core concurrency concepts

Race condition trap:

count++; // read, add, write — not atomic

Use synchronization, locks, atomics, or concurrency-safe structures when shared mutable state is accessed by multiple threads.

Virtual threads in Java SE 21

Virtual threads are lightweight threads intended to make blocking, thread-per-task server-style code more scalable.

Review points:

• Created with APIs such as Thread.startVirtualThread(...) or virtual-thread executors.
• Useful for many blocking tasks, not for making CPU-bound algorithms automatically faster.
• Avoid assuming thread identity, scheduling order, or timing.
• Be careful with shared mutable state exactly as with platform threads.
• Blocking while holding monitors or using certain native operations can reduce scalability.

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    Future<String> f = executor.submit(() -> "done");
    System.out.println(f.get());
}

Concurrency traps

JDBC operation rules

String sql = "select name from employee where id = ?";

try (Connection con = dataSource.getConnection();
     PreparedStatement ps = con.prepareStatement(sql)) {

    ps.setLong(1, employeeId);

    try (ResultSet rs = ps.executeQuery()) {
        if (rs.next()) {
            return rs.getString("name");
        }
    }
}

Transaction pattern

try (Connection con = dataSource.getConnection()) {
    con.setAutoCommit(false);
    try {
        updateAccount(con, from);
        updateAccount(con, to);
        con.commit();
    } catch (SQLException e) {
        con.rollback();
        throw e;
    }
}

Core JDBC flow

Typical flow:

1. Obtain Connection.
2. Create PreparedStatement or Statement.
3. Bind parameters if needed.
4. Execute.
5. Process ResultSet if returned.
6. Commit/rollback when managing transactions.
7. Close resources, usually with try-with-resources.

try (Connection con = dataSource.getConnection();
     PreparedStatement ps = con.prepareStatement(
         "select name from employee where id = ?")) {

    ps.setInt(1, id);

    try (ResultSet rs = ps.executeQuery()) {
        while (rs.next()) {
            System.out.println(rs.getString(1));
        }
    }
}

JDBC review table

Common trap: PreparedStatement prevents SQL injection only when values are bound as parameters, not when user input is concatenated into SQL text before preparing.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Audited {
    String value() default "standard";
}

Secure coding checklist

High-yield rule: the reference type selects overloaded methods; the runtime object selects overridden instance methods.

class A {
    void m(Object o) { System.out.print("A-Object"); }
    void n() { System.out.print("A"); }
}
class B extends A {
    void m(String s) { System.out.print("B-String"); } // overload
    @Override void n() { System.out.print("B"); }
}

A x = new B();
x.m("hi"); // A-Object
x.n();     // B

Constructors and initialization

Review order:

1. Static fields and static initializers, superclass first.
2. Instance fields and instance initializers, superclass first.
3. Superclass constructor.
4. Subclass instance fields/initializers and constructor body.

Constructor rules:

• A constructor call to this(...) or super(...) must be the first statement when explicit.
• If no constructor is declared, a default no-argument constructor is provided.
• If any constructor is declared, no default constructor is automatically added.
• Abstract classes can have constructors.
• Interfaces do not have constructors.

Interfaces

Conflict rule: if a class inherits conflicting defaults, it must override and choose or provide behavior. A superclass instance method generally wins over an interface default.

• A stream cannot be reused after a terminal operation.
• Intermediate operations do not run until a terminal operation.
• peek is mainly for debugging; do not rely on it without a terminal operation.
• findAny may return any matching element, especially with parallel streams.
• forEach on a parallel stream does not preserve order; forEachOrdered attempts encounter order.

map vs flatMap

Example idea:

List<List<String>> groups = List.of(List.of("a", "b"), List.of("c"));

groups.stream()
      .flatMap(List::stream)
      .toList(); // ["a", "b", "c"]

Reduce and collect

Reduction trap: for parallel streams, accumulator and combiner must be associative and compatible with the identity. Side effects in reductions are a common source of wrong answers.

Optional