“"Excellent question coverage and clear explanations."”
Pooja
Software Developer
The 1Z0-829 is 50 multiple-choice questions in 90 minutes, and you need 68% to pass — that’s roughly a minute and 48 seconds per question, which sounds generous until you’re staring at a 15-line code listing and four answer options that all look plausible. Oracle doesn’t test Java the way a tutorial teaches it. Almost every question gives you a working (or almost-working) block of code and asks what it prints, whether it compiles, or which line causes a runtime exception. Straight recall questions (“what does transient mean?”) are rare; reading code under time pressure is the actual skill being tested.
Expect a mix of single-answer and “choose two” or “choose three” questions, which are scored as all-or-nothing — partial credit doesn’t exist. A handful of questions will hinge on something that looks like a typo but isn’t (a missing semicolon, a return type mismatch, an unreachable catch block), and those trip up experienced developers more often than beginners, because experienced developers tend to skim Explore another exam preparation resource with our Certified Experience Cloud Consultant practice test.
Oracle does not publish percentage weightings for this exam, so treat the table below as a map of scope, not a study-time allocator. In practice, Arrays/Collections, Streams/Lambdas, and the OOP domain carry disproportionate weight simply because they touch nearly every code sample on the exam.
Domain | What It Covers |
|---|---|
Handling Date, Time, Text, Numeric and Boolean Values | Primitives, wrapper classes, Math API, casting, String/StringBuilder, text blocks, the Date-Time API |
Controlling Program Flow | if/else, switch statements and expressions, loops, break/continue |
Utilizing Java’s Object-Oriented Approach | Classes, records, constructors, overloading, var-arg methods, inheritance, abstract and sealed classes, polymorphism, instanceof pattern matching, interfaces, enums |
Handling Exceptions | try/catch/finally, try-with-resources, multi-catch, custom exceptions |
Working with Arrays and Collections | Arrays, List, Set, Map, Deque; generics including wildcards |
Working with Streams and Lambda Expressions | Functional interfaces, object and primitive streams, decomposition, reduction, grouping/partitioning |
Packaging and the Java Platform Module System | Modules, dependencies, services, modular/non-modular JARs, migration with unnamed and automatic modules |
Managing Concurrent Code Execution | Runnable/Callable, thread lifecycle, Executor services, locking, parallel streams |
Using the Java I/O API | Console/file I/O streams, object serialization, NIO.2 Path operations |
Accessing Databases Using JDBC | Connections, statements (basic, prepared, callable), result processing, transactions |
Implementing Localization | Locales, resource bundles, formatting dates/numbers/currency |
Candidates are also expected to know the basics of the Java Logging API and common annotations (@Override, @FunctionalInterface, @Deprecated, @SuppressWarnings, @SafeVarargs), even though these aren’t called out as a standalone domain.
Records, sealed classes, and switch expressions get all the attention in study guides because they’re the “new” part of Java 17 — but they’re also the part most self-taught developers already half-know from blog posts. The domains that actually sink people are the ones that feel like plumbing:
The Java Platform Module System is the single biggest blind spot. Most working developers have never written a module-info.java file by hand, because most teams still build unnamed-module applications. The exam expects you to reason about readability, exports, opens-for-reflection, and the difference between automatic and unnamed modules — concepts with almost no -world muscle memory behind them for most candidates.
Concurrency is the second trap, specifically the difference between the various ExecutorService factory methods, what synchronized actually locks versus what a ReentrantLock locks, and how parallel streams interact with shared mutable state. People who’ve used Thread and basic synchronized blocks in production still get these questions wrong because the exam tests edge cases, not everyday usage.
NIO.2 and JDBC round out the underestimated list. Candidates who learned Java recently often have little hands-on JDBC experience since most frameworks abstract it away, and the exact method names on Path, Files, and the JDBC Statement hierarchy are easy to half-remember and hard to guess correctly among four similar-looking options.
Because almost every question is a code-reading exercise, drilling flashcard-style “what is X” questions won’t move your score much. What works is forcing yourself to predict the output or compile status of a snippet before looking at the answer choices — the moment you start pattern-matching against the options instead of reasoning through the code, you’re training the wrong instinct, and the exam’s distractors are specifically built to punish pattern-matching.
Time yourself in blocks, not just on full mock exams. If a single question is taking you past two minutes, that’s a signal you’re uncertain about an underlying rule (generics bounds, checked-exception propagation, a specific Stream terminal operation) rather than just being slow — go fix the rule, don’t just grind more questions on the same gap. Keep a running list of the specific compiler rules that trip you up (effectively-final capture in lambdas, sealed-class permits clauses, try-with-resources closing order) and review that list the morning of the exam instead of re-reading everything.
The most common failure pattern isn’t ignorance of a topic — it’s running out of time because of over-deliberation on early questions, leaving the harder Streams and Collections questions rushed. Mark-and-move is not optional on this exam; Oracle’s interface lets you flag questions for review, and anyone comfortable with the pacing uses that feature on every pass.
A close second is underestimating “choose two” and “choose three” questions. These are worth the same as single-answer questions but require getting every part right, and candidates who spend 70% of their prep time on the flashy Java 17 features often walk in with shakier recall on the lower-glamour domains (I/O, JDBC, localization) that quietly make up a large share of the multi-select questions.
Finally, retaking the exam too soon without changing study method is a common and expensive mistake — Oracle enforces a retake waiting period, and showing up again with the same gaps simply reproduces the same score.
New to Java, or only coursework experience: Budget 3–5 months. Spend the first stretch building actual small programs that use collections, streams, and exception handling rather than just reading about them — this exam punishes people who recognize syntax but haven’t written enough of it to predict behavior under pressure.
1+ years of professional Java experience: 6–10 weeks is , with most of that time going to the domains your day job doesn’t touch — modules, concurrency internals, JDBC, and localization. If your production code runs on Spring Boot, assume your JPMS and raw-JDBC knowledge is close to zero and plan accordingly.
Retaking after a failed attempt: 3–4 weeks, but only if you diagnose why you failed using your score report’s domain breakdown rather than re-studying everything uniformly. A second failure is almost always caused by retaking without changing strategy.
Last updated on Nov, 3 2026