1Z0-829 — Oracle Java SE 17 Developer Study Plan

Last revised: June 29, 2026

A practical study schedule for Oracle Java SE 17 Developer (1Z0-829), with 7-day, 14-day, 30-day, and 60/90-day preparation paths.

Who this study plan is for

This Study Plan is for candidates preparing for Oracle Java SE 17 Developer (1Z0-829). It assumes you are preparing for the real Oracle exam and need to turn available study time into a practical schedule.

The exam rewards precise Java knowledge. You should practice reading code, predicting compiler output, identifying runtime behavior, and choosing the best Java SE 17 API or language feature for a scenario. Do not rely only on passive reading.

Use this page to choose a timeline, set a daily rhythm, review missed questions, and decide when you are ready for timed mock exams.

Which plan should you use?

Your situation	Recommended plan	Best use
Exam is in 7 days and you have already studied most topics	7-day final review	Consolidate weak areas, take timed mocks, stop adding new material
Exam is in 2 weeks and you know Java but have gaps	14-day focused plan	Intensive domain review plus repeated question practice
Exam is about 1 month away	30-day balanced plan	Full topic pass, hands-on code review, timed mock progression
Exam is 2 to 3 months away or you are new to modern Java certification style	60/90-day full path	Build depth, practice steadily, reduce cram risk

Minimum weekly time targets

Plan	Suggested study time	Notes
7-day plan	2 to 4 hours per day	Only works if you have already covered the exam content
14-day plan	1.5 to 3 hours per day	Best for experienced Java developers with certification gaps
30-day plan	60 to 120 minutes per day, 5 to 6 days per week	Balanced path for most working professionals
60/90-day plan	45 to 90 minutes per day, 4 to 6 days per week	Best for steady retention and hands-on practice

Core 1Z0-829 study areas

Use these areas to structure your review. Do not treat them as official weighting. Treat them as practical study buckets.

Study area	What to practice
Java language fundamentals	Variables, scope, primitives, wrappers, strings, numeric promotion, operators, control flow
Object-oriented Java	Classes, inheritance, interfaces, abstract classes, overriding, overloading, access modifiers, polymorphism
Java 17 language features	Records, sealed classes, pattern matching for `instanceof`, switch expressions where relevant
Exceptions and resource handling	Checked vs unchecked exceptions, try-catch-finally, try-with-resources, suppression behavior
Arrays, generics, and collections	Array behavior, `List`, `Set`, `Map`, sorting, comparison, generics, wildcards
Lambdas and streams	Functional interfaces, method references, stream pipelines, collectors, optional results, primitive streams
Date, time, text, and localization	`java.time`, formatting, parsing, locales, resource bundles
Java I/O and NIO.2	Paths, files, streams, readers/writers, serialization concepts where applicable
Concurrency	Threads, executors, synchronization, concurrent collections, atomicity, parallel stream concerns
Modules and deployment	Module declarations, exports, requires, classpath vs module path, packaging basics
JDBC	Connections, statements, result sets, transactions, exception handling, resource cleanup
Exam-style code reading	Predict compile errors, output order, exception flow, type inference, overload selection

Daily practice rhythm

A strong 1Z0-829 session should include code reading, hands-on verification, and missed-question review.

60-minute study block

Time	Activity	Output
0-10 min	Review yesterday’s missed questions	Update error log
10-30 min	Study one focused topic	Notes on rules and edge cases
30-50 min	Do targeted practice questions or code predictions	Mark confidence level
50-60 min	Compile small examples or review explanations	Add 2 to 5 rules to memory list

90-minute study block

Time	Activity	Output
0-15 min	Error-log review	Repeat previously missed concepts
15-40 min	Topic review	One Java feature or API area
40-70 min	Practice set	15 to 25 focused questions
70-85 min	Hands-on verification	Confirm behavior with `javac`, `java`, or JShell
85-90 min	Plan next session	Choose next weak area

2-hour study block

Time	Activity
0-20 min	Review missed questions and flashcards
20-50 min	Study one exam area deeply
50-85 min	Timed topic drill
85-110 min	Code verification and explanation review
110-120 min	Update readiness tracker

How to practice Java code effectively

For Oracle Java SE 17 Developer (1Z0-829), you need to know what Java code does, not just what it is supposed to do.

Use a small scratch workspace and compile examples frequently.

javac Example.java
java Example

For module practice, create small examples instead of only reading about modules.

javac -d out --module-source-path src $(find src -name "*.java")
java --module-path out -m com.example/com.example.Main

When reviewing a question, ask these in order:

Does the code compile?
If not, which line fails and why?
If it compiles, does it throw an exception?
If it runs, what is the exact output?
Which rule explains the result?
Could a small syntax change alter the answer?

Missed-question review method

Do not only record the right answer. Record the reason you missed it.

Error type	What it usually means	Fix
Syntax error missed	You assumed code compiled	Practice compile/no-compile drills
API confusion	You remembered the class but not behavior	Write a tiny example and run it
Type inference mistake	You lost track of generic, lambda, or stream types	Annotate intermediate types by hand
Exception-flow mistake	You missed checked exceptions, finally, or resource closing	Draw execution order
Output-order mistake	You rushed through side effects	Trace line by line
Overload/override mistake	You confused compile-time and runtime binding	Write method-resolution notes
Module/access mistake	You overlooked visibility or exports	Build a small module example
Concurrency mistake	You assumed deterministic ordering	Mark what is guaranteed vs not guaranteed

Error log template

Use a simple table or spreadsheet.

Field	Example
Date	2026-06-18
Topic	Streams
Question type	Predict output
Missed because	Confused `map` result type with `flatMap`
Correct rule	`flatMap` flattens nested streams into one stream
Verification	Wrote 10-line example and ran it
Retest date	In 2 days

Review the error log every study day. Retest missed concepts after 24 hours, 3 days, and 7 days.

Diagnostic-first approach

Before choosing a detailed plan, take a diagnostic set under light time pressure.

Diagnostic result	What to do next
Strong across most areas, only small gaps	Use the 7-day or 14-day plan
Good Java experience but weak in modules, localization, JDBC, or concurrency	Use the 14-day plan
Mixed results across several areas	Use the 30-day plan
Low confidence reading exam-style code	Use the 60/90-day path

After the diagnostic, sort weak areas into three categories:

Category	Meaning	Study priority
Red	Frequently missed or guessed	Review immediately
Yellow	Partly understood but inconsistent	Drill every 2 to 3 days
Green	Usually correct	Maintain with mixed practice

7-day final review plan

Use this only if you have already studied the main 1Z0-829 topics. This is not a full learning plan.

Day	Main goal	Study actions
1	Diagnostic and triage	Take a timed or semi-timed mixed set. Build a red/yellow/green topic list. Review all misses.
2	Language and OOP cleanup	Drill scope, casting, inheritance, interfaces, records, sealed classes, overriding, overloading, and access modifiers.
3	Collections, generics, lambdas, streams	Practice type inference, functional interfaces, method references, collectors, optional values, and stream pipeline output.
4	Exceptions, I/O, date/time, localization	Review checked exceptions, try-with-resources, file APIs, formatting, parsing, locales, and resource bundles.
5	Modules, concurrency, JDBC	Drill module declarations, classpath/module path concepts, executors, synchronization, concurrent behavior, JDBC resource handling.
6	Full timed mock	Take a full mock using the timing shown in your current Oracle exam guide or appointment details. Review every missed and guessed question.
7	Final weak-area sprint	Revisit only high-yield weak areas. Review notes, error log, and small code examples. Stop heavy new learning.

7-day rules

Do not try to learn every topic from scratch.
Spend at least as much time reviewing explanations as answering questions.
Stop adding new material during the final 24 to 48 hours unless it directly fixes a repeated miss.
Keep final-day practice short and confidence-building.

14-day focused plan

Use this if you know Java but need concentrated exam preparation.

Day	Focus	Practice target
1	Diagnostic mixed set	Identify red/yellow/green topics
2	Java fundamentals	Operators, promotion, strings, wrappers, scope, control flow
3	OOP foundations	Classes, constructors, initialization, inheritance, interfaces
4	Advanced OOP and Java 17 features	Records, sealed classes, pattern matching, polymorphism edge cases
5	Exceptions and resource management	Checked exceptions, try-with-resources, suppressed exceptions, flow control
6	Arrays, generics, collections	Sorting, equality, comparison, wildcards, collection behavior
7	Lambdas and functional interfaces	Predicate, Function, Consumer, Supplier, method references
8	Streams	Intermediate vs terminal operations, collectors, primitive streams, Optional
9	Date/time, text, localization	`java.time`, formatting, parsing, locales, resource bundles
10	I/O and NIO.2	Paths, files, readers/writers, streams, file operations
11	Concurrency	Threads, executors, synchronization, concurrent collections, race conditions
12	Modules and JDBC	Module declarations, exports/requires, JDBC flow and resource cleanup
13	Full timed mock	Simulate exam timing; review all misses and guesses
14	Final review	Red-topic sprint, memorization cleanup, light mixed practice

14-day daily checklist

Each day complete:

20 to 40 minutes of topic review
20 to 40 targeted questions
3 to 5 code snippets compiled or mentally traced
Missed-question log update
10-minute review of prior misses

30-day balanced plan

This is the best default plan for many working candidates. It gives enough time for topic coverage, code practice, and timed mocks.

Week 1: Diagnostic and Java language precision

Day	Focus
1	Diagnostic mixed set and topic triage
2	Primitives, wrappers, strings, operators, numeric promotion
3	Control flow, loops, switch behavior, scope
4	Classes, fields, methods, constructors, initialization order
5	Inheritance, interfaces, overriding, overloading, access modifiers
6	Records, sealed classes, pattern matching, Java 17 feature review
7	Mixed review and missed-question cleanup

Week 2: Collections, generics, lambdas, and streams

Day	Focus
8	Arrays and array edge cases
9	Collections: `List`, `Set`, `Map`, equality, sorting
10	Generics, type bounds, wildcards, type inference
11	Functional interfaces and lambdas
12	Method references and common functional patterns
13	Streams: pipeline behavior, terminal operations, collectors
14	Timed topic mock and review

Week 3: APIs and platform topics

Day	Focus
15	Exceptions and try-with-resources
16	Date/time API, formatting, parsing
17	Localization and resource bundles
18	I/O streams, readers, writers
19	NIO.2 paths and files
20	JDBC basics, transactions, resource cleanup
21	Mixed review and error-log retest

Week 4: Concurrency, modules, mocks, and final readiness

Day	Focus
22	Threads, executors, synchronization
23	Concurrent collections, atomicity, parallel execution concerns
24	Modules, exports, requires, service visibility, classpath vs module path
25	Full timed mock 1
26	Deep review of mock 1
27	Weak-area sprint
28	Full timed mock 2
29	Final review of misses, guessed questions, and Java rules
30	Light review, rest, exam logistics

30-day mock schedule

Timing	Mock type	Purpose
Day 1	Diagnostic set	Find weak areas
Day 14	Timed topic mock	Test retention after two weeks
Day 25	Full timed mock	Measure readiness under pressure
Day 28	Full timed mock	Confirm improvement and pacing

60/90-day full preparation path

Use this path if you are starting earlier, returning to Java after time away, or need to build Java SE 17 depth before heavy mock exams.

Phase 1: Foundation and setup

Timeline	Focus	Outcome
Days 1-7	Set up Java 17 environment, take diagnostic, organize notes	Baseline score and topic map
Days 8-14	Java fundamentals and control flow	Fewer syntax and promotion errors
Days 15-21	OOP foundations	Clear understanding of constructors, inheritance, interfaces
Days 22-30	Java 17 language features and exceptions	Confidence with records, sealed classes, exception flow

Phase 2: Core exam skills

Timeline	Focus	Outcome
Days 31-38	Arrays, collections, generics	Stronger type and collection reasoning
Days 39-46	Lambdas and functional interfaces	Better lambda syntax and target type recognition
Days 47-54	Streams and collectors	Accurate pipeline tracing
Days 55-60	Review sprint and timed topic mock	Confirm progress before advanced APIs

Phase 3 for 90-day candidates

If you have 90 days, expand the plan instead of rushing into mocks.

Timeline	Focus	Outcome
Days 61-68	Date/time, localization, formatting	Accurate API selection and parsing behavior
Days 69-76	I/O, NIO.2, JDBC	Better resource handling and file/database flow
Days 77-82	Concurrency and modules	Improved reasoning about execution, visibility, and packaging
Days 83-86	Full timed mock 1 and deep review	Identify final weak areas
Days 87-89	Weak-area sprint	Fix repeated misses
Day 90	Light final review	Enter exam rested and organized

If using 60 days instead of 90

Compress Phase 3 into the final two weeks:

Days	Focus
47-50	Date/time, localization
51-53	I/O, NIO.2, JDBC
54-56	Concurrency and modules
57	Full timed mock
58	Mock review
59	Weak-area sprint
60	Light review

Topic-by-topic drill guide

Use this table when planning daily practice.

Topic	Drill method	Done when you can…
Numeric promotion and operators	Predict expression types and values	Explain why the result type changes
Strings and wrappers	Trace immutability, equality, boxing, parsing	Identify object vs value comparisons
Control flow	Trace loops, switch, break, continue, labels	Predict exact output or compile failure
Constructors and initialization	Write parent/child initialization examples	Order static, instance, and constructor steps
Inheritance and interfaces	Compare overload vs override cases	State which method is selected and why
Records and sealed classes	Write minimal examples	Explain generated members and permitted inheritance
Exceptions	Draw flow through try/catch/finally	Predict checked exception requirements
Collections	Sort, search, compare, mutate collections	Know when equality, ordering, or mutability matters
Generics	Rewrite declarations with bounds	Explain what assignments compile
Lambdas	Convert lambdas to method references	Identify target functional interface
Streams	Trace each pipeline stage	Know when lazy execution occurs
Date/time	Format, parse, adjust dates	Choose the right temporal type
Localization	Load bundles and format locale-specific data	Explain fallback and formatting behavior conceptually
I/O and NIO.2	Create, read, copy, move simple files	Identify path and file operation behavior
JDBC	Trace connection, statement, result set, transaction flow	Place resource cleanup correctly
Concurrency	Mark shared state and ordering assumptions	Separate guaranteed behavior from possible behavior
Modules	Build a two-module example	Explain `requires` and `exports` in code context

Hands-on mini-labs

These are short labs for reinforcing exam behavior.

Lab 1: Compile or not compile

Create five tiny files that test one rule at a time:

Access modifiers across packages
Overloaded methods with widening, boxing, and varargs
Interface default and static methods
Generic method calls
Sealed class inheritance rules

Before compiling, write your prediction:

File	Prediction	Actual	Rule
`A.java`	Compiles	Compiles	Correct
`B.java`	Fails line 8	Fails line 8	Access modifier

Lab 2: Stream tracing

For each stream question, write:

Source type
Intermediate operation result types
Terminal operation
Whether execution is lazy until terminal operation
Final result or exception

Lab 3: Exception and resource flow

Write small try-with-resources examples and trace:

Resource creation order
Resource closing order
Primary exception
Suppressed exception behavior
Whether finally executes

Lab 4: Module visibility

Build two small modules:

One module exports a package.
One module requires the first module.
Then remove exports or requires and observe the failure.

The goal is to connect module declarations to compile-time and runtime behavior.

When to use timed mock exams

Timed mocks are most useful after you have reviewed enough content to learn from the result.

Preparation stage	Mock use	What to do after
Start of plan	Short diagnostic set	Identify topic priorities
Midpoint	Timed topic mock	Check whether review is sticking
Final 7 to 10 days	Full timed mock	Practice pacing and exam pressure
Final 48 hours	Usually avoid full mocks	Use light review unless you need pacing practice

Use the current Oracle exam information available for your appointment or exam guide when setting mock timing. Do not rely on outdated timing from old notes.

How to review a timed mock

For every question, mark one of four outcomes:

Outcome	Meaning	Action
Correct and confident	You knew the rule	Briefly confirm explanation
Correct but guessed	Hidden weakness	Add to error log
Incorrect but close	Partial knowledge	Drill topic within 24 hours
Incorrect and unfamiliar	Content gap	Re-study the topic before more mocks

A full mock is not finished when the timer ends. It is finished when every missed or guessed question has a written rule attached to it.

Final-week rules

During the final week, your goal is to reduce mistakes, not to collect more resources.

Rule	Why it matters
Stop adding broad new material 3 to 4 days before the exam	New content can displace tested rules you already know
Keep compiling small examples	Java behavior is precise; verification prevents false memory
Review guessed questions, not only wrong ones	Guesses often expose weak reasoning
Avoid marathon sessions the day before the exam	Fatigue increases code-reading mistakes
Practice pacing with at least one timed set	You need enough time to read code carefully
Keep a one-page rule sheet	Use it for final review, not during the exam

Final 24-hour checklist

Review your error log.
Re-read rules for your top 5 weak topics.
Do a small mixed set only if it will not increase stress.
Verify exam appointment details.
Prepare identification and testing setup if applicable.
Sleep normally.
Do not start a new book, course, or large topic.

Exam-readiness checks

You are closer to ready when the following are true:

Readiness check	Target behavior
Code prediction	You can predict compile errors, runtime exceptions, and output without running code
OOP reasoning	You can separate overload selection from override dispatch
Stream reasoning	You can trace pipeline types and terminal behavior
Exceptions	You can identify checked exception requirements and resource-closing behavior
Modules	You can explain basic `module-info.java` relationships
Concurrency	You do not assume ordering unless Java guarantees it
API selection	You can choose appropriate Java SE APIs for dates, files, localization, and JDBC flow
Mock review	Your repeated misses are decreasing across practice sets
Pacing	You can finish timed sets without rushing the final questions

If you are still missing the same topic repeatedly, do not take another full mock immediately. Spend one focused session rebuilding that topic, then retest with targeted questions.

Practical next step

Start with a diagnostic mixed practice set for Oracle Java SE 17 Developer (1Z0-829). Build your red/yellow/green topic list, choose the 7-day, 14-day, 30-day, or 60/90-day path, and begin daily missed-question review from the first session.

Quick Review

Exam Blueprint