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:
- No project to build: you practise reading short programs
- No frameworks: the exam covers core Java only
- No modules or localisation experience: both are taught from the start
- Nothing to install: labs run in the page or an online sandbox
What helps:
- Working Java: classes, interfaces, loops, collections and exceptions
- Streams and threads at the level of the Java course
Before you start:
- Working Java: you write classes, interfaces, loops, collections and exceptions code
- Streams and threads at the level of the Java course (it covers both)
Take first:
- Hands-on Python: Complete Video Course & Book — Beginner
- Modern Java: Virtual Threads & High-Throughput Services — Intermediate
- Algorithms & Data Structures for Working Engineers — Intermediate
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)
- Handling Date, Time, Text, Numeric and Boolean Values: Use primitives and wrapper classes. Evaluate arithmetic and boolean expressions, using the Math API and by applying precedence rules, type conversions, and casting; Manipulate text, including text blocks, using String and StringBuilder classes; Manipulate date, time, duration, period, instant and time-zone objects, including daylight saving time, using the Date-Time API
- Controlling Program Flow: Create program flow control constructs, including if/else, switch statements and expressions, loops, and break and continue statements
- Using Object-Oriented Concepts in Java: Declare and instantiate Java objects, including nested class objects, and explain the object life cycle, including creation, reassigning references, and garbage collection; Create classes and records, and define and use instance and static fields and methods, constructors, and instance and static initializers; Implement overloaded methods, including var-arg methods; Understand variable scopes, apply encapsulation, and create immutable objects. Use local variable type inference; Implement inheritance, including abstract and sealed types and record classes. Override methods, including those of the Object class. Implement polymorphism and differentiate between object type and reference type. Perform reference type casting, identify object types using the instanceof operator, and pattern matching with the instanceof operator and the switch construct; Create and use interfaces, identify functional interfaces, and utilize private, static, and default interface methods; Create and use enum types with fields, methods, and constructors
- Handling Exceptions: Handle exceptions using try/catch/finally, try-with-resources, and multi-catch blocks, including custom exceptions
- Working with Arrays and Collections: Create arrays, List, Set, Map, and Deque collections, and add, remove, update, retrieve, and sort their elements
- Working with Streams and Lambda Expressions: Use Java object and primitive Streams, including lambda expressions implementing functional interfaces, to create, filter, transform, process, and sort data; Perform decomposition, concatenation, and reduction, and grouping and partitioning on sequential and parallel streams
- Packaging and Deploying Java Code: Define modules and expose module content, including that by reflection, and declare module dependencies, define services, providers, and consumers; Compile Java code, create modular and non-modular jars, runtime images, and implement migration to modules using unnamed and automatic modules
- Managing Concurrent Code Execution: Create both platform and virtual threads. Use both Runnable and Callable objects, manage the thread lifecycle, and use different Executor services and concurrent API to run tasks; Develop thread-safe code, using locking mechanisms and concurrent API; Process Java collections concurrently and utilize parallel streams
- Using Java I/O API: Read and write console and file data using I/O streams; Serialize and de-serialize Java objects; Construct, traverse, create, read, and write Path objects and their properties using the java.nio.file API
- Implementing Localization: Implement localization using locales and resource bundles. Parse and format messages, dates, times, and numbers, including currency and percentage values
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.
- Pro monthly — $29 a month. Every course, lab, handbook, practice exam and certificate
- Pro yearly — $249 a year. Every course, lab, handbook, practice exam and certificate
Course outline
Start Here
- 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.
- 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
- 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.
- 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.
- 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
- 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.
- 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
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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
- 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.
- 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
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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.
- 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
- 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.
- 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
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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
- 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.
- 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
- 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.
- 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.