1Z0-830 — Oracle Java SE 21 Developer Professional Quick Reference

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

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

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

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
}

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

sealed interface Shape permits Circle, Rectangle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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