OCP Java SE
1 Java Fundamentals
1.1 Introduction to Java
1.1 1 History and Evolution of Java
1.1 2 Java Platform Overview
1.1 3 Java Virtual Machine (JVM)
1.1 4 Java Development Kit (JDK)
1.1 5 Java Runtime Environment (JRE)
1.2 Java Language Basics
1.2 1 Data Types and Variables
1.2 2 Operators and Expressions
1.2 3 Control Flow Statements
1.2 4 Arrays and ArrayLists
1.2 5 Methods and Method Overloading
1.3 Object-Oriented Programming (OOP)
1.3 1 Classes and Objects
1.3 2 Inheritance and Polymorphism
1.3 3 Encapsulation and Abstraction
1.3 4 Interfaces and Abstract Classes
1.3 5 Nested Classes
1.4 Exception Handling
1.4 1 Exception Types
1.4 2 Try-Catch-Finally Blocks
1.4 3 Custom Exceptions
1.4 4 Exception Propagation
1.5 Java Collections Framework
1.5 1 Collection Interfaces
1.5 2 List, Set, and Map Implementations
1.5 3 Iterator and ListIterator
1.5 4 Comparable and Comparator
1.5 5 Collections Utility Class
2 Advanced Java Concepts
2.1 Generics and Collections
2.1 1 Generic Classes and Methods
2.1 2 Bounded Type Parameters
2.1 3 Wildcards
2.1 4 Collections Framework Enhancements
2.2 Concurrency
2.2 1 Threads and Runnable
2.2 2 Thread States and Life Cycle
2.2 3 Synchronization and Locks
2.2 4 Concurrent Collections
2.2 5 Executors and Thread Pools
2.3 IO Streams and File Handling
2.3 1 Input and Output Streams
2.3 2 File and Directory Operations
2.3 3 Serialization and Deserialization
2.3 4 NIO 2 File System API
2.4 Networking
2.4 1 TCPIP and UDP Protocols
2.4 2 Socket Programming
2.4 3 URL and URLConnection
2.4 4 HTTP Client API
2.5 JDBC (Java Database Connectivity)
2.5 1 Database Connectivity Basics
2.5 2 Connection, Statement, and ResultSet
2.5 3 PreparedStatement and CallableStatement
2.5 4 Transaction Management
2.5 5 Connection Pooling
3 Java 8 Features
3.1 Lambda Expressions
3.1 1 Syntax and Usage
3.1 2 Functional Interfaces
3.1 3 Method References
3.2 Stream API
3.2 1 Stream Creation and Operations
3.2 2 Intermediate and Terminal Operations
3.2 3 Parallel Streams
3.3 Date and Time API
3.3 1 LocalDate, LocalTime, and LocalDateTime
3.3 2 Period and Duration
3.3 3 Time Zones and Daylight Saving
3.4 Optional Class
3.4 1 Introduction to Optional
3.4 2 Creating and Using Optional
3.4 3 Handling Null Values
3.5 Default and Static Methods in Interfaces
3.5 1 Default Methods
3.5 2 Static Methods
3.5 3 Multiple Inheritance Issues
4 Java 9 and Beyond
4.1 Modular Programming with Jigsaw
4.1 1 Introduction to Modules
4.1 2 Module Declaration and Dependencies
4.1 3 Services and Service Providers
4.2 Enhanced Java 9 Features
4.2 1 JShell: The Java REPL
4.2 2 Factory Methods for Collections
4.2 3 Process API Updates
4.3 Java 10 and 11 Features
4.3 1 Local-Variable Type Inference
4.3 2 HTTP Client API (Standard)
4.3 3 Garbage Collector Interface
4.4 Java 12 and 13 Features
4.4 1 Switch Expressions (Preview)
4.4 2 Text Blocks (Preview)
4.4 3 Enhanced Switch Statements
4.5 Java 14 and 15 Features
4.5 1 Pattern Matching for instanceof
4.5 2 Records (Preview)
4.5 3 Sealed Classes (Preview)
5 Best Practices and Advanced Topics
5.1 Design Patterns
5.1 1 Creational Patterns
5.1 2 Structural Patterns
5.1 3 Behavioral Patterns
5.2 Performance Tuning
5.2 1 Memory Management and Garbage Collection
5.2 2 Profiling and Monitoring Tools
5.2 3 Optimization Techniques
5.3 Security
5.3 1 Java Security Model
5.3 2 Cryptography and Encryption
5.3 3 Secure Coding Practices
5.4 Internationalization and Localization
5.4 1 Resource Bundles
5.4 2 Locale and Formatting
5.4 3 Character Encoding
5.5 Testing and Debugging
5.5 1 Unit Testing with JUnit
5.5 2 Mocking with Mockito
5.5 3 Debugging Techniques and Tools
6 Exam Preparation and Strategies
6.1 Exam Objectives and Structure
6.1 1 Overview of Exam Topics
6.1 2 Question Types and Formats
6.1 3 Time Management Strategies
6.2 Practice Exams and Simulations
6.2 1 Sample Questions and Answers
6.2 2 Mock Exams and Assessments
6.2 3 Review and Analysis of Results
6.3 Study Tips and Resources
6.3 1 Recommended Study Materials
6.3 2 Online Courses and Tutorials
6.3 3 Community Forums and Discussion Groups
6.4 Certification Process
6.4 1 Registration and Scheduling
6.4 2 Exam Day Preparation
6.4 3 Post-Exam Actions and Results
3 2 2 Intermediate and Terminal Operations Explained

2 2 Intermediate and Terminal Operations Explained

Intermediate and terminal operations are fundamental concepts in the Java Stream API. Understanding these operations is crucial for effectively processing collections of data in a functional style. This guide will delve into the key concepts, provide detailed explanations, and offer examples to enhance your understanding.

Key Concepts

1. Intermediate Operations

Intermediate operations transform a stream into another stream. They are lazy, meaning they do not process the elements until a terminal operation is invoked. Common intermediate operations include filter, map, and flatMap.

2. Terminal Operations

Terminal operations produce a non-stream result, such as a primitive value, a collection, or no value at all. They trigger the processing of elements in the stream. Common terminal operations include forEach, collect, and reduce.

Detailed Explanation

1. Intermediate Operations

Intermediate operations allow you to perform various transformations on the stream elements. They return a new stream that can be further processed by other intermediate or terminal operations.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class IntermediateOperationsExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        List<String> filteredNames = names.stream()
                                           .filter(name -> name.startsWith("A"))
                                           .map(String::toUpperCase)
                                           .collect(Collectors.toList());

        filteredNames.forEach(System.out::println);
    }
}
    

2. Terminal Operations

Terminal operations are the final step in a stream pipeline. They produce a result or a side-effect. Once a terminal operation is invoked, the stream cannot be reused.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class TerminalOperationsExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        int sum = numbers.stream()
                         .filter(n -> n % 2 == 0)
                         .mapToInt(Integer::intValue)
                         .sum();

        System.out.println("Sum of even numbers: " + sum);
    }
}
    

Examples and Analogies

Intermediate Operations

Think of intermediate operations as stages in a production line. Each stage processes the product (stream element) and passes it to the next stage. The final product is only assembled when the production line reaches the end (terminal operation).

Terminal Operations

Think of terminal operations as the final packaging and shipping of a product. Once the product is packaged (terminal operation is invoked), it is ready for delivery (result is produced), and the production line cannot be reused for the same product.