Free Oracle 1Z0-829 Exam Actual Questions & Explanations

Last updated on: Jun 13, 2026
Author: Kimberlie Duenas (Oracle Certified Associate Java Programmer & Exam Strategy Consultant)

The Oracle 1Z0-829 exam validates your ability to design, develop, and deploy Java applications using Java SE 17. This certification, part of the Oracle Java path, is intended for developers who have hands-on experience building Java applications and want to demonstrate their proficiency as a Java SE 17 Developer. This landing page provides a clear roadmap of exam topics, question formats, and practical preparation strategies to help you study efficiently and build confidence before test day.

1Z0-829 Exam Syllabus & Core Topics

Use this topic map to guide your study for Oracle 1Z0-829 (Java SE 17 Developer) within the Oracle Java path.

  • Handling Date, Time, Text, Numeric and Boolean Values: Demonstrate proficiency with Java's date/time API (LocalDate, LocalTime, ZonedDateTime), string manipulation, numeric operations, and boolean logic in real-world scenarios.
  • Controlling Program Flow: Write conditional statements (if/else, switch), loops (for, while, do-while), and control flow structures that respond to application logic and user input.
  • Utilizing Java Object-Oriented Approach: Design and implement classes, inheritance hierarchies, interfaces, enums, and polymorphism to build maintainable, scalable applications.
  • Handling Exceptions: Catch, throw, and manage checked and unchecked exceptions; implement try-catch-finally blocks and custom exception classes to ensure robust error handling.
  • Working with Arrays and Collections: Create and manipulate arrays, lists, sets, maps, and queues; choose appropriate collection types for different use cases and iterate efficiently.
  • Working with Streams and Lambda Expressions: Use functional programming constructs to filter, map, reduce, and process collections; write concise, readable code with lambda syntax and method references.
  • Packaging and Deploying Java Code and Use the Java Platform Module System: Organize code into packages and modules, configure module dependencies, and prepare applications for production deployment.
  • Managing Concurrent Code Execution: Create and synchronize threads, use thread pools and executors, handle race conditions, and implement thread-safe patterns in multi-threaded applications.
  • Using Java I/O API: Read and write files, streams, and character data; handle file operations, buffering, and serialization for reliable data persistence.
  • Accessing Databases Using JDBC: Connect to databases, execute SQL queries and updates, manage result sets, and implement connection pooling for efficient database access.
  • Implementing Localization: Support multiple languages and regions using ResourceBundles, Locale objects, and formatting APIs to create globally accessible applications.

Question Formats & What They Test

The 1Z0-829 exam uses a mix of question types to assess both theoretical knowledge and practical problem-solving ability. Questions progress in difficulty and reflect real-world development scenarios.

  • Multiple Choice: Test understanding of core definitions, API behavior, syntax rules, and key terminology across all 11 topic areas.
  • Scenario-Based Items: Present realistic code snippets or application requirements; ask you to identify the best design choice, predict output, or diagnose bugs in logic or exception handling.
  • Code Analysis: Evaluate code segments for correctness, performance, thread safety, or module visibility; determine what will compile, run, or throw exceptions.

Questions build in complexity, requiring you to connect concepts (e.g., streams with exception handling, concurrency with I/O) and apply knowledge to practical development decisions.

Preparation Guidance

An efficient study plan maps each topic to weekly study blocks, pairs concept review with hands-on coding, and includes regular practice tests to identify gaps. Aim for 4-6 weeks of consistent preparation if you have prior Java experience, or 8-10 weeks if you are building foundational knowledge.

  • Allocate one week per topic cluster: start with fundamentals (data types, control flow, OOP), then move to advanced topics (streams, concurrency, modules, JDBC).
  • Write code daily: create small programs that exercise each topic (e.g., build a date calculator, implement a thread-safe cache, query a test database).
  • Practice with question sets after each topic; review explanations for both correct and incorrect answers to understand the reasoning.
  • Connect concepts across workflows: for example, see how exceptions flow through stream operations, or how modules affect JDBC driver loading.
  • Take a full-length timed mock test 1-2 weeks before your exam date to build pacing, identify weak areas, and reduce test anxiety.

Explore other Oracle certifications: view all Oracle exams.

Get the PDF & Practice Test

Strengthen your preparation with up‑to‑date resources from validexamdumps.com. These materials align to 1Z0-829 and cover practical scenarios with clear explanations.

  • Q&A PDF with explanations: topic-mapped questions that clarify why correct options are right and others aren't.
  • Practice Test: realistic items, timed/untimed modes, progress tracking, and detailed review of each answer.
  • Focused coverage: aligned to handling date/time/text/numeric/boolean values, controlling program flow, object-oriented design, exception handling, arrays and collections, streams and lambda expressions, packaging and modules, concurrent execution, I/O, JDBC, and localization, so you study what matters most.
  • Regular updates: content refreshes that reflect syllabus and product changes.

Visit the exam page to download the PDF, Online Practice Test, or get a Bundle Discount offer for both formats: Java SE 17 Developer.

Frequently Asked Questions

Which topics typically carry the most weight on the 1Z0-829 exam?

Object-oriented programming, exception handling, and streams/lambda expressions are heavily tested because they form the foundation of modern Java development. Collections and I/O also appear frequently. Focus your study time on these areas first, then move to specialized topics like JDBC and localization.

How do the 11 exam topics connect in real project workflows?

In a typical application, you handle data types and control flow to process user input, apply OOP design to organize code into classes and modules, use streams to transform collections efficiently, catch exceptions at each layer, write to files or databases using I/O and JDBC, and support multiple languages via localization. Concurrency and module systems ensure the application scales and deploys safely in production.

What hands-on experience helps most, and which labs should I prioritize?

Build a small multi-threaded application that reads from a file, processes data with streams, writes to a database via JDBC, and handles exceptions at each step. This single project exercises 6+ topics simultaneously. Also practice date/time formatting, module configuration, and creating custom exception classes. Hands-on coding is more valuable than passive reading.

What are the most common mistakes that cost points on this exam?

Misunderstanding stream terminal vs. intermediate operations, confusing checked and unchecked exceptions, overlooking thread safety in concurrent code, and misapplying module visibility rules are frequent pitfalls. Additionally, many candidates rush through code analysis questions without tracing execution carefully. Read each question twice and trace code step-by-step before selecting an answer.

What is an effective pacing and review strategy for the final week before the exam?

In your final week, take one full-length practice test every 2-3 days; do not introduce new topics. Instead, review weak areas using your Q&A PDF and re-code small examples from those sections. On the day before the exam, do a light review of key APIs (Stream, LocalDateTime, SQLException) and get adequate sleep. Trust your preparation and focus on reading questions carefully during the actual exam.

Get All 50 Questions
Question No. 1

Daylight Saving Time (DST) is the practice of advancing clocks at the start of spring by one hour and

adjusting them backward by one hour in autumn.

Considering that in 2021, DST in Chicago (Illinois) ended on November 7th at 2 AM, and given the fragment:

What is the output?

Show Answer Hide Answer
Correct Answer: A

The answer is A because the code fragment uses the ZoneId and ZonedDateTime classes to create two date-time objects with the same local date-time but different zone offsets. The ZoneId class represents a time-zone ID, such as America/Chicago, and the ZonedDateTime class represents a date-time with a time-zone in the ISO-8601 calendar system. The code fragment creates two ZonedDateTime objects with the same local date-time of 2021-11-07T01:30, but different zone IDs of America/Chicago and UTC. The code fragment then compares the two objects using the equals and isEqual methods.

The equals method compares the state of two objects for equality. In this case, it compares the local date-time, zone offset, and zone ID of the two ZonedDateTime objects. Since the zone offsets and zone IDs are different, the equals method returns false.

The isEqual method compares the instant of two temporal objects for equality. In this case, it compares the instant of the two ZonedDateTime objects, which is derived from the local date-time and zone offset. Since DST in Chicago ended on November 7th at 2 AM in 2021, the local date-time of 2021-11-07T01:30 in America/Chicago corresponds to the same instant as 2021-11-07T06:30 in UTC. Therefore, the isEqual method returns true.

Hence, the output is true false.Reference:

Oracle Certified Professional: Java SE 17 Developer

Java SE 17 Developer

OCP Oracle Certified Professional Java SE 17 Developer Study Guide

ZoneId (Java Platform SE 8 )

ZonedDateTime (Java Platform SE 8 )

Time Zone & Clock Changes in Chicago, Illinois, USA

Daylight Saving Time Changes 2023 in Chicago, USA


Question No. 2

Given the code fragment:

What is the result?

Show Answer Hide Answer
Correct Answer: D

The code fragment is comparing the values of a, b, and c using the < and > operators. The first comparison, d, is checking if a is less than b and greater than c. Since a is equal to 2, b is equal to -2, and c is equal to -4, this comparison will evaluate to true. The second comparison, e, is checking if a is greater than b and a is greater than c. Since a is equal to 2, b is equal to -2, and c is equal to -4, this comparison will evaluate to false. Therefore, the result will be true 1 false 2.Reference:Operators (The Java Tutorials > Learning the Java Language - Oracle


Question No. 3

Which statement is true?

Show Answer Hide Answer
Correct Answer: A

The tryLock () method of the Lock interface is a non-blocking attempt to acquire a lock. It returns true if the lock is available and acquired by the current thread, and false otherwise. It does not wait for the lock to be released by another thread. This is different from the lock () method, which blocks the current thread until the lock is acquired, and does not return any value.Reference: https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/locks/Lock.html#tryLock(),3,4,5


Question No. 4

Given the code fragment:

Which code fragment invokes all callable objects in the workers set?

A)

B)

C)

D)

Show Answer Hide Answer
Correct Answer: C

The code fragment in Option C invokes all callable objects in the workers set by using the ExecutorService's invokeAll() method. This method takes a collection of Callable objects and returns a list of Future objects representing the results of the tasks. The other options are incorrect because they either use the wrong method (invokeAny() or submit()) or have syntax errors (missing parentheses or semicolons).Reference:AbstractExecutorService (Java SE 17 & JDK 17) - Oracle


Question No. 5

Given:

and the code fragment:

Show Answer Hide Answer
Correct Answer: A

The code fragment is using the Stream API to perform a reduction operation on a list of ElectricProduct objects. The reduction operation consists of three parts: an identity value, an accumulator function, and a combiner function. The identity value is the initial value of the result, which is 0.0 in this case. The accumulator function is a BiFunction that takes two arguments: the current result and the current element of the stream, and returns a new result. In this case, the accumulator function is (a,b) -> a + b.getPrice (), which means that it adds the price of each element to the current result. The combiner function is a BinaryOperator that takes two partial results and combines them into one. In this case, the combiner function is (a,b) -> a + b, which means that it adds the two partial results together.

The code fragment then applies a filter operation on the stream, which returns a new stream that contains only the elements that match the given predicate. The predicate is p -> p.getPrice () > 10, which means that it selects only the elements that have a price greater than 10. The code fragment then applies a map operation on the filtered stream, which returns a new stream that contains the results of applying the given function to each element. The function is p -> p.getName (), which means that it returns the name of each element.

The code fragment then calls the collect method on the mapped stream, which performs a mutable reduction operation on the elements of the stream using a Collector. The Collector is Collectors.joining ('',''), which means that it concatenates the elements of the stream into a single String, separated by commas.

The code fragment then prints out the result of the reduction operation and the result of the collect operation, separated by a new line. The result of the reduction operation is 300.00, which is the sum of the prices of all ElectricProduct objects that have a price greater than 10. The result of the collect operation is CellPhone,ToyCar,Motor,Fan, which is the concatenation of the names of all ElectricProduct objects that have a price greater than 10.

Therefore, the output of the code fragment is:

300.00 CellPhone,ToyCar,Motor,Fan


Get All 50 Questions Explore Other Oracle Exams