1Z0-829 — Oracle Java SE 17 Developer Quick Reference

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

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

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

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

int score = 2;

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

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

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
        """;

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};

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

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

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();
    }
}

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

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

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

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

    private final int code;

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

    int code() {
        return code;
    }
}

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 (var in = new FileInputStream("a.txt");
     var out = new FileOutputStream("b.txt")) {
    in.transferTo(out);
} // out closes first, then in

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

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);

record Person(String name, int age) {}

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

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

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

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

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
          ));

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));

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

messages_fr_CA
messages_fr
messages

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

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);
}

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

    private String name;
    private transient String sessionToken;
}

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

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

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

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

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;
}

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

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");
        }
    }
}

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;
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Reviewed {
    String value();
    int version() default 1;
}

@Reviewed("exam")
class Service {}