This plan is built for code-reading precision, not passive review. The emphasis weights below come from the local IT Mastery Oracle 1Z0-830 curriculum bundle used to structure this guide. Oracle’s public storefront does not expose a simple official weighting table, so use these weights as a planning signal, not as an Oracle-published percentage chart.
Pick your pace
| Weekly time |
Recommended timeline |
Best fit |
18-22 hours |
4 weeks |
you already write Java often and mainly need exam precision |
10-14 hours |
8 weeks |
you know most core APIs but need steady rule cleanup |
6-9 hours |
12 weeks |
you are rebuilding breadth while keeping a work schedule |
How to use the plan
- pair every reading block with short snippets so you can separate compile-time failure from runtime behavior
- keep one mistake log with four labels only:
type rule, API contract, mutability/order, and concurrency/visibility
- send repeat misses to the local cheat sheet and glossary instead of rereading whole chapters blindly
- finish each week with mixed code-reading, not only topic-isolated drills
Weighted study order
| Weight |
Topic |
Why it matters |
16 |
Lambdas, Streams and Collectors |
biggest single reasoning lane and the easiest place to lose points on signatures and terminal behavior |
9 |
OOP and Object Model |
constructors, records, nested types, and object contracts create many subtle code questions |
9 |
Inheritance and Polymorphism |
overriding, sealed types, casts, and pattern matching drive many elimination rules |
8 |
Types, Operators and Text |
compile-time math and string behavior shape the rest of the exam |
8 |
Arrays and Collections |
mutability, order, and API return types produce common traps |
8 |
Concurrency |
virtual threads, executors, and shared-state rules now matter directly |
8 |
I/O, NIO.2 and Serialization |
file APIs and resource handling mix syntax with contract questions |
7 |
Exceptions |
flow control and try-with-resources still create easy misses |
6 |
Control Flow |
switch expressions and pattern-aware flow matter more in modern Java |
6 |
Generics |
bounds and wildcards are high-yield whenever collections or streams appear |
6 |
Modules and Packaging |
lower-volume, but the exam can punish vague JPMS thinking |
5 |
Interfaces and Enums |
default methods and enum behavior often appear inside larger stems |
5 |
Localization |
smaller lane, but formatting and bundles are rule-heavy |
4 |
Date/Time API |
lighter weight, but time-zone and immutability mistakes are common |
4 |
Annotations and Logging |
lower weight, good late-stage cleanup area |
4-week intensive plan
| Week |
Focus |
Output |
| 1 |
Types, control flow, OOP, inheritance |
daily compile-vs-runtime drills |
| 2 |
Collections, generics, streams |
mixed pipeline and mutability drills |
| 3 |
Exceptions, modules, I/O, localization |
API-contract cleanup |
| 4 |
Concurrency, review, and readiness |
readiness decision |
8-week balanced plan
| Week |
Focus |
Output |
| 1 |
Types, operators, strings, var |
fundamentals drills |
| 2 |
Date/time and control flow |
modern syntax drills |
| 3 |
OOP, records, nested types |
object-model drills |
| 4 |
Inheritance, sealed types, interfaces, enums |
polymorphism drills |
| 5 |
Exceptions and collections |
rule cleanup |
| 6 |
Generics plus streams |
signature and pipeline drills |
| 7 |
Modules, I/O, localization, annotations/logging |
API review |
| 8 |
Concurrency and final mixed sets |
readiness check |
12-week part-time plan
| Weeks |
Focus |
Output |
| 1-2 |
Types, strings, operators, control flow |
fundamentals drills |
| 3-4 |
OOP, records, inheritance, interfaces |
model-building drills |
| 5-6 |
Collections and generics |
signature drills |
| 7-8 |
Streams and collectors |
mixed reduction drills |
| 9-10 |
Exceptions, modules, I/O |
contract drills |
| 11 |
Localization, annotations, logging |
cleanup |
| 12 |
Concurrency and full mixed review |
readiness decision |
Daily drill loop
- Read one lesson section slowly.
- Write or run
3-5 tiny snippets that test the exact rule.
- Predict
compile error, output, or exception before running.
- Add only surprising misses to your mistake log.
- Revisit those misses
48 hours later without looking at the answer first.
Booking signal
You are close when:
- you can identify compile failure before arguing about output
- you stop guessing on wildcard, stream, and overload questions
- you can explain why the wrong choice fails using a concrete Java rule
- your misses cluster in a few narrow lanes instead of the full blueprint
Final 72 hours
- reread the cheat sheet for overload order, generics, streams, exceptions, and concurrency
- do mixed code-reading, not fresh topic learning
- keep the resources page open for JLS and Java 21 API confirmation
- use the faq to settle last-week triage decisions