Java Lambda: ביטויי למבדה וקוד פונקציונלי תמציתי

התנהגות שאפשר להעביר הלאה

ביטוי lambda הוא גוש קוד קומפקטי שאפשר למסור למתודה, לשמור במשתנה או להחזיר, בדיוק כמו מספר או מחרוזת. לפני שהיו ביטויי lambda, העברת התנהגות חייבה לכתוב מחלקה שלמה (או מחלקה אנונימית מסורבלת) רק כדי לעטוף מתודה אחת. lambda מזקקת את זה לעיקר: הפרמטרים והגוף.

lambda תמיד מממשת ממשק פונקציונלי: ממשק עם מתודה מופשטת אחת בדיוק (פגשתם אותם בסוף העמוד על ממשקים). הקומפיילר מבין מההקשר לאיזה ממשק התכוונתם ומתאים את ה-lambda למתודה היחידה הזו.

interface Transformer {
    int apply(int x);
}

public class Main {
    public static void main(String[] args) {
        Transformer doubler = x -> x * 2;       // מממשת את apply(int)
        Transformer square  = x -> x * x;

        System.out.println(doubler.apply(21));  // 42
        System.out.println(square.apply(9));     // 81
    }
}

x -> x * 2 הוא כל המימוש של apply. אין new, אין גוף מחלקה, אין שם מתודה: הממשק מספק את כל אלה.

תחביר החץ

לכל lambda יש את הצורה parameters -> body. החלקים משתנים לפי מה שצריך:

() -> 42                       // בלי פרמטרים
x -> x + 1                     // פרמטר אחד, הסוגריים אופציונליים
(x, y) -> x + y                // שניים או יותר פרמטרים צריכים סוגריים
(int x, int y) -> x + y        // הטיפוסים אופציונליים: בדרך כלל הם מוסקים
x -> {                          // גוף של בלוק צריך סוגריים מסולסלים ו-return
    int doubled = x * 2;
    return doubled + 1;
}

גוף שהוא ביטוי יחיד (x -> x + 1) מחזיר את הערך שלו באופן מובלע, בלי מילת המפתח return. ברגע שמשתמשים בסוגריים מסולסלים, כותבים בלוק רגיל וחייבים לכתוב return במפורש אם המתודה מחזירה משהו. טעות נפוצה היא לערבב בין השניים: x -> { x + 1 } לא מתקמפל, כי בלוק צריך פקודה (return x + 1;).

lambda במקום מחלקות אנונימיות

הדרך הברורה ביותר לראות מה lambda נותנת היא לפני ואחרי. מיון עם Comparator מותאם אישית נראה פעם ככה:

// לפני: מחלקה אנונימית
names.sort(new Comparator<String>() {
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
});

אותו דבר כ-lambda הוא שורה אחת קריאה:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("Charlie", "Bo", "Alex"));

        names.sort((a, b) -> a.length() - b.length());   // אחרי: lambda

        System.out.println(names);   // [Bo, Alex, Charlie]
    }
}

Comparator הוא ממשק פונקציונלי (המתודה המופשטת היחידה שלו היא compare), אז ה-lambda נכנסת ישר למקום. כל הטקס, ה-new, המחלקה, חתימת המתודה, נעלם, ונשארת רק לוגיקת ההשוואה.

ארגז הכלים של java.util.function

כמעט אף פעם לא צריך להצהיר על ממשק פונקציונלי משלכם. החבילה java.util.function מגיעה עם הצורות הנפוצות, וכמעט כל ממשקי הספרייה של Java מקבלים אותן:

• Function<T, R>: מקבלת T, מחזירה R (apply)
• Predicate<T>: מקבלת T, מחזירה boolean (test)
• Supplier<T>: לא מקבלת כלום, מחזירה T (get)
• Consumer<T>: מקבלת T, לא מחזירה כלום (accept)

import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Function<String, Integer> length = s -> s.length();
        Predicate<Integer> isEven        = n -> n % 2 == 0;
        Supplier<String> greeting        = () -> "hello";

        System.out.println(length.apply("lambda"));   // 6
        System.out.println(isEven.test(10));           // true
        System.out.println(greeting.get());            // hello
    }
}

אלה ממשקים גנריים: Function<String, Integer> משתמש שוב ב-generics שראיתם בעמוד הקודם כדי לשמור על בטיחות טיפוסים. בחרו את הממשק שהצורה שלו מתאימה למה שהקוד שלכם צריך לקבל ולהפיק.

הפניות למתודות

כש-lambda לא עושה כלום חוץ מלקרוא למתודה קיימת אחת, אפשר להחליף אותה בהפניה למתודה עם ::. זה אותו ערך, כתוב בצורה ישירה יותר:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>(List.of("pear", "fig", "apple", "kiwi"));

        // lambda:           s -> s.toUpperCase()
        // הפניה למתודה: String::toUpperCase
        words.replaceAll(String::toUpperCase);
        System.out.println(words);   // [PEAR, FIG, APPLE, KIWI]

        // מיון לפי אורך בעזרת עזר סטטי בתור Comparator
        words.sort((a, b) -> Integer.compare(a.length(), b.length()));
        System.out.println(words);   // [FIG, PEAR, KIWI, APPLE]
    }
}

להפניות למתודות יש כמה סוגים: String::toUpperCase (מתודת מופע שנקראת על כל ארגומנט), Math::max (מתודה סטטית), System.out::println (מתודה על אובייקט מסוים) ו-ArrayList::new (בנאי). השתמשו בהן רק כשהן נקראות בבירור: אם צריך לחשוב איזו צורה מתאימה, lambda רגילה זה בסדר גמור.

לכידת משתנים

lambda יכולה להשתמש במשתנים מקומיים מהמתודה שסביבה, אבל רק אם הם final או effectively final: הושמו פעם אחת ולא השתנו לעולם. Java לוכדת את הערך ברגע שה-lambda נוצרת, ולכן משתנה שעלול להשתנות אחר כך היה דו-משמעי.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        int factor = 3;                          // לא מושם מחדש אף פעם -> effectively final
        Function<Integer, Integer> scale = n -> n * factor;

        System.out.println(scale.apply(10));     // 30
        // factor = 4;   // <- ביטול ההערה כאן שובר את ה-lambda שלמעלה
    }
}

אם תשימו ערך חדש ב-factor במקום כלשהו, הקומפיילר ידחה את ה-lambda עם "variable used in lambda expression should be final or effectively final". כשבאמת צריך מצב משותף שמשתנה, לכדו אובייקט במקום: שדה, איבר של מערך או AtomicInteger, כי ההפניה נשארת קבועה גם כשהתוכן שלה משתנה. שימו לב שביטויי lambda, בניגוד למחלקות אנונימיות, לא יוצרים scope משלהם: this בתוך lambda מתייחס למופע העוטף, לא ל-lambda עצמה.

הבא בתור: Streams

ביטויי lambda הם אבן הבניין, לא היעד. התמורה האמיתית שלהם מגיעה עם ה-Streams API, שבו משרשרים פעולות כמו filter, map ו-reduce, שכל אחת מהן מקבלת lambda, כדי לבטא טרנספורמציות של נתונים כצינור קריא במקום סבך של לולאות. זה העמוד הבא.