Streams ב-Java: הסבר על filter, map, collect ו-reduce

צינורות במקום לולאות

Stream הוא צינור לעיבוד רצף של ערכים. מתחילים ממקור, בדרך כלל אוסף, משרשרים פעולות כמו "השאר רק את אלה", "המר כל אחד", "מיין אותם", ומסיימים באיסוף התוצאה. במקום לכתוב לולאה עם רשימה זמנית ו-if בפנים, מתארים מה רוצים ונותנים ל-stream לעשות את המעבר.

עכשיו כשיש לכם lambdas, streams נופלים למקום: כל פעולה מקבלת lambda (או method reference) שמתארת את העבודה עבור איבר אחד.

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> names = List.of("Ada", "Boris", "Chen", "Dmitri");

        List<String> result = names.stream()
            .filter(name -> name.length() > 3)   // משאירים שמות ארוכים מ-3 תווים
            .map(String::toUpperCase)            // ממירים כל אחד
            .collect(Collectors.toList());       // אוספים לרשימה חדשה

        System.out.println(result);
    }
}

קראו מלמעלה למטה: קחו את השמות, השאירו את הארוכים, הפכו לאותיות גדולות, אספו לרשימה. הרשימה המקורית names לא משתנה אף פעם: stream מפיק תוצאה חדשה ומשאיר את המקור בשקט.

האנטומיה של stream

לכל צינור יש שלושה חלקים:

• מקור: list.stream(), Arrays.stream(array) או Stream.of(a, b, c).
• אפס או יותר פעולות ביניים: filter, map, sorted, distinct, limit. כל אחת מחזירה stream נוסף, ולכן אפשר לשרשר אותן.
• בדיוק פעולה סופית אחת: collect, count, forEach, reduce, findFirst. היא מתניעה את העבודה ומפיקה תוצאה (או תופעת לוואי).

החלוקה הזו חשובה בגלל כלל אחד שמפתיע את כולם בהתחלה.

פעולות ביניים הן עצלות

פעולות ביניים לא עושות כלום בעצמן. הן רק רושמות מה צריך לקרות. הצינור רץ רק כשפעולה סופית מבקשת תוצאה.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4);

        nums.stream()
            .map(n -> {
                System.out.println("mapping " + n);
                return n * 2;
            });
        // אין פעולה סופית -> שום דבר לא מודפס.

        System.out.println("Done, but nothing was mapped.");
    }
}

הריצו את זה: ה-lambda של map לא רצה אף פעם. הוסיפו פעולה סופית, וכל השרשרת מתעוררת לחיים:

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4);

        List<Integer> doubled = nums.stream()
            .map(n -> {
                System.out.println("mapping " + n);
                return n * 2;
            })
            .collect(Collectors.toList());   // סופית -> עכשיו זה רץ

        System.out.println(doubled);
    }
}

העצלות הזו היא לא תכונה מוזרה שצריך להילחם בה: היא מאפשרת ל-stream למזג פעולות ולדלג על עבודה מיותרת. אבל המשמעות היא שצינור בלי פעולה סופית לא עושה כלום, וזה באג נפוץ מסוג "למה שום דבר לא קורה?".

filter ו-map: לשמור ולהמיר

שתי אלה נושאות את רוב המשקל. filter מקבלת Predicate (lambda שמחזירה boolean) ושומרת את האיברים שעוברים. map מקבלת Function ומחליפה כל איבר בתוצאה של הפעלתה עליו.

import java.util.List;
import java.util.stream.Collectors;

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

        List<Integer> lengths = words.stream()
            .filter(w -> w.length() > 3)   // מסננים את "fig" ואת "kiwi"
            .map(String::length)           // הופכים כל מילה לאורך שלה
            .collect(Collectors.toList());

        System.out.println(lengths);   // [5, 6, 6]
    }
}

שימו לב ש-map יכולה לשנות את טיפוס האיבר: כאן stream של String הופך ל-stream של Integer. String::length הוא method reference, קיצור של ה-lambda w -> w.length().

פעולות סופיות מפיקות תוצאה

אחרי שעיצבתם את ה-stream, פעולה סופית הופכת אותו למשהו מוחשי:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(3, 1, 4, 1, 5, 9, 2, 6);

        long bigCount = nums.stream()
            .filter(n -> n > 3)
            .count();                       // כמה עברו?

        boolean anyEven = nums.stream()
            .anyMatch(n -> n % 2 == 0);     // האם לפחות אחד זוגי?

        System.out.println("Big numbers: " + bigCount);
        System.out.println("Any even? " + anyEven);
    }
}

פעולות סופיות נפוצות: collect (איסוף לרשימה, קבוצה או מפה), count, forEach, anyMatch / allMatch / noneMatch, findFirst, min / max ו-reduce. אחרי שפעולה סופית רצה, ה-stream נצרך: אי אפשר להשתמש בו שוב. קראו שוב ל-list.stream() כדי לקבל צינור חדש.

איסוף תוצאות

collect עם Collectors הוא סוס העבודה לבניית תוצאה. הנפוץ ביותר הוא Collectors.toList():

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> names = List.of("ada", "boris", "chen");

        // מחברים למחרוזת אחת
        String joined = names.stream()
            .map(String::toUpperCase)
            .collect(Collectors.joining(", "));

        System.out.println(joined);   // ADA, BORIS, CHEN
    }
}

Collectors נותנת גם את toSet(), joining(...), groupingBy(...) ו-counting(). ב-Java 16 ומעלה אפשר להחליף את collect(Collectors.toList()) ב-.toList() הקצר יותר (הוא מחזיר רשימה שאי אפשר לשנות):

List<String> result = names.stream().map(String::toUpperCase).toList();

sorted, distinct ו-limit

פעולות הביניים האלה מעצבות מחדש את ה-stream לפני האיסוף:

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(5, 3, 8, 3, 1, 9, 5, 2);

        List<Integer> top3 = nums.stream()
            .distinct()                 // מסירים כפילויות
            .sorted((a, b) -> b - a)    // בסדר יורד
            .limit(3)                   // לוקחים את שלושת הראשונים
            .collect(Collectors.toList());

        System.out.println(top3);   // [9, 8, 5]
    }
}

sorted() בלי ארגומנט משתמשת בסדר הטבעי; העבירו Comparator (כאן lambda) לסדר מותאם. Comparator.reverseOrder() היא הדרך הנקייה יותר למיין בסדר יורד.

reduce: לקפל stream לערך אחד

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

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(2, 4, 6, 8);

        int sum = nums.stream()
            .reduce(0, (a, b) -> a + b);   // מתחילים מ-0 וממשיכים לחבר

        int product = nums.stream()
            .reduce(1, (a, b) -> a * b);   // מתחילים מ-1 וממשיכים לכפול

        System.out.println("Sum: " + sum);
        System.out.println("Product: " + product);
    }
}

לסכומים וממוצעים פשוטים, ה-streams הייעודיים ברורים יותר: nums.stream().mapToInt(Integer::intValue).sum(). השתמשו ב-reduce כשאין פונקציית צבירה מוכנה.

Streams לא מחליפים כל לולאה

Streams מצטיינים כשממירים אוסף לתוצאה. הם לא מהירים יותר מלולאה באופן אוטומטי, והם מסורבלים כשצריך לשנות מצב חיצוני או לצאת מוקדם בדרכים מסובכות. כלל טוב: אם הצינור נקרא כמשפט אחד ברור, השתמשו ב-stream; אם אתם מושיטים יד למונה משותף או ל-index, לולאת for רגילה היא כנה ובסדר גמור.

זכרו גם ש-stream הוא לשימוש חד פעמי. פעולה עליו פעמיים זורקת חריגה:

Stream<String> s = names.stream();
s.forEach(System.out::println);
s.count();   // IllegalStateException: stream has already been operated upon

הבא: Optional

כמה פעולות סופיות של stream, findFirst, min, max, ו-reduce בלי ערך התחלתי, עשויות לא למצוא כלום, ולכן הן לא מחזירות ערך חשוף. הן מחזירות Optional, המיכל של Java ל"אולי ערך, אולי כלום", שסוף סוף נותן חלופה נקייה להחזרת null. זה העמוד הבא.