Devops Monk

// Java 7: what does null mean here?
public User findById(Long id) {
    // returns User, or null if not found
}

// Caller can easily forget the null check
User user = repo.findById(42L);
System.out.println(user.getName()); // NullPointerException if not found

// Java 8: the return type tells you "might not be present"
public Optional<User> findById(Long id) { ... }

// Caller cannot "forget" — they must handle the Optional
Optional<User> user = repo.findById(42L);
System.out.println(user.map(User::getName).orElse("unknown"));

// Empty optional
Optional<String> empty = Optional.empty();

// Optional with a non-null value — throws NullPointerException if value is null
Optional<String> present = Optional.of("Hello");

// Optional that may contain null — use this when you're not sure
Optional<String> nullable = Optional.ofNullable(someStringThatMightBeNull);

Optional<String> opt = Optional.of("Hello");

if (opt.isPresent()) {
    System.out.println(opt.get()); // "Hello"
}

String value = opt.get(); // throws NoSuchElementException if empty

String name = opt.orElse("unknown");

// createDefaultUser() is ALWAYS called, even when opt is present
User user = userOpt.orElse(createDefaultUser()); // potentially wasteful

// createDefaultUser() only called when optional is empty
User user = userOpt.orElseGet(() -> createDefaultUser());

// Method reference form
User user = userOpt.orElseGet(UserFactory::createDefault);

// Java 8: throws NoSuchElementException by default
User user = userOpt.orElseThrow();

// Custom exception
User user = userOpt.orElseThrow(() -> new UserNotFoundException(id));

Optional<String> name = userOpt.map(User::getName);
Optional<Integer> len  = name.map(String::length);

// Chain
Optional<String> city = userOpt
    .map(User::getAddress)
    .map(Address::getCity);

// User.getAddress() returns Optional<Address>
// Address.getCity() returns Optional<String>

// Without flatMap — gets Optional<Optional<String>>
Optional<Optional<String>> wrong = userOpt.map(u -> u.getAddress());

// With flatMap — flattens to Optional<String>
Optional<String> city = userOpt
    .flatMap(User::getAddress)       // Optional<Address>
    .flatMap(Address::getCity);      // Optional<String>

Optional<String> longName = nameOpt.filter(s -> s.length() > 5);
// If nameOpt is present but name.length() <= 5, returns empty
// If nameOpt is empty, returns empty

userOpt.ifPresent(user -> System.out.println("Found: " + user.getName()));

// Not available in Java 8, but worth knowing for reference
userOpt.ifPresentOrElse(
    user -> System.out.println("Found: " + user.getName()),
    ()   -> System.out.println("Not found")
);

if (userOpt.isPresent()) {
    System.out.println("Found: " + userOpt.get().getName());
} else {
    System.out.println("Not found");
}

List<Optional<User>> optionals = ids.stream()
    .map(repo::findById)
    .collect(Collectors.toList());

// Java 8: filter present, then map to value
List<User> users = optionals.stream()
    .filter(Optional::isPresent)
    .map(Optional::get)
    .collect(Collectors.toList());

// Java 9+: Optional.stream() — cleaner
List<User> users = optionals.stream()
    .flatMap(Optional::stream)
    .collect(Collectors.toList());

// WRONG
public class User {
    private Optional<String> middleName; // Don't do this
}

// RIGHT: use null for optional fields; Optional is for return types
public class User {
    private String middleName; // nullable

    public Optional<String> getMiddleName() {
        return Optional.ofNullable(middleName);
    }
}

// WRONG: forces callers to wrap values in Optional for no benefit
public void process(Optional<String> name) { ... }

// RIGHT: use overloading or @Nullable
public void process(String name) { ... }
public void process() { process(null); }

// WRONG: verbose null check
if (opt.isPresent()) {
    return opt.get().getName();
}
return "unknown";

// RIGHT: map + orElse
return opt.map(User::getName).orElse("unknown");

// WRONG: throws NullPointerException if value is null
Optional<String> opt = Optional.of(potentiallyNullValue);

// RIGHT
Optional<String> opt = Optional.ofNullable(potentiallyNullValue);

// WRONG: adds overhead with no benefit
public Optional<List<Order>> getOrders() {
    return Optional.of(this.orders); // orders is always initialised
}

// RIGHT: return empty list (null object pattern) or plain reference
public List<Order> getOrders() {
    return Collections.unmodifiableList(this.orders);
}

public interface UserRepository {
    Optional<User> findById(Long id);
    Optional<User> findByEmail(String email);
    List<User> findAll(); // never absent — return empty list, not Optional<List>
}

public String getUserCity(Long userId) {
    return userRepository.findById(userId)
        .flatMap(User::getAddress)
        .map(Address::getCity)
        .orElse("Unknown");
}

public User getOrCreateUser(String email) {
    return userRepository.findByEmail(email)
        .orElseGet(() -> createNewUser(email));
}

// Try primary source, then cache, then default
String config = primaryConfig()
    .or(() -> cachedConfig())     // Java 9+
    .orElseGet(() -> defaultConfig());

// Java 8 equivalent:
Optional<String> cfg = primaryConfig();
if (!cfg.isPresent()) cfg = cachedConfig();
String config = cfg.orElseGet(() -> defaultConfig());