Optional ב-Java: להימנע מ-null ומ-NullPointerException

הבעיה ש-Optional פותר

למתודה שייתכן שאין לה תשובה תמיד הייתה ב-Java בחירה מביכה: להחזיר null ולקוות שהקורא יזכור לבדוק. בדרך כלל הוא לא זוכר, והתוצאה היא NullPointerException שצצה רחוק מהמתודה שהחזירה את ה-null.

Optional<T> הוא קופסה קטנה שמכילה ערך או שהיא ריקה באופן מפורש. כשמתודה מחזירה Optional<User> במקום User, היא אומרת לקוראים "ייתכן שלא אמצא כלום" ישירות בחתימה שלה, והמהדר מכוון אותם לטפל במקרה הזה.

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
    }
}

יצירת Optional

יש שלוש מתודות יצירה, ובחירת הנכונה חשובה:

• Optional.of(value): הערך חייב להיות לא null, אחרת היא זורקת NullPointerException במקום.
• Optional.ofNullable(value): ריק אם הערך הוא null, עם ערך אחרת. השתמשו בה כדי לעטוף משהו שעשוי להיות null.
• Optional.empty(): Optional ריק.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        String maybeNull = System.getenv("DOES_NOT_EXIST");  // מחזיר null

        Optional<String> safe = Optional.ofNullable(maybeNull);
        System.out.println(safe.isPresent());  // false, בלי חריגה

        // Optional.of(maybeNull) היה זורק כאן NullPointerException
        Optional<String> sure = Optional.of("definitely here");
        System.out.println(sure.isPresent());  // true
    }
}

טעות נפוצה היא להשתמש ב-Optional.of(x) על ערך שעלול להיות null: זה מבטל את כל המטרה וזורק בדיוק את החריגה שניסיתם להימנע ממנה. כשיש ספק, השתמשו ב-ofNullable.

קריאת הערך בבטחה

אחרי שיש Optional, המטרה היא להוציא את הערך בלי להניח שהוא שם. הכלי הגס הוא get(), וכמעט אף פעם לא כדאי להשתמש בו:

Optional<String> name = Optional.empty();
String value = name.get();   // זורק NoSuchElementException: פשוט NPE בתחפושת

במקום זה, ספקו ערך חלופי או הגיבו לקיום הערך. orElse מחזירה ברירת מחדל כשהוא ריק; ifPresent מריצה קוד רק כשיש ערך:

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"));
    }
}

השתמשו ב-orElseGet(supplier) במקום orElse כשבניית ברירת המחדל יקרה: ה-supplier רץ רק אם ה-Optional באמת ריק. הארגומנט של orElse תמיד מחושב, גם כשאין בו צורך.

orElseThrow עבור "זה אמור להיות קיים"

לפעמים ריק הוא באמת שגיאה: ערך הגדרה חובה, משתמש שאמור להיות במסד הנתונים. orElseThrow הופכת Optional ריק לחריגה ברורה לבחירתכם:

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());
        }
    }
}

זה נקרא הרבה יותר טוב מבלוק if (opt.isPresent()), והופך את הכישלון למפורש בנקודה שבה הוא קורה.

המרה עם map ו-filter

התמורה האמיתית היא בשרשור. map מפעילה פונקציה על הערך רק אם הוא קיים ומשאירה Optional ריק ריק, כך שממירים בלי לגעת אף פעם ב-null. filter משמיטה את הערך אם הוא לא עובר בדיקה.

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())  // משאירים רק ערך לא ריק
            .map(String::toUpperCase)   // "CODDY"
            .orElse("EMPTY");

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

        // Optional ריק עובר בלי שינוי: בלי NPE, בלי הסתעפויות
        String none = Optional.<String>empty()
            .map(String::trim)
            .orElse("EMPTY");
        System.out.println(none);    // EMPTY
    }
}

אם פונקציית ההמרה עצמה מחזירה Optional, השתמשו ב-flatMap במקום map כדי להימנע מ-Optional<Optional<T>> מסורבל. זה משקף את ההבחנה בין map ל-flatMap שראיתם ב-streams: Optional מתנהג כמו stream של אפס או איבר אחד.

איפה Optional מתאים (ואיפה לא)

Optional תוכנן כטיפוס החזרה של מתודות שעשויות באופן לגיטימי לא להפיק תוצאה: הדוגמאות הקלאסיות הן Stream.findFirst(), חיפושים בסגנון Map ופענוח קלט. השתמשו בו שם, וה-API שלכם יתעד בעצמו את החורים שלו.

הוא לא נועד ל:

• שדות. הוא לא ניתן לסריאליזציה ומוסיף אובייקט לכל שדה. השתמשו בהפניות רגילות ובדקו אותן בבנאי.
• פרמטרים של מתודות. הקוראים יצטרכו לעטוף ארגומנטים ב-Optional.of(...), וזה רועש יותר מהעמסה או מפרמטר שיכול להיות null.
• אוספים. החזירו List ריקה, לא Optional<List>. אוסף ריק כבר אומר "כלום".

כשמשתמשים בו כטיפוס החזרה, Optional הופך באגים שקטים של null לתזכורות בזמן קומפילציה לטפל במקרה החסר.

הבא: חריגות

Optional מטפל בצורה נקייה במקרה היומיומי של "ייתכן שאין ערך", אבל חלק מהכשלים חריגים באמת: קובץ שלא נפתח, רשת שנופלת, קלט שאי אפשר לפענח. Java מייצגת אותם בעזרת חריגות (exceptions), וזה העמוד הבא.