Java Optional: null ve NullPointerException'dan kaçınma

Optional'ın çözdüğü sorun

Bir cevabı olmayabilecek bir metot Java'da her zaman rahatsız edici bir seçeneğe sahipti: null döndürüp çağıran tarafın kontrol etmeyi hatırlamasını ummak. Genellikle hatırlamazlar ve sonuç, null döndüren metottan çok uzakta ortaya çıkan bir NullPointerException olur.

Optional<T>, ya bir değer içeren ya da açıkça boş olan küçük bir kutudur. Bir metot User yerine Optional<User> döndürerek çağıran tarafa, kendi imzasında "bu hiçbir şey bulmayabilir" der - ve derleyici onları bu durumu ele almaya yönlendirir.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> found = Optional.of("Ada");
        Optional<String> missing = Optional.empty();

        System.out.println(found.isPresent());   // true
        System.out.println(missing.isPresent());  // false
    }
}

Bir Optional oluşturma

Üç fabrika metodu var ve doğru olanı seçmek önemli:

• Optional.of(value) - değer null olmamalı, yoksa anında NullPointerException fırlatır.
• Optional.ofNullable(value) - değer null ise boş, aksi halde dolu. Null olabilecek bir şeyi sarmalamak için bunu kullan.
• Optional.empty() - boş bir optional.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        String maybeNull = System.getenv("DOES_NOT_EXIST");  // null döndürür

        Optional<String> safe = Optional.ofNullable(maybeNull);
        System.out.println(safe.isPresent());  // false, istisna yok

        // Optional.of(maybeNull) burada NullPointerException fırlatırdı
        Optional<String> sure = Optional.of("definitely here");
        System.out.println(sure.isPresent());  // true
    }
}

Yaygın bir hata, null olabilecek bir değer için Optional.of(x)'e başvurmaktır - bu amacı baltalar ve tam da kaçınmaya çalıştığın istisnayı fırlatır. Şüphedeysen ofNullable kullan.

Değeri güvenli okuma

Bir optional'ın elinde olduğunda amaç, değerin orada olduğunu varsaymadan onu dışarı çıkarmaktır. Kaba araç get()'tir ve onu neredeyse hiç kullanmamalısın:

Optional<String> name = Optional.empty();
String value = name.get();   // NoSuchElementException fırlatır - kılık değiştirmiş NPE

Bunun yerine bir yedek değer sağla veya varlığa tepki ver. orElse boşken bir varsayılan döndürür; ifPresent yalnızca bir değer var olduğunda kod çalıştırır:

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> name = Optional.of("Grace");
        Optional<String> blank = Optional.empty();

        System.out.println(name.orElse("anonymous"));   // Grace
        System.out.println(blank.orElse("anonymous"));  // anonymous

        name.ifPresent(n -> System.out.println("Hello, " + n));
        blank.ifPresent(n -> System.out.println("never prints"));
    }
}

Varsayılanı oluşturmak pahalıysa orElse yerine orElseGet(supplier) kullan - supplier yalnızca optional gerçekten boşsa çalışır. orElse'in argümanı, gerekmese bile her zaman değerlendirilir.

"Bu var olmalı" için orElseThrow

Bazen boş olmak gerçekten bir hatadır - zorunlu bir yapılandırma değeri, veritabanında olması gereken bir kullanıcı. orElseThrow, boş bir optional'ı seçtiğin net bir istisnaya dönüştürür:

import java.util.Optional;

public class Main {
    static Optional<Integer> parsePort(String raw) {
        try {
            return Optional.of(Integer.parseInt(raw));
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    }

    public static void main(String[] args) {
        int port = parsePort("8080")
            .orElseThrow(() -> new IllegalStateException("port must be a number"));
        System.out.println("listening on " + port);

        try {
            parsePort("nope")
                .orElseThrow(() -> new IllegalStateException("port must be a number"));
        } catch (IllegalStateException e) {
            System.out.println("caught: " + e.getMessage());
        }
    }
}

Bu, bir if (opt.isPresent()) bloğundan çok daha iyi okunur ve hatayı tam olduğu noktada açık hale getirir.

map ve filter ile dönüştürme

Asıl kazanç zincirlemededir. map, bir fonksiyonu değere yalnızca varsa uygular ve boş bir optional'ı boş bırakır - böylece bir null'a hiç dokunmadan dönüşüm yaparsın. filter, bir testi geçemezse değeri atar.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> raw = Optional.of("  Coddy  ");

        String result = raw
            .map(String::trim)          // "Coddy"
            .filter(s -> !s.isEmpty())  // yalnızca boş olmayanı tut
            .map(String::toUpperCase)   // "CODDY"
            .orElse("EMPTY");

        System.out.println(result);  // CODDY

        // Boş bir optional dokunulmadan akar - NPE yok, dallanma yok
        String none = Optional.<String>empty()
            .map(String::trim)
            .orElse("EMPTY");
        System.out.println(none);    // EMPTY
    }
}

Eşleme fonksiyonunun kendisi bir Optional döndürüyorsa, rahatsız edici bir Optional<Optional<T>>'den kaçınmak için map yerine flatMap kullan. Bu, stream'lerde gördüğün map/flatMap ayrımını yansıtır - bir Optional, sıfır veya bir elemanlı bir stream gibi davranır.

Optional nereye ait (ve nereye değil)

Optional, meşru biçimde sonuç üretmeyebilecek metotlar için bir dönüş tipi olarak tasarlanmıştır - klasik örnekler Stream.findFirst(), Map tarzı aramalar ve ayrıştırmadır. Onu orada kullan, API'n kendi boşluklarını belgelemiş olur.

Şunlar için tasarlanmamıştır:

• Alanlar. Serileştirilebilir değildir ve her alan için bir nesne ekler. Düz referanslar kullan ve yapıcıda doğrula.
• Metot parametreleri. O zaman çağıran tarafın argümanları Optional.of(...) içine sarması gerekir ki bu, bir aşırı yükleme veya null kabul eden bir parametreden daha gürültülüdür.
• Koleksiyonlar. Optional<List> değil, boş bir List döndür. Boş bir koleksiyon zaten "hiçbir şey" anlamına gelir.

Bir dönüş tipi olarak ele alındığında Optional, sessiz null hatalarını eksik durumu ele almaya yönelik derleme zamanı uyarılarına dönüştürür.

Sıradaki: İstisnalar

Optional, günlük "değer olmayabilir" durumunu temiz bir şekilde ele alır, ama bazı hatalar gerçekten istisnaidir - açılmayan bir dosya, kopan bir ağ, ayrıştırılamayan bir girdi. Java bunları istisnalarla modeller ve bu da bir sonraki sayfadır.