Java Optional完全ガイド：5つの活用法で nullの不安から解放される

// 非null値でOptionalを作成
Optional<String> optional = Optional.of("Hello");

// nullの可能性がある値でOptionalを作成
Optional<String> nullableOptional = Optional.ofNullable(nullableName);

// 空のOptionalを作成
Optional<String> empty = Optional.empty();

// 値が存在する場合の処理
optional.ifPresent(value -> System.out.println("Value: " + value));

// デフォルト値を設定
String result = optional.orElse("Default");

// 値が存在しない場合に例外をスロー
String value = optional.orElseThrow(() -> new NoSuchElementException());

// 従来のnullチェック
if (name != null) {
    System.out.println(name.toUpperCase());
} else {
    System.out.println("Name is null");
}

// Optionalを使用した方法
Optional.ofNullable(name)
    .map(String::toUpperCase)
    .ifPresentOrElse(
        System.out::println,
        () -> System.out.println("Name is null")
    );

Optional.of(value)：非nullの値でOptionalを作成します。

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

注意：nullを渡すとNullPointerExceptionが発生します。

Optional.ofNullable(value)：nullの可能性がある値でOptionalを作成します。

   String nullableValue = getValueFromSomewhere();
   Optional<String> opt = Optional.ofNullable(nullableValue);

isPresent()：Optionalが値を持っているかをboolean値で返します。

   if (opt.isPresent()) {
       System.out.println("Value is present: " + opt.get());
   }

ifPresent(Consumer<? super T> consumer)：値が存在する場合に指定された処理を実行します。

   opt.ifPresent(value -> System.out.println("Value: " + value));

orElse(T other)：値が存在しない場合にデフォルト値を返します。

   String result = opt.orElse("Default");

orElseGet(Supplier<? extends T> supplier)：値が存在しない場合に関数を実行してデフォルト値を取得します。

   String result = opt.orElseGet(() -> computeDefaultValue());

map(Function<? super T, ? extends U> mapper)：値が存在する場合に変換を適用し、新しいOptionalを返します。

   Optional<Integer> length = opt.map(String::length);

flatMap(Function<? super T, Optional<U>> mapper)：値が存在する場合に変換を適用し、結果のOptionalをフラット化します。

   Optional<String> upper = opt.flatMap(this::toUpperCase);

   private Optional<String> toUpperCase(String s) {
       return Optional.ofNullable(s).map(String::toUpperCase);
   }

Optional<String> filtered = opt.filter(s -> s.length() > 5);

public Optional<String> processName(String input) {
    return Optional.ofNullable(input)
        .map(String::trim)
        .filter(s -> !s.isEmpty())
        .map(String::toUpperCase)
        .flatMap(this::addPrefix);
}

private Optional<String> addPrefix(String name) {
    return Optional.of("Mr. " + name);
}

// 使用例
processName("  john  ")
    .ifPresent(System.out::println);  // 出力: Mr. JOHN

processName("")
    .orElse("No name provided");  // 出力: No name provided

// 従来の方法
public String findUserName(int id) {
    // ユーザーが見つからない場合はnullを返す
    // ...
}

// Optionalを使用した方法
public Optional<String> findUserName(int id) {
    // ユーザーが見つからない場合はOptional.empty()を返す
    // ...
}

findUserName(123).ifPresentOrElse(
    name -> System.out.println("User found: " + name),
    () -> System.out.println("User not found")
);

List<User> users = getUserList();
List<String> validUserNames = users.stream()
    .map(User::getEmail)
    .filter(Optional::isPresent)
    .map(Optional::get)
    .filter(email -> email.contains("@"))
    .map(email -> email.split("@")[0])
    .collect(Collectors.toList());

List<Optional<String>> optionalList = Arrays.asList(
    Optional.of("apple"),
    Optional.empty(),
    Optional.of("banana")
);

List<String> result = optionalList.stream()
    .flatMap(Optional::stream)
    .collect(Collectors.toList());

System.out.println(result);  // 出力: [apple, banana]

この例では、Optional::streamを使用することで、存在する値のみを簡単に取り出すことができます。

// 悪い例
public class User {
    private Optional<String> middleName; // 推奨されない
}

// 良い例
public class User {
    private String middleName; // nullを許容

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

// 悪い例
public void processUser(Optional<User> user) { ... }

// 良い例
public void processUser(User user) { ... }
public void processUserIfPresent(User user) { ... } // userがnullの場合は何もしない

// 悪い例
Optional<String> name = getNameOptional();
String result = name.get(); // 危険：NoSuchElementExceptionの可能性あり

// 良い例
String result = name.orElse("Default Name");
// または
String result = name.orElseThrow(() -> new CustomException("Name not found"));

Optional<Optional<String>> nested = Optional.of(Optional.of("value"));

flatMap()を使用して平坦化する

Optional<String> result = nested.flatMap(opt -> opt);

map()を使用して内部のOptionalを処理する

Optional<String> result = nested.map(opt -> opt.orElse("default"));

設計を見直し、ネストが必要ない方法を検討する

// ネストの代わりに
public Optional<String> findValue() {
    String value = // 値を取得する処理
    return Optional.ofNullable(value);
}

// Java 11以降
if (optional.isEmpty()) {
    // Optionalが空の場合の処理
}

// Java 8-10 (または11以降でも使用可能)
if (!optional.isPresent()) {
    // Optionalが空の場合の処理
}

public String getUserName(int id) throws UserNotFoundException {
    return userRepository.findById(id)
        .map(User::getName)
        .orElseThrow(() -> new UserNotFoundException("User not found with id: " + id));
}

値が存在する場合のテスト

@Test
void testPresentValue() {
    Optional<String> optional = Optional.of("test");
    assertTrue(optional.isPresent());
    assertEquals("test", optional.get());
}

@Test
void testEmptyOptional() {
    Optional<String> optional = Optional.empty();
    assertTrue(optional.isEmpty()); // Java 11以降
    assertFalse(optional.isPresent()); // すべてのバージョン
}

@Test
void testOrElseThrow() {
    Optional<String> optional = Optional.empty();
    assertThrows(NoSuchElementException.class, () -> optional.orElseThrow());
}

public static void assertOptionalContains(Optional<?> optional, Object expected) {
    assertTrue(optional.isPresent(), "Optional should be present");
    assertEquals(expected, optional.get(), "Optional value should match expected");
}

import static org.assertj.core.api.Assertions.*;

@Test
void testOptionalWithAssertJ() {
    Optional<String> optional = Optional.of("test");
    assertThat(optional)
        .isPresent()
        .hasValue("test");
}

Optionalを活用し、nullの不安のない、美しいコードの世界へ踏み出しましょう。