Зачем нужен Optional

// Old way — null return invites NPE
static String findEmail(int userId) {
    if (userId == 1) return "alice@example.com";
    return null; // caller might forget to check!
}

String email = findEmail(99);
System.out.println(email.toUpperCase()); // NullPointerException!

import java.util.Optional;

static Optional<String> findEmail(int userId) {
    if (userId == 1) return Optional.of("alice@example.com");
    return Optional.empty();
}

// Caller must handle the Optional
Optional<String> result = findEmail(99);
if (result.isPresent()) {
    System.out.println(result.get().toUpperCase());
} else {
    System.out.println("User not found");
}

// WRONG: Optional as field
class User {
    private Optional<String> nickname; // bad practice
}

// WRONG: Optional as parameter
void save(Optional<String> name) {} // just use overloading

// CORRECT: Optional only as return type
static Optional<User> findById(long id) {
    // returns Optional.empty() if not found
    return database.findById(id);
}

// Good use of Optional: user might not exist
static Optional<User> findUser(String email) { ... }

// Good use of exception: invalid operation
static User createUser(String email) {
    if (!email.contains("@"))
        throw new IllegalArgumentException("Invalid email");
    // ...
}

// Rule of thumb:
// Optional = absence is a normal, expected outcome
// Exception = something went wrong that should not happen

import java.util.*;
import java.util.stream.*;

List<String> ids = List.of("user:1", "cache:miss", "user:2");

// BAD: List<Optional<User>>
// GOOD: filter optionals out of streams
List<String> users = ids.stream()
    .map(id -> id.startsWith("user:") ? Optional.of(id) : Optional.<String>empty())
    .flatMap(Optional::stream) // Java 9+: flatMap empty optionals
    .collect(Collectors.toList());
System.out.println(users); // [user:1, user:2]

import java.util.*;

interface UserRepository {
    Optional<User> findById(long id);
    Optional<User> findByEmail(String email);
    List<User> findAll(); // no Optional — returns empty list if none
}

record User(long id, String name, String email) {}

// The caller sees immediately that the result might be absent
UserRepository repo = /* inject */;
repo.findByEmail("alice@example.com")
    .ifPresentOrElse(
        u -> System.out.println("Found: " + u.name()),
        () -> System.out.println("Not found")
    );

import java.util.*;
import java.util.stream.*;

List<Optional<String>> maybeNames = List.of(
    Optional.of("Alice"),
    Optional.empty(),
    Optional.of("Bob"),
    Optional.empty(),
    Optional.of("Charlie")
);

List<String> present = maybeNames.stream()
    .flatMap(Optional::stream) // Java 9+
    .collect(Collectors.toList());
System.out.println(present); // [Alice, Bob, Charlie]

import java.util.Optional;

String name = null;

// Optional.of(null) throws NullPointerException!
try {
    Optional<String> bad = Optional.of(name);
} catch (NullPointerException e) {
    System.out.println("NPE from Optional.of(null)");
}

// Optional.ofNullable(null) returns empty safely
Optional<String> safe = Optional.ofNullable(name);
System.out.println(safe.isPresent()); // false
System.out.println(safe.isEmpty());   // true (Java 11+)

// In hot loops (millions/second), null check might be preferred:
// String result = findFastPath(id); // returns null or value
// if (result != null) use(result);

// For typical service/repository code:
// Optional<String> result = findValue(id);
// result.ifPresent(v -> use(v));

// Modern JVMs are good at escape analysis — many Optional allocations
// are stack-allocated and cause no heap pressure.

// Java's Optional was inspired by functional languages:
// Haskell's Maybe, Scala's Option, Rust's Option<T>

// The goal: make the type system express that absence is possible
// Instead of relying on documentation or developer vigilance

// Before Optional:
// String email = user.getEmail(); // is this null? Check the docs!

// With Optional:
// Optional<String> email = user.getEmail(); // type says: might be absent