1Z0-830 course and practice exam: Oracle Java SE 21 Developer Professional

This 1Z0-830 course has 39 video lessons and 141 graded labs, and its 1Z0-830 practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.

Java 21 language, APIs, modules, concurrency, I/O and localization

Prepares you for Oracle's 1Z0-830 exam: values and text, program flow, object-oriented Java, exceptions, arrays and collections, streams and lambdas, packaging and deploying, concurrency, I/O and localization.

Advanced · 3 hours · 39 lessons · 141 labs

1Z0-830 exam guide

The 1Z0-830 exam (Oracle Certified Professional: Java SE 21 Developer, by Oracle): 120 minutes; questions: 50; pass mark: 68%.

  • Format: Multiple-choice and select-all-that-apply
  • Duration: 120 minutes
  • Questions: 50
  • Pass mark: 68%
  • Valid for: Lifetime (no expiration for OCP credentials)
  • Delivery: Online, proctored (Pearson VUE) or at a testing center
  • Prerequisites: No formal prerequisites; practical Java SE development experience recommended

Exam domains

  • Handling Date, Time, Text, Numeric and Boolean Values
  • Controlling Program Flow
  • Using Object-Oriented Concepts in Java
  • Handling Exceptions
  • Working with Arrays and Collections
  • Working with Streams and Lambda Expressions
  • Packaging and Deploying Java Code
  • Managing Concurrent Code Execution
  • Using Java I/O API
  • Implementing Localization

Oracle does not publish domain weights for this exam.

A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

10 1Z0-830 sample questions with answers: free to read, no account needed.

Common questions

How long is the 1Z0-830 exam?

The 1Z0-830 exam lasts 120 minutes.

How many questions are on the 1Z0-830 exam?

50.

What is the 1Z0-830 passing score?

The pass mark is 68%.

Is there a free 1Z0-830 practice test?

Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

Source: Oracle exam page: 1Z0-830 (down for maintenance on 2026-10-03; not re-verified) (Oracle), checked 2026-10-09.

Who it is for

Advanced level.

For Java developers preparing for Oracle's Java SE 21 Developer exam (1Z0-830). It assumes you already write Java and trains you to read code the way the compiler does.

What you don't need yet:

What helps:

Before you start:

Take first:

Learning paths:

Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.

What this exam proves, and what it doesn't

Java SE 21 Developer is a multiple-choice and select-all exam: passing shows you can read Java code the way the compiler does. It doesn't show you can build real applications; our graded labs have you read and run short programs.

Exam objectives this course teaches

Oracle Certified Professional: Java SE 21 Developer (1Z0-830)

Labs

141 labs, 141 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.

What is free

Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.

Course outline

Start Here

  1. Fifty Items, Five Traps (2 labs): You can predict the output of five classic Java traps, spot three lines the compiler rejects, and say what the 1Z0-830 exam covers and how this course trains for it.
  2. A Hundred And Twenty Minutes, Fifty Items (2 labs): You can pace fifty items in a hundred and twenty minutes with checkpoints, scan an item for compile errors before tracing it, and handle choose-two items.

Numbers, Text And Time

  1. Promotion, Wrappers And The Math API (5 labs): You can predict numeric promotion, compound assignment, overflow, wrapper equality and the Math API's edge cases, and spot the lossy conversions the compiler rejects.
  2. Strings, StringBuilder And Text Blocks (5 labs): You can predict String pool identity, String and StringBuilder method results, and the exact content of a text block, including its indentation, escapes and final newline.
  3. Dates, Times And Daylight Saving (4 labs): You can choose between LocalDate, LocalTime, LocalDateTime, ZonedDateTime and Instant, tell Period from Duration, and predict what happens to a zoned time in a daylight saving gap or overlap.

Program Flow

  1. Switch, Loops And Labels (4 labs): You can predict switch statements with fall-through, write exhaustive switch expressions with yield, and trace for, while, do-while and labelled break and continue.
  2. Sprint: Values And Flow (4 labs): You can answer eight exam-style items on numbers, text, dates and program flow at exam pace, and turn each miss into the rule you need to review.

Object-Oriented Java

  1. Objects, Nested Classes And Garbage Collection (3 labs): You can count the objects eligible for garbage collection at a given line, create static nested, inner, local and anonymous class objects, and spot the nested-class code that does not compile.
  2. Classes, Records And Initialisation Order (4 labs): You can predict the order of static and instance initialisers and constructors across a class hierarchy, apply the rules for this() and super(), and write records with compact and extra constructors.
  3. Overloading And Varargs (3 labs): You can predict which overload the compiler picks through its three phases (widening, then boxing, then varargs), recognise illegal and ambiguous overloads, and call varargs methods with zero, many or array arguments.
  4. Scope, var And Immutable Objects (4 labs): You can work out where a variable is in scope and whether it has a value, use var only where it is allowed, and write an immutable class or record that does not leak its state.
  5. Inheritance, Overriding And Object's Methods (4 labs): You can tell what the reference type decides from what the object type decides, apply the overriding rules for access, return type and exceptions, use abstract classes, and override equals and hashCode correctly.
  6. Sealed Types, Casts And Pattern Matching (4 labs): You can tell a cast that fails at compile time from one that throws ClassCastException, declare sealed hierarchies, and write instanceof patterns, record patterns and pattern switches that are exhaustive and correctly ordered.
  7. Interfaces: Default, Static And Private Methods (4 labs): You can apply the implicit modifiers of interface members, resolve default method conflicts, call static and private interface methods correctly, and identify functional interfaces.
  8. Enums With Fields, Constructors And Methods (4 labs): You can use an enum's built-in methods, give it fields, constructors and constant-specific bodies, switch over it exhaustively, and predict when its constructor runs.
  9. Sprint: Object-Oriented Java (4 labs): You can answer eight exam-style items across initialisation order, overloading, overriding, patterns, interfaces, enums, records and sealed types at exam pace.

Exceptions

  1. Checked, Unchecked, Catch And Finally (3 labs): You can classify checked and unchecked exceptions, write custom exceptions, order catch blocks and multi-catch legally, and predict what try, catch and finally print and return.
  2. Try-With-Resources And Suppressed Exceptions (3 labs): You can predict the order in which try-with-resources opens and closes resources and runs catch and finally, read suppressed exceptions, and spot illegal resource declarations.

Arrays And Collections

  1. Arrays: Declare, Sort, Search, Compare (4 labs): You can read every legal array declaration, predict defaults, lengths and copies, and use Arrays.sort, binarySearch, equals, compare, mismatch and asList with their exam edge cases.
  2. Generics, Bounds And Wildcards (4 labs): You can write generic classes and methods with bounds, explain type erasure, choose between extends and super wildcards, and spot the generic code the compiler rejects.
  3. Lists, Sets, Maps, Deques And Sequenced Collections (4 labs): You can tell mutable, unmodifiable and fixed-size collections apart, predict List, Set, Map and Deque method results, and use Java 21's sequenced collection methods and comparator chains.
  4. Sprint: Exceptions, Arrays And Collections (4 labs): You can answer eight exam-style items on exceptions, try-with-resources, arrays, generics and collections at exam pace, and log each miss as a rule.

Streams And Lambdas

  1. Lambdas, Functional Interfaces And Method References (4 labs): You can write every legal lambda form, pick the right java.util.function interface, combine them with default methods, and use all four kinds of method reference.
  2. Stream Pipelines, Primitive Streams And Optional (4 labs): You can predict when a lazy stream pipeline runs and in what order, use the common intermediate and terminal operations, work with primitive streams and their statistics, and handle Optional without surprises.
  3. Reduction, Grouping And Partitioning (4 labs): You can reduce streams with each form of reduce, build maps with groupingBy, partitioningBy and toMap, combine collectors with downstream collectors and teeing, and avoid the identity trap in parallel reduction.
  4. Sprint: Lambdas And Streams (4 labs): You can answer eight exam-style items on lambdas, method references, stream laziness, Optional, primitive streams and collectors at exam pace.

Packaging And Deploying

  1. Modules: Exports, Opens And Services (4 labs): You can read and write module descriptors, tell exports from opens and named from automatic and unnamed modules, and predict the errors when access is missing.
  2. Jars, Automatic Modules And Runtime Images (3 labs): You can compile and package class path and modular jars, predict how java -jar and the module path find classes, name automatic modules, and describe what jdeps and jlink do.

Concurrency

  1. Platform And Virtual Threads, Runnable And Callable (4 labs): You can start platform and virtual threads, follow a thread through its states, submit Runnable and Callable tasks to executors, and read their futures and failures.
  2. Thread Safety: Locks And Atomics (3 labs): You can explain lost updates, make shared state safe with synchronized, atomics and locks, coordinate threads with a latch, and recognise deadlock, livelock and starvation.
  3. Concurrent Collections And Parallel Streams (3 labs): You can predict fail-fast and snapshot iteration, share maps and lists safely between threads, and say which parallel stream results keep their order and which reductions stay correct.
  4. Sprint: Modules And Concurrency (4 labs): You can answer eight exam-style items on modules, thread states, futures, atomics, concurrent collections and parallel streams at exam pace.

Input And Output

  1. Console And File I/O With Streams (3 labs): You can choose between byte and character streams, wrap and bridge them, read and write files and console input, and predict what is lost when a stream is not flushed or closed.
  2. Serialization: What Survives The Trip (3 labs): You can serialize and deserialize objects and records, predict which fields and constructors survive the round trip, and recognise the errors that stop it.
  3. Paths And Files With NIO.2 (3 labs): You can build, take apart, normalize, resolve and relativize paths, and create, read, write, walk, copy and delete files with the Files class, predicting each result and exception.

Localization

  1. Locales, Resource Bundles And Formatting (3 labs): You can predict which resource bundle answers a lookup, and format and parse numbers, currency, percentages, dates and messages for a locale.
  2. Sprint: I/O And Localization (4 labs): You can answer eight exam-style items on paths, readers, serialization, the Files class, resource bundles and number parsing at exam pace.

Mock And Review

  1. Mock Exam: Sit It, Score It (3 labs): You can sit a timed mock under exam conditions, score it by topic, find the marks you lose most, and answer mixed items from every exam topic.
  2. Final Review And Exam Day (3 labs): You can plan the last week before the exam, answer one item from every exam topic, and walk into the exam with a pacing plan and a scan for compile errors.