Java SE 8 Programmer II Exam

This page maps sections in the Java Tutorials to topics covered in the Java SE 8 Programmer II exam. This exam is associated with the Oracle Certified Professional, Java SE 8 Programmer certificate. The topics covered in this exam are:

  1. Java Class Design
  2. Advanced Class Design
  3. Generics and Collections
  4. Lambda Built-In Functional Interfaces
  5. Java Stream API
  6. Exceptions and Assertions
  7. Use Java SE 8 Date/Time API
  8. Java I/O Fundamentals
  9. Java File I/O (NIO.2)
  10. Concurrency
  11. Building Database Applications with JDBC
  12. Localization

Section 1: Java Class Design

Item 1: Implement encapsulation.

Item 2: Implement inheritance including visibility modifiers and composition.

Item 3: Implement polymorphism.

Item 4: Override hasCode, equals, and toString methods from Object class.

Item 5: Create and use singleton classes and immutable classes.

Item 6: Develop code that uses the static keyword on initialize blocks, variables, methods, and classes.

Section 2: Advanced Class Design

Item 1: Develop code that uses abstract classes and methods.

Item 2: Develop code that uses the final.

Item 3: Create inner classes including static inner classes, local classes, nested classes, and anonymous innter classes.

Item 4: Use enumerated types including methods, and constructors in an enum type

Item 5: Develop code that declares, implements and/or extends interfaces and use the @Override annotation.

Item 6: Create and use lambda expressions.

Section 3: Generics and Collections

The Generics (Updated) lesson, the Collections trail and, in particular, the specified pages.

Item 1: Create and use a generic class.

Item 2: Create and use ArrayList, TreeSet, TreeMap, and ArrayDeque objects.

Item 3: Use java.util.Comparator and java.lang.Comparable interfaces.

Item 4: Collections, streams, and filters.

Item 5: Iterate using forEach methods of Streams and List.

Item 6: Describe the Stream interface and the Stream pipeline.

Item 7: Filter a collection by using lambda expressions.

Item 8: Use method references with streams.

Section 4: Lambda Built-In Functional Interfaces

The sections Lambda Expressions and Aggregate Operations cover some of the following items:

Item 1: Use the built-in interfaces included in the java.util.function package such as Predicate, Consumer, Function, and Supplier.

Item 2: Develop code that uses primitive versions of functional interfaces.

Item 3: Develop code that uses binary versions of functional interfaces.

Item 4: Develop code that uses the UnaryOperator interface.

Section 5: Java Stream API

The sections Lambda Expressions and Aggregate Operations cover some of the following items:

Item 1: Develop code to extract data from an object using peek() and map() methods including primitive versions of the map() method.

Item 2: Search for data by using search methods of the Stream classes including findFirst, findAny, anyMatch, allMatch, noneMatch.

Item 3: Develop code that uses the Optional class.

Item 4: Develop code that uses Stream data methods and calculation methods.

Item 5: Sort a collection using Stream API.

Item 6: Save results to a collection using the collect method and group/partition data using the Collectors class.

Item 7: Use flatMap() methods in the Stream API.

Section 6: Exceptions and Assertions

Item 1: Use try-catch and throws statements.

Item 2: Use catch, multi-catch, and finally clauses.

Item 3: Use autoclose resources with a try-with-resources statement.

Item 4: Create custom exceptions and autocloseable resources.

Item 5: Test invariants by using assertions.

Section 7: Use Java SE 8 Date/Time API

Item 1: Create and manage date-based and time-based events including a combination of date and time into a single object using LocalDate, LocalTime, LocalDateTime, Instant, Period, and Duration.

Item 2: Work with dates and times across timezones and manage changes resulting from daylight savings including Format date and times values.

Item 3: Define and create and manage date-based and time-based events using Instant, Period, Duration, and TemporalUnit.

Section 8: Java I/O Fundamentals

Item 1: Read and write data from the console.

The I/O Streams lesson and, in particular, the following pages:

Item 2: Use BufferedReader, BufferedWriter, File, FileReader, FileWriter, FileInputStream, FileOutputStream, ObjectOutputStream, ObjectInputStream, and PrintWriter in the package.

The File I/O (Featuring NIO.2) lesson, and in particular, the following pages:

Section 9: Java File I/O (NIO.2)

Item 1: Use the Path interface to operate on file and directory paths.

Item 2: Use the Files class to check, read, delete, copy, move, and manage metadata a file or directory.

Item 3: Use Stream API with NIO.2.

Section 3: Object-Oriented Design Principles

The Java Tutorials do not cover Design Patterns topics. The following references cover design patterns using the Java programming language:

  • Head First Design Patterns by Elizabeth Freeman, et al.
  • Java Design Pattern Essentials by Tony Bevis

Item 1: Write code that declares, implements and/or extends interfaces.

Item 2: Choose between interface inheritance and class inheritance.

Item 3: Develop code that implements "is-a" and/or "has-a" relationships.

Item 4: Apply object composition principles.

Item 5: Design a class using the Singleton design pattern.

Item 6: Write code to implement the DAO pattern.

Item 7: Design and create objects using a factory, and use factories from the API.

Section 5: String Processing

Item 1: Search, parse and build strings.

Item 2: Search, parse, and replace strings by using regular expressions.

Item 3: Use string formatting.

Section 10: Concurrency

Item 1: Create worker threads using Runnable, Callable and use an ExecutorService to concurrently execute tasks.

Item 2: Identify potential threading problems among deadlock, starvation, livelock, and race conditions.

Item 3: Use synchronized keyword and java.util.concurrent.atomic package to control the order of thread execution.

Item 4: Use java.util.concurrent collections and classes including CyclicBarrier and CopyOnWriteArrayList.

Item 5: Use parallel Fork/Join Framework.

Item 6: Use parallel Streams including reduction, decomposition, merging processes, pipelines and performance.

Section 11: Building Database Applicatons with JDBC

Item 1: Describe the interfaces that make up the core of the JDBC API including the Driver, Connection, Statement, and ResultSet interfaces and their relationship to provider implementations.

Item 2: Identify the components required to connect to a database using the DriverManager class including the JDBC URL.

Item 3: Submit queries and read results from the database including creating statements, returning result sets, iterating through the results, and properly closing result sets, statements, and connections.

Section 12: Localization

Item 1: Read and set the locale by using the Locale object..

Item 2: Create and read a Properties file.

Item 3: Build a resource bundle for each locale and load a resource bundle in an application.