My first attempt at the OCP Java SE 8 Programmer II exam ended at 61%. The pass mark is 65%. Four marks. I had eight years of Java behind me at the time, which made it worse, not better — and the fix turned out to be a stack of oracle-1z0-809 practice questions free of charge plus one change to how I read code. Here is the whole post-mortem, because the way I failed is the way most experienced developers fail this exam.
The exam, factually
- 85 multiple-choice questions, 150 minutes, 65% to pass, USD $245.
- Topics: generics and collections, lambda and the Streams API, concurrency, JDBC, I/O and NIO.2, exceptions and assertions, localization, and the date/time API.
- Compiles-or-not questions everywhere. Many questions where the correct answer is "compilation fails" or "an exception is thrown at runtime."
That last bullet is the exam in one line, and it is why experience betrays you.
Why eight years of Java made me worse at this
In real work, I have an IDE. When I write a generic method with a bounded wildcard slightly wrong, a red squiggle appears before my finger leaves the keyboard. I have never once had to hold the rules of type inference in my head, because I outsourced that to IntelliJ a decade ago.
1Z0-809 takes the IDE away and asks you to be the compiler. That is a genuinely different skill from writing Java, and it atrophies precisely because you are good at your job.
The specific places it bit me:
Generics. List<? extends Number> versus List<? super Number> — I knew the mnemonic, I could not apply it under time pressure to a method that both read and wrote. Producer-extends, consumer-super is not a fact to memorise; it is a rule you have to use twenty times before it is automatic.
Streams laziness and terminal operations. Questions that show a stream pipeline with no terminal operation and ask what prints. The answer is "nothing," and I got it right — but I got the harder version wrong: a pipeline reused after a terminal operation, which throws IllegalStateException. Real code rarely does that. The exam does it constantly.
Concurrency edge cases. ExecutorService shutdown semantics, what invokeAll blocks on, CopyOnWriteArrayList iteration behaviour during modification. I use concurrency utilities happily and had never once read their contracts carefully.
NIO.2 path arithmetic. Paths.get("/a/b").resolve("/c") — what does it return? If you cannot answer instantly, you will lose marks, and no amount of professional experience helps because nobody does path arithmetic by hand in production.
Effectively final and the rules on lambda capture. Easy marks, and I dropped one by rushing.
The habit change
Here is the thing that took me from 61% to a comfortable pass on the retake, and it takes about ten minutes a day.
Read code without running it, out loud, and predict the output before checking.
That is it. I took snippets — from practice banks, from the JDK source, from my own codebase — and forced myself to say what would happen line by line before compiling. Where it would fail. What it would print. Which exception, and from which line.
The first week was humiliating. By week three I was catching things my IDE would have caught for me, which is exactly the muscle the exam tests. This one practice is worth more than any book on the market for this specific exam, because the exam is fundamentally a "be the compiler" test.
The second half of the method is volume, and it needs to be volume with explanations. A question bank that tells you the answer is nearly useless here; you need to know why line 7 fails to compile. The free 1Z0-809 practice test is scored by topic, so you can see whether you are bleeding marks in concurrency or in generics rather than staring at one number. The full 1Z0-809 exam prep page has the deeper bank.
For the compile-or-not questions specifically, being able to ask a follow-up matters more than usual — "why does the wildcard make this call illegal, and what would make it legal?" is the question you actually need answered, and ai.examcert.app will walk it through conversationally rather than handing you a one-line explanation and moving on.
A four-week plan that works for working developers
Week 1 — diagnostic and generics. Cold practice test on day one. Then spend the week exclusively on generics and collections: bounded wildcards, type inference, Comparator chaining, the Collectors API. This is the single biggest topic block and the one professional experience helps with least.
Week 2 — streams and functional interfaces. Know every method on Stream, IntStream, Optional, and the standard functional interfaces cold — including the primitive specialisations, which the exam loves because nobody uses them daily. Practise reading pipelines and predicting output.
Week 3 — concurrency, JDBC, NIO.2, date/time. These are shallower but wide. Read the actual Javadoc contracts, not a summary. Date/time in particular is pure rules: period versus duration, what plusMonths does at the end of a month, how time zones and daylight saving are handled.
Week 4 — full-length timed runs and error post-mortems. Two or three complete 85-question, 150-minute attempts. Time management matters: 105 seconds per question, and some code-reading questions will legitimately take three minutes, so you need to be banking time on the easy ones.
Time management, specifically
I lost my first attempt partly to the clock. The strategy that fixed it:
- First pass — answer everything you are confident on, flag anything requiring careful compilation-tracing. Should take about 70 minutes.
- Second pass — the flagged code-tracing questions, with your remaining time and a calmer head.
- Never leave blanks. There is no negative marking. An educated guess on a flagged question is free expected value.
Is 1Z0-809 still worth it in 2026?
Java 8 is old. The exam is old. And yet the OCP for Java SE 8 remains, in a lot of enterprise hiring, the Java certification people actually recognise — because an enormous volume of production Java is still on 8 or on an 8-flavoured codebase, and because the material it tests (generics, streams, concurrency) is not version-specific in any way that matters.
If your employer pays for it, or if you work in an enterprise Java shop, it is a reasonable badge and an unreasonably good excuse to finally learn the parts of the language you have been approximating for years. That second part is the real return. I am a better Java developer for having failed this exam by four marks.
Start with a cold free 1Z0-809 practice test, then start reading code out loud. Four weeks.
Top comments (0)