تدفقات Java (Streams): شرح filter وmap وcollect وreduce

سلاسل المعالجة بدلاً من الحلقات

الـ stream هو سلسلة معالجة (pipeline) لمعالجة تسلسل من القيم. تبدأ من مصدر - غالباً مجموعة - ثم تسلسل عمليات مثل "أبقِ هذه فقط"، و"حوّل كل عنصر"، و"رتّبها"، وتنهي بجمع النتيجة. وبدلاً من كتابة حلقة فيها قائمة مؤقتة وif بداخلها، تصف ما تريده وتترك للـ stream أمر المرور على العناصر.

والآن وقد أصبحت تتقن تعبيرات لامدا، يتّضح دور التدفقات: كل عملية تأخذ تعبير لامدا (أو مرجع دالة) يصف العمل المطلوب لعنصر واحد.

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

شغّلها: تعبير لامدا الخاص بـ 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 (تعبير لامدا يُرجع 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 هو مرجع دالة - اختصار لتعبير لامدا 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 (هنا تعبير لامدا) للحصول على ترتيب مخصص. و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);
    }
}

بالنسبة إلى المجاميع والمتوسطات البسيطة، تكون التدفقات المتخصصة أوضح: nums.stream().mapToInt(Integer::intValue).sum(). ولجأ إلى reduce حين لا يوجد مُجمِّع جاهز.

التدفقات لا تحل محل كل حلقة

تتألق التدفقات عندما تحوّل مجموعة إلى نتيجة. وهي ليست أسرع تلقائياً من الحلقة، وتصبح غير عملية حين تحتاج إلى تعديل حالة خارجية أو الخروج المبكر بطرق متشعّبة. وثمة قاعدة جيدة: إذا قُرئت سلسلة المعالجة كجملة واحدة واضحة، فاستخدم الـ stream؛ أما إذا كنت تلجأ إلى عدّاد مشترك أو إلى index، فحلقة for البسيطة أصدق وأنسب.

تذكّر أيضاً أن الـ stream يُستخدم مرة واحدة. هذا يرمي استثناءً:

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

التالي: Optional

بعض العمليات الطرفية في التدفقات - findFirst وmin وmax وreduce من دون قيمة محايدة - قد لا تجد شيئاً، لذا فهي لا تُرجع قيمة مجردة. إنها تُرجع كائن Optional، وهو حاوية Java لمعنى "ربما قيمة، وربما لا شيء"، الذي يمنحك أخيراً بديلاً نظيفاً عن إرجاع null. وذلك هو موضوع الصفحة التالية.