Java SE 8 Programmer II (1Z0-809) Exam Guide
Java SE 8 Programmer II validates whether a Java developer can apply advanced language, library, concurrency, database, I/O, and localization concepts rather than only recognize isolated syntax. Oracle positions it as the second examination in the Java SE 8 Programmer path toward the Oracle Certified Professional Java SE 8 Programmer credential. This guide helps candidates decide whether their Java foundation is ready, which objective areas need hands-on practice, how to sequence study, and what to verify before scheduling because delivery details differ by exam language and source page.
What does Java SE 8 Programmer II validate?
The examination is intended to assess practical Java SE 8 programming ability at a level where a candidate can understand a designer’s intent and implement functionality independently. Oracle associates Java SE 8 Programmer II with exam 1Z0-809 and describes it as part of the path to the Oracle Certified Professional Java SE 8 Programmer credential.
The objective list is broad. It reaches from class design and generics to streams, exceptions, date and time, file handling, concurrency, JDBC, and localization. A candidate who has memorized method names but cannot predict compilation, runtime behavior, resource handling, or thread interaction will need more preparation.
Treat the exam as a reasoning test over small Java programs. Your study target is not simply to write a complete application. It is to explain what a fragment does, identify a legal or illegal use of an API, choose an appropriate abstraction, and follow the consequences of library and language rules.
Who should take this exam?
This exam is most suitable for a developer who already has the Java SE 8 foundation represented by Programmer I and is ready to work with the more advanced topics in Programmer II. Oracle’s OCP path lists Java SE Programmer I, exam 1Z0-808, as the required preceding exam and Java SE Programmer II, exam 1Z0-809, as the next step.
Oracle’s Java SE 8 Programmer Professional learning path is described as the second path in a two-part Java SE 8 training and certification program and requires completion of the OCA learning path first. That requirement is an important scheduling checkpoint: if you have not completed the preceding path or exam requirement, confirm your eligibility with Oracle before buying or booking anything.
The credential is not limited to one job title. It can suit Java application developers, maintainers of enterprise code, and learners moving from foundational Java toward professional-level work. It is a poor fit for someone who has not yet become comfortable with classes, inheritance, exceptions, collections, and basic control flow. Build that foundation first rather than trying to compensate with question memorization.
Which skills appear in the objective list?
The objectives cover distinct technical families, and each deserves separate practice. Use the list below as a diagnostic map, not as a substitute for reading the current official exam page. Oracle’s Japanese objectives identify the following areas for Java SE 8 Programmer II.
Class design includes encapsulation, access modifiers, composition, inheritance, polymorphism, and overriding Object methods such as hashCode, equals, and toString. It also includes singleton and immutable classes, static initialization, abstract classes and methods, final, nested and inner classes, enumerations, interfaces, the Override annotation, and lambda expressions.
Generics and collections include generic classes, ArrayList, TreeSet, TreeMap, ArrayDeque, Comparator, and Comparable. The important preparation task is to understand type relationships and ordering behavior, not merely to remember class names.
Collections, functional interfaces, and streams include stream pipelines, filtering with lambdas, method references, Predicate, Consumer, Function, Supplier, primitive-specialized functional interfaces, two-argument interfaces, and UnaryOperator. The stream API objectives extend to map, peek, search operations, Optional, calculations, sorting, collect, grouping, partitioning, and flatMap.
Exceptions and assertions include try-catch, throw, catch, multi-catch, finally, try-with-resources, custom exceptions, AutoCloseable resources, and assertions. The date and time API includes LocalDate, LocalTime, LocalDateTime, Instant, Period, Duration, TemporalUnit, time zones, formatting, and daylight-saving changes.
Java I/O objectives include console input and output, classes such as BufferedReader, BufferedWriter, File, FileReader, FileWriter, FileInputStream, FileOutputStream, ObjectInputStream, ObjectOutputStream, and PrintWriter. NIO.2 adds Path operations for files and directories and use of the stream API with NIO.2.
Concurrency covers Runnable, Callable, ExecutorService, deadlock, starvation, livelock, race conditions, synchronized, atomic classes, CyclicBarrier, CopyOnWriteArrayList, Fork/Join, and parallel streams. JDBC covers Driver, Connection, Statement, ResultSet, DriverManager, JDBC URLs, queries, result iteration, and correct closure of database resources.
Localization covers the benefits of localizing an application. Review the complete current objective list directly because the supplied research excerpt begins the localization section but does not reproduce all of its entries. Do not infer omitted objectives from a third-party checklist.
How should you use the objectives as a study checklist?
Convert every objective into an observable task. For example, do not mark “streams” complete after watching a lesson. Mark it complete only after you can build and explain a pipeline using filtering, mapping, a terminal search or reduction, and collection into a result.
Create a table with four columns: objective, code exercise, failure pattern, and confidence. In the code-exercise column, write a small task such as comparing Comparable with Comparator, managing a resource with try-with-resources, or reading a ResultSet and closing the JDBC objects. In the failure-pattern column, record what confused you and why.
Keep language rules separate from API recall. A question involving a lambda may test target typing, an interface contract, or overload selection. A question involving TreeSet may test ordering and comparison rather than construction. Your notes should therefore contain both a short rule and a runnable example.
The supplied official research does not provide percentage weights for the objective areas. Do not rank bare percentages or create a weighted study plan from unsupported figures. Until Oracle supplies a current blueprint for the version and language you intend to take, prioritize by objective breadth, your diagnostic results, and the time required to repair weak areas.
What should you know about format and delivery before scheduling?
Verify the exact exam language and delivery status on Oracle’s current certification information before making a purchase. The supplied sources are not uniform: Oracle’s catalog lists Java SE 8 Programmer II with exam code 1Z0-809 and notes availability in Traditional Chinese for Taiwan, while Oracle’s Japanese page separately states that delivery of 1Z0-809-JPN ended on July 16, 2025.
The Japanese page identifies 1Z0-809-JPN as a multiple-choice exam with a 120-minute duration, 68 questions, and a 65% passing score. Those figures apply to the Japanese exam page and should not be presented as universal details for every language or delivery route. Because that page also records that delivery ended, use it as historical and language-specific evidence rather than assuming the same booking option remains open.
Oracle’s education track lists the exam duration as 120 minutes for Java SE 8 Programmer II. Even when a duration is supported, confirm the current appointment information and any applicable policies through Oracle’s official certification route. Exam availability, language options, and registration procedures can change independently of the technical objectives.
Do not confuse Oracle’s exam-preparation seminar with the certification examination. The Learn Oracle page names an official “Certification Exam Prep: Java SE 8 Programmer II (OCP) Ed 1” event, but the supplied page also displays that the event has been cancelled. Treat it as evidence that Oracle has offered preparation content, not as a currently available booking recommendation.
The lab instructions on that page concern access to a training environment, including lab scheduling and system checks. They are not evidence of the certification exam’s delivery method, question format, or test-day interface. If you enroll in a separate Oracle training lab, follow the instructions shown for that lab and keep its credentials separate from exam-registration decisions.
How do you decide whether you are ready to schedule?
Schedule only after you can solve unfamiliar code problems across the objective families without relying on a remembered answer pattern. Readiness should be based on repeatable reasoning: you can state why code compiles or fails, predict the relevant output or exception, and explain the API choice that makes the result correct.
Start with a diagnostic pass. Take one small exercise from each broad area: class design, generics and collections, streams, exceptions and date/time, I/O and NIO.2, concurrency, JDBC, and localization. Use your own code or reputable instructional exercises, not leaked questions. Record whether the difficulty came from syntax, API behavior, or time pressure.
If you repeatedly miss a topic, do not respond by collecting more practice questions immediately. Return to the smallest missing concept and write a minimal program. For example, isolate resource closure from file parsing, or isolate ordering from collection mutation. Once the program is understood, combine it with one neighboring concept.
A reasonable final checkpoint is an explanation test. Without looking at notes, explain how a stream pipeline reaches its terminal operation, why a resource is closed, how a comparison determines sorted collection behavior, how a JDBC result is consumed, and how a race condition can arise. If those explanations are vague, postpone scheduling and repair the underlying model.
Signs that the foundation is not ready
You are still guessing about checked exceptions, access control, overriding, generic bounds, or the difference between an object and a stream. You cannot compile small examples without extensive correction. You recognize API names but cannot select an operation or predict its result. These are foundation gaps, not problems that a last-minute question bank reliably fixes.
Signs that scheduling is reasonable
You can complete short, mixed-topic exercises, review mistakes without repeating them, and distinguish a compilation issue from a runtime issue. You can also work within the official time information for your exam route while leaving time to reread code carefully. Confirm the current registration and delivery details immediately before committing.
What study sequence gives the best return?
Study in dependency order: reinforce class design and generics first, then collections and functional programming, followed by streams, exceptions and date/time, I/O and NIO.2, concurrency, JDBC, and localization. This sequence lets later subjects reuse earlier concepts while preventing advanced APIs from becoming disconnected memorization.
Begin with class design because inheritance, interfaces, encapsulation, polymorphism, and immutability recur throughout the rest of the objectives. Next practice generic types and collection ordering. Only then make streams a major focus; otherwise a stream exercise can obscure whether the real problem is type inference, collection behavior, or terminal-operation semantics.
After the language and collection foundation, pair exceptions with I/O and JDBC. Resource management, checked exceptions, and correct closure have a natural relationship. Pair concurrency with executors and collections, then compare sequential and parallel stream reasoning. Finish with localization and a complete mixed review rather than leaving it as an unexamined final checkbox.
Use short feedback loops. Read a concept, write a minimal example, alter one rule, compile or run it, and explain the change. Keep a mistake log with the original assumption, the actual rule, and a corrected example. This is more useful than highlighting a long chapter without testing recall.
Phase one: establish the object model
Practice access modifiers, composition, inheritance, polymorphism, abstract classes, interfaces, static members, final, nested classes, enums, and Object-method overrides. Write immutable and singleton examples, then inspect where state can still leak or where a subtype changes expected behavior. Include lambda targets and Override because they connect class design to Java SE 8 features.
Phase two: make types and collections predictable
Write generic classes and methods, then use ArrayList, TreeSet, TreeMap, and ArrayDeque in small tasks. Compare Comparable and Comparator with explicit ordering examples. Test what happens when an ordering rule is inconsistent with equality, and distinguish the interface type of a reference from the concrete collection behavior.
Phase three: reason through functional code
Build pipelines with Predicate, Consumer, Function, Supplier, primitive functional interfaces, two-argument interfaces, and UnaryOperator. Practice method references, map, peek, Optional, findFirst, findAny, anyMatch, allMatch, noneMatch, collect, grouping, partitioning, and flatMap. For each pipeline, identify intermediate operations, the terminal operation, and whether evaluation is lazy.
Phase four: apply platform APIs safely
Use try-with-resources with AutoCloseable, custom exceptions, assertions, and the Java SE 8 date/time types. Then write file and directory examples using classic I/O and Path. Add a small JDBC flow that connects, issues a query, iterates a ResultSet, and closes resources in the right structure. These exercises force API knowledge to meet control-flow and cleanup decisions.
Phase five: handle concurrency and integration
Create tasks with Runnable and Callable, execute them through ExecutorService, and identify where shared state produces a race condition. Study synchronized, atomic classes, CyclicBarrier, CopyOnWriteArrayList, Fork/Join, and parallel streams by explaining the coordination and performance implications. End with mixed exercises that combine resource handling, collections, streams, and concurrency.
Which topics deserve hands-on code rather than flashcards?
Write code for any subject where execution order, type inference, resource lifetime, comparison, or shared state changes the answer. Flashcards are useful for class names and definitions, but they cannot replace observing how a pipeline behaves, how a resource closes, or how a thread interaction creates a problem.
For class design, create a small hierarchy with an interface, an abstract class, an immutable value object, and an overridden equals/hashCode pair. Change a modifier or method signature one at a time and compile after each change. This exposes rules that passive reading often hides.
For streams, begin with a collection of simple domain objects and implement filtering, mapping, sorting, grouping, partitioning, and flattening. Explain each operation’s input and output type. Add Optional and search operations only after the ordinary pipeline is clear. Avoid using peek as a general debugging substitute; understand its place in a pipeline and test the resulting behavior.
For exceptions and I/O, deliberately create a resource that records closure, then use try-with-resources and nested resources. Compare thrown, caught, and finally behavior. For NIO.2, practice converting a Path into a file operation and using a stream API without forgetting that resource management still matters.
For concurrency, do not rely on a single successful run. Construct examples that make a race condition possible, then identify the shared mutable state and the synchronization or atomic approach that addresses it. Contrast the purpose of an executor, a barrier, a concurrent collection, and a Fork/Join task instead of treating them as interchangeable tools.
For JDBC, write the entire lifecycle: identify the driver and connection information, create a statement, issue a query, iterate the result set, and close the result set, statement, and connection. You do not need a large application; a small, readable flow reveals whether your understanding is procedural or merely vocabulary-based.
How should you manage practice questions?
Use practice questions as diagnosis after learning, not as a replacement for the Java platform. A useful question session ends with an explanation of every option you rejected, especially when the question turns on a compilation rule or a subtle API contract.
Before choosing an answer, classify the task. Is it asking about compilation, overload resolution, inheritance, generic typing, execution order, exception flow, collection ordering, stream evaluation, resource closure, or concurrency? This classification prevents a familiar keyword from pulling your attention toward the wrong rule.
For code questions, trace in a fixed order: declarations and types, initialization, overload or override selection, control flow, resource and exception behavior, then output or final state. Write a short trace instead of jumping to a remembered result. If the fragment involves a stream, mark intermediate versus terminal operations and identify when work is triggered.
After each miss, rewrite the example into a smaller program and create a nearby variant that should produce a different result. For instance, change one access modifier, replace a Comparator, move a terminal operation, or alter the resource declaration. The goal is to learn the boundary of the rule.
Never use dumps, leaked questions, or memorized answer keys as a passing strategy. They do not establish that you understand the official objectives, and they can leave major gaps in areas such as concurrency, JDBC, and localization. Use legitimate learning resources and your own runnable experiments.
What mistakes commonly derail preparation?
The most expensive mistakes are usually planning errors: studying only the topics that feel familiar, treating every collection as equivalent, and postponing hands-on work until the final review. Correct these by measuring coverage against the objective list and requiring a code or explanation task for each technical family.
A second mistake is confusing Java syntax with Java behavior. A candidate may know how to write a lambda but not know which functional interface supplies its target type. They may recognize TreeMap but not understand ordering. They may know try-with-resources exists but not trace closure and exception flow. Pair every syntax note with a behavior test.
A third mistake is studying streams in isolation. Stream questions can involve generics, method references, Optional, collection transformations, ordering, or terminal operations at the same time. Build pipelines from typed collections and annotate the type after each major operation.
A fourth mistake is treating concurrency as vocabulary. Being able to define deadlock is not enough if you cannot identify lock acquisition order. Being able to name ExecutorService is not enough if you cannot distinguish task submission from task completion. Draw the participants, shared state, locks, and coordination points.
A fifth mistake is ignoring operational verification. The Japanese source records that 1Z0-809-JPN delivery ended on July 16, 2025, while the catalog still lists 1Z0-809 and notes Traditional Chinese availability for Taiwan. Confirm the exact route, language, and current status instead of assuming that a search result or an old study page is still schedulable.
What should you verify on Oracle’s sites next?
Use Oracle’s certification track to confirm the relationship between Programmer I and Programmer II, then check the certification catalog and the exam-language page relevant to you. Because the supplied evidence contains different status information for the Japanese route and the broader catalog, do this verification before purchasing a voucher, subscription, or preparation product.
Review the official objectives again after your diagnostic. The Japanese objective page is particularly useful for the technical scope: it lists class design, generics and collections, streams and filters, exceptions, date/time, I/O, concurrency, JDBC, and localization. It is still necessary to confirm whether the objective page for your intended language or current delivery route differs.
If you choose Oracle training, distinguish digital courses, learning paths, hands-on labs, and certification preparation from the exam itself. Oracle’s training page describes these as different learning experiences. The supplied Learn Oracle preparation page includes system and lab instructions, but it also states that the event has been cancelled, so check its live status rather than planning around the archived page.
For any Oracle training lab you actually book, follow the page’s operational instructions: test the connection, schedule the lab, and obtain credentials through the course process. The page instructs learners to check back before the lab for username and password details and provides a support route for lab issues. Those instructions apply to the training environment, not automatically to certification-exam registration.
Official status checks
Confirm the exam code, language, delivery status, registration route, and current policies from Oracle. Do not infer that the Japanese question count or passing score applies to another language, and do not infer that a catalog listing guarantees an appointment in your region.
Training-resource checks
Confirm whether an Oracle course or preparation event is active, cancelled, subscription-gated, or offered in your region. A course page can contain useful objectives and lab guidance even when the associated event is no longer available.
A practical final review plan
Use the final review to expose weak transitions between topics, not to reread every page. Begin with the objective checklist, select the areas with the lowest confidence, and solve mixed code exercises that force you to move between types, APIs, exceptions, and execution flow.
Review class design and generics together, then collections and streams together. Follow with exceptions, I/O, NIO.2, and JDBC because cleanup and checked-exception reasoning overlap. Finish with concurrency and localization, then return to any objective you have not represented in code or an explanation.
Prepare a one-page rule sheet in your own words. Include distinctions such as Comparable versus Comparator, intermediate versus terminal stream operations, checked versus unchecked exception handling, object time versus machine time, classic I/O versus Path-based operations, and task execution versus coordination. Keep examples short enough to reconstruct without copying.
On the last study session, stop adding new resources. Run a timed mixed practice block using a legitimate source, review why each answer is correct, and list unresolved questions for targeted research. Confirm the official appointment information separately. Technical confidence and administrative certainty are different readiness checks.
What should you do after reading this guide?
First, verify whether your intended 1Z0-809 language and delivery route is currently available. Second, confirm the preceding Programmer I requirement. Third, download or copy the official objective list into a diagnostic checklist. Fourth, write one small exercise for each major technical family and score your explanations, not only your answers.
If the diagnostic exposes gaps in class design, generics, or collections, repair those before concentrating on streams and concurrency. If the foundation is solid, spend more time tracing stream pipelines, resource lifecycles, JDBC operations, and concurrency interactions. Keep a mistake log and revisit it until the same misunderstanding no longer recurs.
Finally, schedule only after you have verified current Oracle details and can demonstrate broad objective coverage with your own code. The strongest preparation decision is not choosing the largest question bank; it is choosing a sequence that turns every unfamiliar result into an explainable Java rule.
Conclusion
Java SE 8 Programmer II is best approached as an applied Java assessment with a wide objective range and a separate administrative verification step. Build from object design and types into collections, streams, platform APIs, concurrency, JDBC, and localization. Use official Oracle information for eligibility and delivery, especially where the Japanese route and the broader catalog report different status details. Then schedule only when your code tracing, explanation, and objective coverage are reliable.
Related exams
- 1z0-811 exam — Java Foundations
- 1z0-819 exam — Java SE 11 Developer
- 1z0-830 exam — Java SE 21 Developer Professional
