O R A C L E   C E R T I F I C A T I O N

1Z0-819 Java SE 11 Developer Practice Exam

Exam Number: 4833 | Last updated April 19, 2026 | 700+ questions across 4 vendor-aligned objectives

The 1Z0-819 Java SE 11 Developer exam is written for software developers who design, write, and maintain Java applications on the Java SE 11 platform. Candidates validate mastery of the language, the standard library, the module system, and the modern features introduced through JDK 11, including lambdas, streams, concurrency, NIO.2, and the new HTTP client. Earning the credential signals you can ship production-quality Java on the long-term-support release.

The heaviest content is Language Fundamentals and Object-Oriented Programming (roughly 30%), covering classes, interfaces, inheritance, generics, enums, nested types, and local variable type inference. Functional Programming and Streams contributes another 25% with lambdas, method references, the Stream API, Collectors, and Optional.

Modules, Concurrency, and I/O sits near 25% and drills into the Java Platform Module System, java.util.concurrent, the Fork/Join framework, NIO.2, and the new HTTP client. Exceptions, Annotations, JDBC, and Security rounds out the remaining weight with checked versus unchecked exceptions, try-with-resources, annotations, core JDBC operations, and secure coding practices.

♥  Generics and type inference are where the exam separates strong candidates — practice reading bounded wildcards, the PECS rule, and var type inference on loops and lambda parameters. Drill the Stream API until terminal and intermediate operations are automatic, especially the Collectors grouping and mapping pipelines. Also rehearse the module system; JPMS questions often hinge on which exports, opens, requires transitive, and services directive a module needs.

Every answer links to the source. Each explanation below includes a hyperlink to the exact Oracle documentation page the question was derived from. PowerKram is the only practice platform with source-verified explanations. Learn about our methodology →

754

practice exam users

94.0%

satisfied users

92.8%

passed the exam

4.2/5

quality rating

Test your 1Z0 819 Java SE 11 Dev knowledge

10 of 700+ questions

Question #1 - Language Fundamentals and Object-Oriented Programming

A Java developer is designing a generic utility method that copies elements from one collection of some type to another collection that accepts any supertype of that type. He wants the method signature to express this relationship safely.

Which signature correctly uses bounded wildcards (PECS)?

A) public static void copy(List src, List dst)
B) public static void copy(List src, List dst)
C) public static void copy(List src, List dst)
D) public static void copy(List src, List dst)

 

Correct answers: A – Explanation:
PECS: Producer Extends, Consumer Super. The source list is a producer of T (? extends T) and the destination is a consumer (? super T). Option B is too strict (exact type match). Option C loses the type relationship. Option D reverses PECS and won’t compile with correct semantics. Source: Check Source

A developer writes `var list = new ArrayList<>();` and then calls `list.add(“hello”);` followed by `list.add(42);`. The code compiles.

What is the inferred type of `list`?

A) ArrayList — inferred from the second add.
B) ArrayList — the diamond with no explicit type and var produces Object.
C) A compilation error.
D) ArrayList — inferred from the first add.

 

Correct answers: B – Explanation:
With `new ArrayList<>()` the diamond infers Object when no target type is provided, and `var` picks up that declared type. Mixed add calls then work because everything is Object. Option D, Option A, and Option C misread Java’s type inference rules. Source: Check Source

A data engineer has a List and wants to produce a Map> grouping employees by department, using the Stream API.

Which Collector fits?

A) Collectors.counting()
B) Collectors.partitioningBy(e -> e.getDepartment() != null)
C) Collectors.groupingBy(Employee::getDepartment)
D) Collectors.toMap(Employee::getDepartment, Function.identity())

 

Correct answers: C – Explanation:
Collectors.groupingBy produces Map> keyed by the classifier — exactly a Map>. Option D produces Map and fails on duplicate keys. Option B splits into two groups only (true/false). Option A produces a count, not grouped employees. Source: Check Source

A developer calls `Optional.ofNullable(maybeNullValue).map(String::toUpperCase).orElse(“DEFAULT”)`. `maybeNullValue` is `null`.

What is the result?

A) A NullPointerException at runtime.
B) An empty string.
C) “null” as a literal string.
D) “DEFAULT” — map skips null Optionals and orElse returns the fallback.

 

Correct answers: D – Explanation:
Optional.ofNullable wraps null as an empty Optional; map on an empty Optional returns empty; orElse then returns “DEFAULT”. Option C, Option A, and Option B misread Optional’s null-safe behavior. Source: Check Source

A developer wants the Stream pipeline to run in parallel to take advantage of multi-core hardware, but he is worried about unordered output from a forEach.

Which Stream API approach preserves encounter order while still using parallelism?

A) Use forEachOrdered on the parallel stream to honor encounter order.
B) Switch to sequential() and lose all parallelism.
C) Collect to a Set and iterate.
D) Rely on forEach to be ordered in parallel streams.

 

Correct answers: A – Explanation:
forEachOrdered preserves encounter order even on parallel streams; forEach does not. Option D is incorrect — forEach makes no ordering guarantee on parallel streams. Option B unnecessarily sacrifices parallelism. Option C produces an unordered collection. Source: Check Source

An architect is modularizing a legacy application with JPMS. Module A’s public API depends on types from Module B, and any consumer of A also needs those B types visible on their classpath.

Which module-info.java directive in A expresses this transitive requirement?

A) requires B;
B) requires transitive B;
C) opens A to B;
D) exports A to B;

 

Correct answers: B – Explanation:
`requires transitive B` makes B’s readability transitive to A’s consumers so they don’t have to requires B themselves. Option A only satisfies A’s own compilation. Option D exposes A’s packages, not B. Option C opens A for reflection. Source: Check Source

A developer wants to parallelize a CPU-bound recursive divide-and-conquer computation that fans out into independent subtasks.

Which framework is most appropriate?

A) Sequential for-loop processing.
B) Thread.sleep() calls in a loop.
C) ForkJoinPool with RecursiveTask (Fork/Join framework).
D) A single-threaded ExecutorService.

 

Correct answers: C – Explanation:
Fork/Join is designed for divide-and-conquer with work-stealing, using RecursiveTask or RecursiveAction. Option D serializes execution. Option B is not parallelism. Option A misses parallelism entirely. Source: Check Source

A developer writes JDBC code opening a Connection, PreparedStatement, and ResultSet. She wants all three closed automatically even if an exception is thrown mid-query.

Which Java construct guarantees resource cleanup across all three?

A) A single try-catch with no close() calls.
B) Manual close() calls in a finally block only for ResultSet.
C) Relying on the garbage collector to close them.
D) try-with-resources declaring Connection, PreparedStatement, and ResultSet as resources.

 

Correct answers: D – Explanation:
try-with-resources closes AutoCloseable resources in reverse order of declaration, even on exception — the correct JDBC cleanup pattern. Option B is incomplete. Option C is unreliable (GC timing). Option A leaks connections. Source: Check Source

A method declares `throws IOException` but a caller handles the IOException with a generic `catch (Exception e)` block. The caller also calls a second method that throws SQLException.

Is the single generic catch sufficient to handle both?

A) Yes — Exception is a supertype of both IOException and SQLException, so one catch handles both.
B) No — checked exceptions cannot be caught at the Exception level.
C) No — you must catch IOException and SQLException separately in all cases.
D) No — Exception does not include SQLException.

 

Correct answers: A – Explanation:
Both IOException and SQLException are subclasses of Exception; a single `catch (Exception e)` handles both. Option C is not required by the language. Option D is wrong about the hierarchy. Option B is wrong about catch semantics. Source: Check Source

A class designer wants an immutable data carrier with final fields, a public constructor, and value-based equals and hashCode.

Which Java 11 approach best expresses this?

A) A class with public mutable fields.
B) A lambda expression.
C) A final class with private final fields, a constructor that sets them, and equals/hashCode generated from the fields (or implemented explicitly).
D) A sealed interface.

 

Correct answers: C – Explanation:
Java 11 predates records; immutable data carriers use final classes, final fields, a constructor, and explicit equals/hashCode. Option A is mutable. Option D is a different concept and was introduced later. Option B is a function, not a data class. Source: Check Source

Get 700+ more questions with source-linked explanations

Every answer traces to the exact Oracle documentation page — so you learn from the source, not just memorize answers.

Start free 24-hour trial — no credit card

Exam mode & learn mode · Score by objective · Updated April 19, 2026

Learn more...

What the 1Z0 819 Java SE 11 Dev exam measures

  • Language fundamentals and object-oriented programming (30%) — design classes, interfaces, inheritance, generics, enums, and nested types, and apply local variable type inference.
  • Functional programming and streams (25%) — write lambdas and method references, compose Stream pipelines with Collectors, and use Optional for null-safe chains.
  • Modules, concurrency, and I/O (25%) — build and deploy JPMS modules, orchestrate java.util.concurrent and the Fork/Join framework, and use NIO.2 and the new HTTP client.
  • Exceptions, annotations, JDBC, and security (20%) — handle checked and unchecked exceptions, apply annotations, execute JDBC operations, and write secure, resource-safe code.

  • Review the official 1Z0-819 exam page and take notes on every objective and weight.
  • Complete the Oracle University Java SE 11 Programmer learning path on MyLearn.
  • Install the JDK 11 locally or in an OCI always-free VM, build a multi-module application with JPMS, write Stream pipelines against a sample dataset, and exercise the new HTTP client against a public API.
  • Apply the skills on real work: port a small codebase to JDK 11, rewrite a loop as a Stream pipeline, or add a parallel Fork/Join job to a CPU-bound routine.
  • Master one objective at a time, starting with language fundamentals and object-oriented programming since it carries the most weight.
  • Run PowerKram learn mode to see feedback after every question with sourced links back to Oracle documentation.
  • Finish with PowerKram exam mode across all objectives until you pass three back-to-back full-length attempts.

Java SE 11 Developer credentials support core software-engineering careers:

  • Java Software Engineer — $110,000–$160,000 (Glassdoor).
  • Backend Developer — $105,000–$150,000 (PayScale).
  • Senior Software Engineer — $135,000–$190,000 (Levels.fyi).

Work through the Java SE 11 Certified Professional Learning Path on Oracle MyLearn. Reinforce with the Java SE 11 documentation and the Java SE 11 API Specification.

Related certifications to explore

1Z0-071 Oracle Database SQL
1Z0-149 Oracle Database Program with PL/SQL
1Z0-1084 Oracle Cloud Infrastructure Developer 2022 Professional
AWS Certified Developer Associate
Microsoft AZ-204 Azure Developer Associate
Python Institute Professional Python Programmer Level 1

Related reading from our Learning Hub

DevOps - Mistery Removed
PowerKram vs IT Exams — competitive vendor exam coverage
Platform Administrators Certification Guide
PowerKram vs Exam Topics — most competitive pricing