ExamFinch.com My Study

Study guide

About the Java SE 17 Developer (1Z0-829) Exam

Practice this exam

Oracle Java SE 17 Developer Certified Professional 1Z0-829

Track your progress as you read

Finished sections get a check mark.

1 Introduction: The 1Z0-829 Exam

About the Java SE 17 Developer (1Z0-829) Exam

2 Chapter 1: Java Fundamentals & Language Basics

1.1 Primitive Types, Literals, Wrapper Classes, and Type Promotion/Casting 1.2 Local Variable Type Inference (`var`) Rules and Scoping 1.3 Operators, Precedence, Evaluation Order, and Short-Circuit Evaluation 1.4 Text Blocks, String Immutability, and StringBuilder APIs

3 Chapter 2: Program Flow & Decision Constructs

2.1 Conditional Branching with if/else and the Ternary Operator 2.2 Switch Statements and Switch Expressions 2.3 Iteration Constructs, Loop Control, and Branching Labels

4 Chapter 3: Object-Oriented Design & Class Mechanics

3.1 Class Declarations, Field/Method Signatures, and Access Modifiers 3.2 Constructors, Overloading, Initialization Order, and Garbage Collection 3.3 Inheritance, Method Overriding, Polymorphism, and `super`/`this` 3.4 Abstract Classes, Static Members, and Object Methods (`equals`, `hashCode`, `toString`)

5 Chapter 4: Advanced OOP: Interfaces, Records & Sealed Types

4.1 Interface Architecture: Default, Static, and Private Methods 4.2 Enumerations: Constants, Constructors, Methods, and Custom Bodies 4.3 Records: Canonical/Compact Constructors, Components, and Immutability 4.4 Sealed Classes and Interfaces: `permits`, Hierarchy Constraints, and Modifiers

6 Chapter 5: Pattern Matching & Nested Types

5.1 Pattern Matching for `instanceof` and Flow Scoping Mechanics 5.2 Nested Types: Member Inner, Static Nested, Local, and Anonymous Classes 5.3 Defensive Programming, Immutability Patterns, and Validation

7 Chapter 6: Generics, Collections & Arrays

6.1 Generic Classes, Interfaces, Methods, and Type Erasure 6.2 Bounded Type Parameters and Wildcards (PECS Rule) 6.3 Collections Framework: List, Set, Queue, and Deque APIs 6.4 The Map Interface, Sorting, Comparable, and Comparator 6.5 Arrays: Declaration, Initialization, Multidimensional Arrays, and the Arrays Utility Class

8 Chapter 7: Functional Programming & Lambda Expressions

7.1 Functional Interfaces and Lambda Syntax Rules 7.2 Standard Functional Interfaces in `java.util.function` 7.3 Method References: Static, Bound, Unbound, and Constructor References

9 Chapter 8: The Stream API

8.1 Stream Lifecycle: Creation, Pipeline Architecture, and Lazy Evaluation 8.2 Intermediate Stream Operations: Filtering, Mapping, Sorting, and Slicing 8.3 Terminal Stream Operations: Reduction, Matching, Finding, and Collecting 8.4 Primitive Streams (`IntStream`, `LongStream`, `DoubleStream`) and Numeric Statistics

10 Chapter 9: Advanced Streams & Collectors

9.1 The Optional Class: Safe Null Handling, Transformation, and Chaining 9.2 The Collectors API: Downstream Reductions, Grouping, and Partitioning 9.3 Parallel Streams: Fork/Join Pool, Spliterators, and Concurrency Pitfalls

11 Chapter 10: Exception Handling

10.1 The Java Exception Hierarchy: Checked vs. Unchecked Exceptions and Errors 10.2 Exception Constructs: `try-catch-finally`, Multi-Catch, and Rethrowing 10.3 Try-With-Resources, `AutoCloseable`, Suppressed Exceptions, and Custom Exceptions

12 Chapter 11: Date/Time API & Localization

11.1 Date and Time Core Types: `LocalDate`, `LocalTime`, `LocalDateTime` 11.2 Timestamps, Intervals, and Durations: `Instant`, `Period`, and `Duration` 11.3 Time Zones, Daylight Saving Time (DST) Offsets, and `ZonedDateTime` 11.4 Internationalization and Localization: `Locale`, `ResourceBundle`, and Formatters 11.5 Formatting and Parsing Messages, Numbers, Percentages, and Localized Dates

13 Chapter 12: Java Platform Module System (JPMS)

12.1 Module Architecture, `module-info.java`, and Module Paths 12.2 Module Directives: `requires`, `requires transitive`, `exports`, and Qualified Exports 12.3 Reflection, Deep Encapsulation, `opens`, and Open Modules 12.4 Services in JPMS (`uses`, `provides...with`), Migration Paths, and Tooling (`jlink`, `jdeps`) 12.5 Compiling and Packaging Code: Non-Modular JARs, Modular JARs, and Migration Strategies

14 Chapter 13: Concurrency & Multithreading

13.1 Thread Fundamentals, `Runnable`, `Callable`, and Thread Lifecycle 13.2 Memory Visibility, `volatile`, Intrinsic Locks, and Synchronization 13.3 The Concurrency Framework: `ExecutorService`, Thread Pools, and `Future` 13.4 Concurrent Collections, Atomic Variables, Explicit Locks, and `CompletableFuture`

15 Chapter 14: Java I/O and NIO.2

14.1 Classical I/O: Byte and Character Streams, Readers, Writers, and Buffering 14.2 Object Serialization, `Serializable`, `transient`, and `serialVersionUID` 14.3 NIO.2 Architecture: `Path`, `Paths`, and Basic `Files` Operations 14.4 Advanced NIO.2: Directory Walking, Streams (`Files.lines`, `walk`), and `WatchService`

16 Chapter 15: Accessing Databases with JDBC

15.1 JDBC Architecture, Drivers, `DriverManager`, and `DataSource` Connections 15.2 SQL Execution: `Statement`, `PreparedStatement`, and `CallableStatement` 15.3 `ResultSet` Navigation, Data Types, and Transaction Management (Commit, Rollback, Savepoints)

17 Chapter 16: Annotations & the Java Logging API

16.1 Standard Annotations: @Override, @FunctionalInterface, @Deprecated, @SuppressWarnings, and @SafeVarargs 16.2 Java Logging API Basics: Logger, Levels, Handlers, and Configuration

About the Java SE 17 Developer (1Z0-829) Exam

Key Takeaways Explain This Topic AI

Oracle's 1Z0-829 exam has 50 multiple-choice questions, a 90-minute time limit, and a 68% passing score (Oracle MyLearn exam page).

Oracle has announced that the 1Z0-829 exam retires on February 28, 2027, so candidates should schedule it before that date.

An Oracle exam attempt is valued at US$245, and Oracle delivers English exams itself through online-proctored sessions booked in MyLearn.

The blueprint has 11 official topic areas with no published weights, plus expected knowledge of logging, standard annotations, and generics with wildcards.

Oracle's question assumptions tell candidates to treat missing imports, file names, and wrapped lines as non-issues unless the question says otherwise.

Last updated: October 2026

About the Java SE 17 Developer (1Z0-829) Exam

Quick Answer: Oracle's Java SE 17 Developer exam (1Z0-829) has 50 multiple-choice questions , a 90-minute time limit, and a 68% passing score. Passing it earns the Oracle Certified Professional: Java SE 17 Developer credential. Oracle delivers English exams itself through an online-proctored session booked in Oracle MyLearn , and an exam attempt is valued at US$245 . Oracle has announced that this exam retires on February 28, 2027 , so plan to sit it before that date.

This guide teaches the 11 official topic areas of 1Z0-829 plus the three extra skills Oracle says candidates are "also expected" to have. Every chapter targets Java SE 17 standard features only : preview features in Java 17 (such as pattern matching for switch ) and APIs added after Java 17 (such as Locale.of ) are flagged where older or newer material could mislead you.

Exam Facts at a Glance

  • Detail 1Z0-829 value Source
  • Credential earned Oracle Certified Professional: Java SE 17 Developer Oracle MyLearn exam page
  • Number of questions 50 Oracle MyLearn exam page
  • Question format Multiple choice (including choose-all-that-apply items) Oracle MyLearn exam page
  • Duration 90 minutes Oracle MyLearn exam page
  • Passing score 68% Oracle MyLearn exam page
  • Exam attempt price US$245 per attempt (no free retake) Oracle MyLearn certification FAQ
  • Delivery Online proctored, booked and taken through Oracle MyLearn Oracle MyLearn certification FAQ
  • Retirement February 28, 2027 Oracle MyLearn exam page
  • Topic weights Not published Oracle MyLearn exam page

At 90 minutes for 50 questions you have about 1 minute 48 seconds per question . Many questions show 15 to 30 lines of code and ask for the output or for the line that fails to compile, so the real skill is tracing code quickly and accurately.

Delivery and Policy Details

Oracle delivers the exam directly. Since September 1, 2022, Oracle has delivered its certification exams itself; Pearson VUE continues to deliver only the Chinese and Japanese language versions of the Oracle Database, Java, and MySQL exams.

Online proctoring. You check in through MyLearn with a supported browser (Google Chrome or Microsoft Edge) and complete a system readiness check first.

No pen and paper. Oracle's FAQ states that pen and paper are not allowed; use the digital whiteboard and calculator in the exam control panel to trace variables.

Rescheduling. Reschedule or cancel at least 24 hours before the appointment, or you may lose the attempt. A missed appointment is recorded as a "No Show" and counts as an attempt.

Retakes. Oracle's Certification Program Guidelines allow you to schedule a retake of a failed exam using a new exam attempt, and you may not retake an exam you have passed. The guidelines page does not state a specific waiting period, so check the scheduling screen in MyLearn.

Validity. Oracle's recertification policy lists expiry periods for Oracle Cloud Infrastructure (24 months), Oracle Cloud Applications (18 months), and certain Database credentials; Java SE credentials are not on that list.

The 11 Official Topic Areas and Where This Guide Covers Them

Official topic area What Oracle lists Guide chapters

Handling date, time, text, numeric and boolean values Primitives, wrappers, the Math API, parentheses, promotion, casting; String , StringBuilder , text blocks; date, time, duration, period, instant, and time-zone objects 1, 11

Controlling program flow if / else , switch statements and expressions, loops, break , continue 2

Utilizing the Java object-oriented approach Objects and nested classes, object life cycle and garbage collection, classes and records, overloading and varargs, scope, var , encapsulation and immutability, inheritance including abstract and sealed classes, overriding (including Object methods), polymorphism, casting, instanceof and pattern matching, interfaces, functional interfaces, enums 3, 4, 5

  • Handling exceptions try / catch / finally , try-with-resources, multi-catch, custom exceptions 10
  • Working with arrays and collections Arrays, List , Set , Map , Deque ; add, remove, update, retrieve, sort 6

Working with streams and lambda expressions Object and primitive streams with lambdas; supply, filter, map, consume, sort; decomposition, concatenation, reduction, grouping, partitioning; sequential and parallel streams 7, 8, 9

Packaging and deploying Java code and using the Java Platform Module System Modules and dependencies, exposing content including for reflection, services; compiling, modular and non-modular JARs, runtime images, migration with unnamed and automatic modules 12

Managing concurrent code execution Runnable , Callable , thread life cycle, executor services; thread-safe code and locking; processing collections concurrently, including parallel streams 13, 9

Using the Java I/O API Console and file data with I/O streams; serialization; Path objects and the java.nio.file API 14

Accessing databases using JDBC Connections; basic, prepared, and callable statements; query results; transactions 15

Implementing localization Locales, resource bundles, parsing and formatting messages, dates, times, numbers, currency and percentages 11

Oracle also states that candidates are expected to understand the basics of the Java Logging API , use annotations such as @Override , @FunctionalInterface , @Deprecated , @SuppressWarnings , and @SafeVarargs , and use generics, including wildcards . Chapter 16 covers annotations and logging, and Chapter 6 covers generics.

How to Read Exam Code: Oracle's Stated Assumptions

Oracle publishes rules for interpreting the code in questions. Apply them before you hunt for compile errors:

Missing package and import statements: if the sample code has none and the question does not mention them, assume all code is in the same package or that the needed imports exist.

No file or directory names: assume either that all classes are in one file or that each class is in its own file in one directory, whichever lets the code compile and run.

Unintended line breaks: a line that looks wrapped (for example, a broken String literal) is one line, not a compile error.

Code fragments: assume all supporting code exists and the environment supports compiling and running the fragment.

Descriptive comments: take comments such as "setters and getters go here" at face value; assume that code exists and works.

These rules mean a missing import java.util.*; is never the intended answer, but a missing throws clause, a wrong modifier, or an unreachable statement often is.

Study Strategy for 1Z0-829

Trace, then predict. For every code question decide first whether it compiles, then whether it throws at runtime, and only then compute the output.

Learn the Java 17 boundary. Records (Java 16), sealed classes (Java 17), pattern matching for instanceof (Java 16), text blocks (Java 15), and switch expressions (Java 14) are standard in Java 17. Pattern matching for switch , record patterns, virtual threads, and sequenced collections are not.

Practice the API details. Most traps are exact return types ( Math.round returns long ), exclusive end indexes ( substring ), and checked versus unchecked exceptions.

Use the practice questions. Pair each chapter with the free 1Z0-829 practice questions and re-read the sections where you miss items.