1Z0-829 — Oracle Java SE 17 Developer Cheat Sheet

This page is IT Mastery review support. It is not affiliated with Oracle and does not replace Oracle’s official exam information.

1. Scan the tables first. Mark anything you cannot explain without looking it up.
2. Run topic drills immediately after each weak area. Java exam misses often come from small compile-time or runtime details.
3. Practice with code mentally and in an IDE. The real challenge is usually not knowing an API exists; it is predicting exact behavior.
4. Use detailed explanations to fix patterns. If you miss several questions on streams, generics, modules, or date/time, slow down and rebuild the rule set.

var names = List.of("Ana", "Bo");       // inferred List<String>
var nums = new int[] {1, 2, 3};         // valid
// var bad = {1, 2, 3};                 // invalid
// var none = null;                     // invalid

int count = 0;
// Runnable r = () -> count++;          // invalid: count not effectively final

Primitive Types, Literals, and Numeric Promotion

byte b = 10;
// b = b + 1;       // invalid: b + 1 is int
b += 1;             // valid: implicit cast to byte

short s = 1;
char c = 2;
int result = s + c; // promoted to int

long x = 10;        // int literal widened to long
float f = 10.0f;    // suffix required for float literal

Operators and Evaluation

Integer a = 1000;
Integer b = 1000;
System.out.println(a == b);      // false: different references likely
System.out.println(a.equals(b)); // true

Integer c = 10;
int d = 10;
System.out.println(c == d);      // true: c unboxed

Wrapper cache details can appear in questions, but the safer exam habit is: use equals() for value equality unless the question is specifically testing identity or unboxing.

Source files, packages, imports, and main

Identifiers, var, and scope

Remember: var does not make Java dynamically typed. The type is inferred at compile time and then fixed.

Primitive types and numeric promotion

High-yield example: char + char produces an int, not a char.

Equality and object identity

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

Switch Statements and Switch Expressions

int score = 2;

String grade = switch (score) {
    case 1 -> "low";
    case 2, 3 -> "mid";
    default -> {
        String label = "high";
        yield label;
    }
};

Pattern Matching for instanceof

Object obj = "java";

if (obj instanceof String s && s.length() > 2) {
    System.out.println(s.toUpperCase());
}

// if (obj instanceof String t || t.length() > 2) { } // invalid

if, loops, labels, break, and continue

Enhanced for gives you the element value/reference, not an index. Reassigning the loop variable does not replace array or collection elements.

Switch statements and switch expressions

Common switch-compatible types include integral types and wrappers, String, enums, and certain other supported forms. Do not treat boolean, long, float, or double as normal switch selector types.

High-yield traps:

• case labels must be compatible constants or valid case forms.
• default is optional in some statements but often needed in expressions.
• Arrow case syntax and colon case syntax behave differently.
• Missing break in colon-style statements can cause fall-through.

String s = "abc";
s.concat("d");
System.out.println(s);       // abc

StringBuilder sb = new StringBuilder("abc");
sb.append("d");
System.out.println(sb);      // abcd

String text = """
        line one
        line two
        """;

Arrays

Object[] values = new String[2];
// values[0] = new Object(); // ArrayStoreException at runtime

int[][] grid = new int[2][];
grid[0] = new int[] {1, 2};
grid[1] = new int[] {3};

String, StringBuilder, and text blocks

Common String methods to know: charAt, indexOf, substring, replace, trim, strip, isBlank, startsWith, endsWith, contains, split, join, format.

Important distinction:

Formatting numbers and text

Know the broad roles:

Pattern letters are case-sensitive. For date/time formatting, M and m are not interchangeable: month versus minute is a frequent trap.

High-yield rules:

• Top-level classes can be public or package-private only.
• A source file may contain multiple top-level classes, but at most one public top-level class.
• The public top-level class name must match the file name.
• protected across packages is not the same as package access; access must be through the subclass relationship.

Initialization Order

class Parent {
    static { System.out.print("A"); }
    { System.out.print("B"); }
    Parent() { System.out.print("C"); }
}
class Child extends Parent {
    static { System.out.print("D"); }
    { System.out.print("E"); }
    Child() { System.out.print("F"); }
}
// new Child() after class loading prints: A D B C E F

Inheritance, Overriding, and Hiding

class A {
    static void s() { System.out.print("A.s "); }
    void m() { System.out.print("A.m "); }
}
class B extends A {
    static void s() { System.out.print("B.s "); }
    @Override void m() { System.out.print("B.m "); }
}

A ref = new B();
ref.s(); // A.s: static method chosen by reference type
ref.m(); // B.m: instance method chosen by object type

Interfaces

Default method conflict rules:

1. Class method wins over interface default.
2. More specific interface wins over less specific interface.
3. If unrelated defaults conflict, implementing class must override.

interface A {
    default String name() { return "A"; }
}
interface B {
    default String name() { return "B"; }
}
class C implements A, B {
    public String name() {
        return A.super.name();
    }
}

Initialization order

For a new object, reason in this order:

1. Load and initialize needed classes.
2. Initialize superclass static fields and static blocks.
3. Initialize subclass static fields and static blocks.
4. Allocate object memory with default values.
5. Run superclass instance fields, instance initializer blocks, and constructor.
6. Run subclass instance fields, instance initializer blocks, and constructor.

Within a class, fields and initializer blocks execute in textual order.

High-yield trap: overridden methods called from constructors use dynamic dispatch, so subclass methods may run before subclass fields are fully initialized.

Access modifiers

protected is commonly misunderstood. A subclass in another package does not get unrestricted access to every protected member on every superclass reference.

Overloading, overriding, and hiding

Overload resolution often chooses the most specific applicable method. Widening, boxing, varargs, and inheritance can interact; practice these with original practice questions until the selection order feels automatic.

Abstract classes, interfaces, enums, records, and sealed types

Records:

• Components become private final fields plus public accessor methods.
• Accessor names are component names, not JavaBean getX names by default.
• A compact constructor cannot assign directly to component fields before the implicit assignment.
• Records can implement interfaces.
• Records cannot declare additional instance fields beyond record components, but they can declare static fields.

Sealed types:

• Direct subclasses must be permitted.
• Direct subclasses must declare final, sealed, or non-sealed.
• Sealed hierarchies are a common source of compile-time questions.

Pattern matching for instanceof

Pattern matching reduces casting:

• Traditional idea: check type, then cast.
• Java 17 style: if (obj instanceof String s) { ... }.

Review points:

record Range(int start, int end) {
    Range {
        if (end < start) throw new IllegalArgumentException();
    }

    int length() {
        return end - start;
    }
}

Record traps:

• Accessor is x(), not getX(), unless manually added.
• Compact constructors assign component fields automatically after the body.
• You may reassign constructor parameters in a compact constructor to normalize values.
• Records are shallowly immutable; mutable component objects can still mutate internally.

Sealed Classes and Interfaces

sealed interface Shape permits Circle, Rectangle {}

final class Circle implements Shape {}

non-sealed class Rectangle implements Shape {}

class Square extends Rectangle {} // allowed because Rectangle is non-sealed

Exam reminders:

• Every direct subclass of a sealed type must declare exactly one of final, sealed, or non-sealed.
• Sealing controls direct inheritance, not object creation by itself.
• A sealed class can be abstract or concrete.

Enums

enum Level {
    LOW(1), HIGH(2);

    private final int code;

    Level(int code) {
        this.code = code;
    }

    int code() {
        return code;
    }
}

Try, Catch, Finally, and Multi-Catch

try {
    throw new java.io.IOException();
} catch (java.io.FileNotFoundException e) {
    // more specific first
} catch (java.io.IOException | RuntimeException e) {
    // e is effectively final
}

Try-With-Resources

try (var in = new FileInputStream("a.txt");
     var out = new FileOutputStream("b.txt")) {
    in.transferTo(out);
} // out closes first, then in

Checked, unchecked, and errors

• Catch blocks must be ordered from more specific to more general.
• A catch block that can never be reached causes a compile error.
• Multi-catch alternatives cannot be related by subclassing.
• The exception variable in a multi-catch is effectively final.
• A finally block usually runs whether or not an exception is thrown.
• A finally block can suppress or replace an earlier return/throw if it completes abruptly.

Try-with-resources

Do not forget that close() itself may throw an exception depending on the resource type.

static <T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) >= 0 ? a : b;
}

Wildcards: PECS

List<? extends Number> nums = List.of(1, 2, 3);
Number n = nums.get(0);
// nums.add(4); // invalid except null

List<? super Integer> sink = new ArrayList<Number>();
sink.add(10);
Object value = sink.get(0);

Collection Selection Matrix

Factory and Wrapper Methods

Comparator and Comparable

record Person(String name, int age) {}

var people = new ArrayList<Person>();
people.sort(
    Comparator.comparing(Person::name)
              .thenComparingInt(Person::age)
);

equals, hashCode, and ordering traps:

• If two objects are equal by equals, they must have the same hashCode.
• HashSet uniqueness uses equals and hashCode.
• TreeSet uniqueness is based on comparison result 0.
• Natural ordering inconsistent with equals can produce surprising set/map behavior.

Arrays

Array covariance is unlike generic invariance. String[] can be assigned to Object[], but List<String> cannot be assigned to List<Object>.

Collections quick map

Mutability and factory methods

High-yield distinction: unmodifiable is not the same as immutable if the underlying data can still change through another reference.

Generics and wildcards

Use PECS: Producer Extends, Consumer Super.

Common traps:

• Generic type parameters are erased at runtime.
• You cannot create new T() directly.
• You cannot create a normal array of a parameterized type such as new List<String>[10].
• List<Integer> is not a subtype of List<Number>.

Sorting and comparison

If input is not sorted correctly, binary search results are not reliable.

Lambda Syntax and Method References

Predicate<String> nonEmpty = s -> !s.isEmpty();
Function<String, Integer> parse = Integer::parseInt;
Supplier<List<String>> makeList = ArrayList::new;

Lambda traps:

• A lambda targets a functional interface, not just any type.
• Checked exceptions must match the functional interface method.
• this inside a lambda refers to the enclosing instance.
• Captured local variables must be final or effectively final.
• Parameter names cannot redeclare local variables already in scope.

Functional interfaces

A functional interface has exactly one abstract method, though it may also have default, static, and private methods.

• Captured local variables must be final or effectively final.
• Parameter types can be inferred, but syntax must be consistent.
• A lambda body with braces needs explicit return for non-void results.
• Method references must match the target functional interface signature.

Stream pipeline rules

Streams do not modify the source unless the operation itself causes side effects. Prefer side-effect-free lambdas, especially with parallel streams.

Intermediate operations

Terminal operations

Collectors

toMap is a common trap: duplicate keys require a merge function unless the data guarantees uniqueness.

Primitive streams and Optional

Know common Optional methods: isPresent, isEmpty, get, orElse, orElseGet, orElseThrow, ifPresent, map, flatMap, filter.

High-yield distinction:

long count = List.of("a", "bb", "ccc").stream()
        .filter(s -> s.length() > 1)
        .map(String::toUpperCase)
        .count();

Stream traps:

• A stream cannot be reused after a terminal operation.
• Intermediate operations do not run until a terminal operation occurs.
• Avoid modifying the stream source during pipeline execution.
• peek is mainly for debugging; do not rely on it for required side effects.
• Parallel stream operations should be stateless, non-interfering, and associative where reduction is involved.

Common Stream Operations

Primitive Streams

int total = IntStream.rangeClosed(1, 5).sum(); // 15
List<Integer> boxed = IntStream.range(1, 4).boxed().toList();

Collectors

Map<Integer, List<String>> byLength =
    Stream.of("a", "bb", "cc")
          .collect(Collectors.groupingBy(String::length));

Map<Character, String> merged =
    Stream.of("ant", "ape")
          .collect(Collectors.toMap(
              s -> s.charAt(0),
              s -> s,
              (left, right) -> left + "," + right
          ));

Optional

String value = Optional.of("java")
        .filter(s -> s.length() > 2)
        .map(String::toUpperCase)
        .orElse("NONE");

LocalDate date = LocalDate.of(2026, Month.JUNE, 18);
LocalDate next = date.plus(Period.ofDays(3));

LocalTime time = LocalTime.of(9, 30);
LocalTime later = time.plus(Duration.ofMinutes(45));

• java.time classes are immutable.
• LocalDate does not contain time or zone information.
• Use Period for date-based units; use Duration for time-based units.
• Month numbers are 1-based in factory methods.
• Many date/time methods throw runtime exceptions for invalid dates or unsupported units.

Formatting and Parsing

DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd");
String text = LocalDate.of(2026, 6, 18).format(fmt);
LocalDate parsed = LocalDate.parse(text, fmt);

Locale and Resource Bundles

Resource bundle search conceptually moves from most specific to less specific, then may consider default locale, then base bundle. For example, for base messages and locale fr_CA, candidates should recognize names such as:

messages_fr_CA
messages_fr
messages

Java date/time API

Most java.time types are immutable.

• Period is for dates; Duration is for time-based amounts.
• Date/time objects are immutable; date.plusDays(1) returns a new object.
• Formatting patterns are case-sensitive.
• Some operations may adjust invalid dates, such as month-end calculations.
• Time zones and daylight saving transitions can affect ZonedDateTime.

Localization

Resource bundle lookup can fall back through less-specific locales. Practice questions often test which bundle is selected or whether a key is found.

try (BufferedReader reader = Files.newBufferedReader(Path.of("data.txt"))) {
    reader.lines()
          .filter(s -> !s.isBlank())
          .forEach(System.out::println);
}

Path and Files

Path p = Path.of("logs", ".", "app.log").normalize();
Path absolute = p.toAbsolutePath();

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

NIO.2 traps:

• Many Path methods are lexical and do not access the filesystem.
• Files.walk, Files.find, and Files.list must be closed.
• Path iteration skips the root and iterates name elements.
• resolve with an absolute right-hand path returns the right-hand path.

Serialization

class User implements Serializable {
    private static final long serialVersionUID = 1L;

    private String name;
    private transient String sessionToken;
}

Path and Files

Byte streams, character streams, and buffering

Remember to close I/O resources. Try-with-resources is the standard exam-safe pattern.

Serialization review

Serialization questions often combine inheritance, transient, static fields, and default values.

Runnable task = () -> System.out.println(Thread.currentThread().getName());
Thread t = new Thread(task);
t.start();

Executors and Futures

ExecutorService service = Executors.newFixedThreadPool(2);
try {
    Future<Integer> future = service.submit(() -> 40 + 2);
    Integer answer = future.get();
} finally {
    service.shutdown();
}

Synchronization, Visibility, and Atomicity

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

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

Deadlock checklist:

• Are two locks acquired in different orders?
• Is a lock held while waiting for another lock?
• Is external code called while holding a lock?
• Is wait() used without a condition loop?

Threads, tasks, and executors

High-yield trap: creating a Thread object does not start execution. Calling run() directly is just a normal method call; start() starts a new thread.

Synchronization and shared state

Common concurrency errors:

• Race condition: result depends on timing.
• Deadlock: threads wait forever for each other’s locks.
• Starvation: a thread cannot get needed resources.
• Livelock: threads keep reacting but make no progress.
• Unsafe publication: other threads see stale or partially initialized state.

Parallel streams

Parallel streams can improve throughput for suitable workloads, but exam questions often focus on correctness:

• Avoid shared mutable state.
• Do not assume forEach preserves order.
• Use associative, stateless operations for reductions.
• findAny may differ from findFirst.
• Side effects become harder to reason about.

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

    exports com.example.app.api;
    opens com.example.app.model;

    uses com.example.spi.Plugin;
    provides com.example.spi.Plugin with com.example.impl.DefaultPlugin;
}

Module Decision Points

Module traps:

• Readability and accessibility are separate: requires grants readability; exports grants access to public types in a package.
• Packages are not exported by default.
• Reflection into non-public members requires openness.
• Named modules cannot generally depend on classes from the unnamed module.
• Automatic modules export all packages and read other resolved modules.
• Avoid split packages across named modules.

Useful Module Commands

javac -d mods --module-source-path src $(find src -name "*.java")

java --module-path mods \
     --module com.example.app/com.example.app.Main

jar --create --file app.jar \
    --main-class com.example.app.Main \
    -C mods/com.example.app .

jdeps --module-path mods --module com.example.app

Statement Execution

String sql = "select id, name from users where status = ?";

try (Connection conn = DriverManager.getConnection(url);
     PreparedStatement ps = conn.prepareStatement(sql)) {

    ps.setString(1, "ACTIVE"); // JDBC parameters are 1-based

    try (ResultSet rs = ps.executeQuery()) {
        while (rs.next()) {
            int id = rs.getInt("id");
            String name = rs.getString("name");
        }
    }
}

ResultSet and Transactions

try (Connection conn = DriverManager.getConnection(url)) {
    conn.setAutoCommit(false);
    try (PreparedStatement ps = conn.prepareStatement(
            "update account set balance = balance - ? where id = ?")) {
        ps.setBigDecimal(1, amount);
        ps.setLong(2, accountId);
        ps.executeUpdate();
        conn.commit();
    } catch (SQLException e) {
        conn.rollback();
        throw e;
    }
}

Core JDBC flow

Statement selection

Execution method traps:

Always distinguish SQL parameter indexes from Java array indexes: JDBC parameters are commonly 1-based.

Built-in and meta-annotations

• Element types are restricted to primitives, String, Class, enums, annotations, and arrays of those types.
• Elements can have default values.
• If the only required element is named value, shorthand syntax can be used.
• Retention matters: reflection requires runtime retention.

API Behavior Traps

• String, LocalDate, LocalTime, LocalDateTime, and most java.time types are immutable.
• StringBuilder.equals() uses object identity unless comparing same reference.
• List.of, Set.of, and Map.of are unmodifiable and reject null.
• Arrays.asList is fixed-size and backed by the array.
• TreeSet and TreeMap need consistent ordering.
• Optional.orElse evaluates its argument eagerly; orElseGet is lazy.
• Files.walk, Files.find, and Files.list return streams that should be closed.
• PreparedStatement parameters and ResultSet column indexes are 1-based.
• volatile improves visibility, not compound atomicity.
• exports is for API access; opens is for deep reflection.

Module review points:

• java.base is required implicitly.
• module-info.java declares module dependencies and exposed packages.
• Packages are the unit of export, not individual classes.
• Public class does not mean accessible outside the module unless its package is exported.
• Reflection-heavy frameworks may require opens, not merely exports.
• Named modules, unnamed modules, and automatic modules behave differently.
• Split packages across modules can create problems.

JARs and command-line awareness

Know the purpose, not just syntax:

Practice command-line questions carefully; one misplaced module name or path option can change the answer.