Why Study with PlanetCert?
The Latest Questions
Practice questions and exam topics aligned with the current exam objectives.
Detailed Explanations
Go beyond the answer. Master the material with comprehensive learning and professional explanations for every concept.

AI-Powered Insights
Personalized preparation guidance that adapts to your performance and identifies weak spots automatically.
Exam Information
Official specifications published by Oracle
Exam Format
Registration
Validity
Skills this practice test covers
- Work with primitives, wrapper classes, String, StringBuilder and local variable type inference.
- Build classes with encapsulation, inheritance, polymorphism, interfaces and enumerations.
- Filter, transform, group and reduce data with lambda expressions and Java Streams.
- Declare, use and expose modules, including services and automatic modules.
- Create worker threads with Runnable and Callable and manage them with an ExecutorService.
- Run SQL statements through the JDBC API and process the query results.
Explore related topics
1Z0-819 exam content
13 domains · 42 topics · 225 of 906 questions are written for 1Z0-819
Working with Java data types11 questions
This domain covers the building blocks of every Java program. Candidates use primitives and wrapper classes with operators, type promotion and casting, handle text with String and StringBuilder, and use local variable type inference.
Skills tested
- Predict the result of type promotion and casting in an expression.
- Choose between String and StringBuilder for text that changes often.
- Use var for local variables and lambda parameters, and spot where it is not allowed.
Questions by topic
- Use local variable type inference4
- Handle text using String and StringBuilder classes7
Controlling Program Flow10 questions
This short domain covers loops and branches. Candidates create and use loops, if/else statements and switch statements, and trace which statement runs next.
Skills tested
- Trace for, for-each, while and do-while loops, including break and continue.
- Write switch statements with case labels and a default case.
- Follow if/else chains, including nested else if branches.
Questions by topic
- Create and use loops3
- Use switch statements3
- Use if/else statements4
Java Object-Oriented Approach45 questions
The domain with the most objectives follows objects from creation to garbage collection. Candidates work with fields, methods, initializers, constructors, scope, encapsulation, immutability, inheritance, polymorphism, interfaces and enumerations.
Skills tested
- Explain an object's lifecycle, from creation to dereferencing and garbage collection.
- Predict the order in which static and instance initializers and constructors run.
- Make a class immutable with private final fields and no setters.
- Tell an object's type from its reference type when methods are called through polymorphism.
- Use private, static and default methods in interfaces, and identify functional interfaces.
Questions by topic
- Utilize polymorphism and casting to call methods3
- Make objects immutable4
- Utilize private, static, and default methods4
- Create and use enumerations9
- Create and use subclasses and superclasses3
- Identify functional interfaces9
- Declare and instantiate Java objects4
- Utilize polymorphism and casting9
Exception Handling18 questions
This domain covers how a program reacts when something fails. Candidates handle exceptions with try/catch/finally, try-with-resources and multi-catch statements, and they create custom exceptions.
Skills tested
- Write try-with-resources blocks and predict the order in which resources close.
- Catch several exception types in one multi-catch block.
- Create custom exceptions by extending Exception or RuntimeException.
Questions by topic
- Use try-with-resources5
- Create and use custom exceptions6
- Handle exceptions using try/catch/finally clauses6
- Use multi-catch statements1
Working with Arrays and Collections16 questions
This domain covers how Java stores groups of objects. Candidates use generics with wildcards, arrays, and List, Set, Map and Deque collections, and sort them with Comparator and Comparable.
Skills tested
- Declare generic types and methods, including bounded wildcards.
- Choose between List, Set, Map and Deque for a given task.
- Sort arrays and collections with Comparable for natural ordering and Comparator for custom ordering.
Questions by topic
- Use List, Set, Map and Deque collections8
- Sort collections and arrays using Comparator and Comparable interfaces3
- Use generics, including wildcards5
Working with Streams and Lambda expressions20 questions
This domain covers functional-style Java. Candidates implement functional interfaces with lambda expressions, use streams to filter, transform and process data, and reduce, group and partition results on sequential and parallel streams.
Skills tested
- Implement interfaces from the java.util.function package with lambda expressions.
- Build stream pipelines with filter, map and flatMap operations.
- Group and partition data with collectors, on sequential and parallel streams.
- Reduce a stream to a single result with the reduce operation.
Questions by topic
- Perform decomposition and reduction5
- Use Java Streams to transform data9
- Implement functional interfaces using lambda expressions4
- Use Java Streams to process data2
Java Platform Module System11 questions
This domain covers how Java code is packaged as modules. Candidates deploy and run modular applications, including automatic modules, and declare, use and expose modules, including services.
Skills tested
- Write a module-info.java file with requires, exports and opens directives.
- Run a modular application from the module path, including automatic modules.
- Declare and use services with provides and uses directives.
Questions by topic
- Declare, use, and expose modules, including the use of services3
- Declare, use, and expose modules4
- Deploy and execute modular applications4
Concurrency13 questions
This domain covers code that runs on several threads at once. Candidates create worker threads with Runnable and Callable, manage them with an ExecutorService, and write thread-safe code with locks and the java.util.concurrent API.
Skills tested
- Submit Runnable and Callable tasks to an ExecutorService and read their Future results.
- Protect shared data with locks, atomic classes or concurrent collections.
Questions by topic
- Manage concurrency using an ExecutorService3
- Develop thread-safe code7
- Create worker threads using Runnable and Callable3
Java I/O API17 questions
This domain covers reading and writing data. Candidates use I/O streams for console and file data, serialize and deserialize objects, and handle files and directories with the java.nio.file API.
Skills tested
- Read and write console and file data with I/O streams.
- Serialize objects with ObjectOutputStream and restore them with ObjectInputStream.
- Create, copy, move and delete files with the Path and Files classes.
Questions by topic
- Handle file system objects using java.nio.file API5
- Implement serialization and deserialization techniques3
- Read and write console and file data9
Secure Coding in Java SE Application15 questions
This domain covers code that resists attack. Candidates mitigate threats such as denial of service and code injection, validate input, protect data integrity, secure access to resources such as files, and run privileged code.
Skills tested
- Validate input to block code injection.
- Make defensive copies so callers cannot change an object's internal state.
- Run privileged code and manage security policies for file system access.
Questions by topic
- Develop code that mitigates security threats12
- Secure resource access including filesystems2
- Manage policies and execute privileged code1
Database Applications with JDBC16 questions
This domain covers working with a database from Java. Candidates connect to a database, run SQL operations and process query results with the JDBC API.
Skills tested
- Open a Connection with DriverManager and a JDBC URL.
- Run queries and updates with PreparedStatement through executeQuery and executeUpdate.
- Read rows and columns from a ResultSet.
Questions by topic
- Connect to and perform database SQL operations10
- Process query results using JDBC API6
Localization15 questions
This domain covers programs that adapt to a user's language and region. Candidates use Locale, resource bundles and Java APIs to parse and format messages, dates and numbers.
Skills tested
- Create Locale objects from language and country codes.
- Load text from a ResourceBundle and predict which bundle Java chooses.
- Format numbers, dates and messages with NumberFormat, DateTimeFormatter and MessageFormat.
Questions by topic
- Parse and format messages, dates, and numbers6
- Use resource bundles8
- Implement Localization using Locale1
Annotations18 questions
This domain covers metadata that is attached to code. Candidates create annotation types, apply annotations to code, and process annotations to act on them.
Skills tested
- Declare an annotation type with @interface, with elements and default values.
- Choose a retention policy and targets for a custom annotation.
- Apply @FunctionalInterface and other built-in annotations correctly.
- Read annotations at runtime through reflection.
Questions by topic
- Create, apply, and process annotations18
Requirements
- No formal prerequisites: anyone can book the exam.
- Recommended: one to two years of Java development experience, to cover all of the objectives.
- Recommended: working knowledge of Java SE 11 features, lambda expressions and the module system.
About the 1Z0-819 exam
Java developers take Oracle's 1Z0-819 exam to show they can read and write Java SE 11 code at a professional level. Its thirteen topic areas run from data types and program flow to modules, concurrency, secure coding, JDBC, localization and annotations. Oracle publishes objectives for each area but no weights. A pass earns the Oracle Certified Professional: Java SE 11 Developer certification.
In the PlanetCert practice test, Java Object-Oriented Approach has the most questions, ahead of streams and lambdas, annotations and exception handling. Every answer comes with an explanation, which helps with code that looks correct but does not compile. Flashcard mode suits the many API names in the I/O, JDBC and localization domains. Brainy AI Assistant can explain why a stream pipeline returns a given result, or how the requires and exports lines in module-info.java fit together.
How to earn the certification
- Earns
- Oracle Certified Professional: Java SE 11 DeveloperProfessional
The Java SE 11 Developer certification does not expire.
How to prepare for 1Z0-819
- 1
Read Oracle's objectives line by line
Each objective names exact features, such as var in lambda parameters or services in modules. Turn the list into a checklist and write a short program for every line.
- 2
Compile small programs by hand
Use the javac and java commands without an IDE, so every compiler error stays visible. Predict each result before running the code, then work out why any guess was wrong.
- 3
Give objects and classes the most time
Java Object-Oriented Approach has the most objectives. Practise initialization order, polymorphism and casting, interface methods and enumerations until each rule fits in one sentence.
- 4
Build one modular, threaded app
Write a small application with two modules, a service and an ExecutorService that runs Callable tasks. Add file output with the Files class, so the project also touches the Java I/O API domain.
- 5
Practise by domain, then under time
Work through the 1Z0-819 practice test one domain at a time in Study Mode. Then take a full run in Timed Mode, and ask Brainy AI Assistant about any snippet whose output was a surprise.
Start a timed 1Z0-819run
Oracle recommends its Java SE 11 Developer learning path, part of the Oracle University learning subscription.
Who 1Z0-819 is for
- Java developers who build or maintain applications on Java 11.
- Programmers with one to two years of Java who want a professional Oracle certification.
- Development teams that run Java 11 in production and want a shared standard for their code.
Typical job titles: Java developer · Software engineer · Backend developer · Java programmer
1Z0-819 glossary
18 terms from the exam objectives and the vendor's official material, each defined in a sentence.
- Automatic modules
- Ordinary JAR files placed on the module path, which Java treats as modules with names taken from the JAR.
- Bounded wildcards
- Generic type arguments such as ? extends Number, which limit the types a method accepts.
- Checked exceptions
- Exceptions that the compiler forces code to catch or declare with throws, such as IOException.
- Comparable
- The interface that gives a class its natural ordering, through its compareTo method.
- Comparator
- An object that defines a sort order separate from the class itself, through its compare method.
- Deque
- A double-ended queue: a collection that can add and remove elements at both ends.
- ExecutorService
- An interface in java.util.concurrent that runs submitted tasks on threads it manages and returns Future objects for their results.
- Functional interfaces
- Interfaces with exactly one abstract method, which a lambda expression can implement.
- java.util.function package
- The package of ready-made functional interfaces, such as Predicate, Function, Supplier and Consumer.
- Local variable type inference
- Letting the compiler work out a local variable's type from its initial value, written with the var keyword.
- module-info.java
- The file that declares a module: its name, the modules it requires and the packages it exports.
- PreparedStatement
- A JDBC statement with ? placeholders for values, which also helps prevent SQL injection.
- Privileged code
- Code run through AccessController.doPrivileged, so a permission check stops at that code instead of checking its callers.
- ResourceBundle
- A set of locale-specific property files or classes from which a program loads translated text.
- Serialization
- Turning an object into bytes with ObjectOutputStream so it can be stored or sent, and later rebuilt.
- StringBuilder
- A class that holds changeable text, so a string can be built up without creating a new String object each time.
- try-with-resources
- A try statement that opens resources in its header and closes them automatically when the block ends.
- Wrapper classes
- Classes such as Integer and Double that hold a primitive value as an object, so it can be used in collections.