المرور على المجموعات في Java: for-each وIterator وforEach

مهمة واحدة وعدة أدوات

لقد جمعت بعض البيانات - في ArrayList أو HashSet أو HashMap - والآن تريد زيارة كل عنصر. تمنحك Java عدة طرق للقيام بذلك، والطريقة التي تختارها تعتمد على ما إذا كنت تحتاج إلى الفهرس، وما إذا كنت تحتاج إلى حذف عناصر في منتصف الحلقة، وما إذا كنت تفضّل صياغة على هيئة دالة أم على هيئة حلقة.

والخبر الجيد: كل Collection (قائمة أو مجموعة أو طابور) تدعم نفس حلقة for المحسّنة، فبمجرد أن تتعلمها يمكنك المرور عليها جميعاً بالطريقة نفسها.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");

        for (String lang : langs) {
            System.out.println(lang);
        }
    }
}

اقرأ النقطتين بمعنى «في»: «لكل lang في langs». أنت لا تتعامل مع فهرس إطلاقاً، فلا يوجد ما يمكن أن تخطئ فيه.

حلقة for-each

حلقة for المحسّنة هي الخيار الافتراضي للحالة البسيطة «افعل شيئاً بكل عنصر». تُقرأ بوضوح وتعمل بالطريقة نفسها عبر أنواع المجموعات - وهنا HashSet لا يملك فهارس على الإطلاق:

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("urgent");
        tags.add("review");
        tags.add("urgent");   // المجموعة Set تتجاهل التكرار

        for (String tag : tags) {
            System.out.println(tag);
        }
    }
}

أمر يجدر تذكّره بخصوص HashSet: ليس له ترتيب محدّد، لذا قد تُطبع العناصر بأي تسلسل. ومع ذلك تزور حلقة for-each كل عنصر مرة واحدة بالضبط.

حين تحتاج إلى الفهرس

تمنحك حلقة for-each العنصر لكن ليس موضعه. إذا كنت تحتاج إلى الفهرس فعلاً - لترقيم الأسطر أو للنظر إلى العناصر المجاورة - فاستخدم حلقة معدودة مع size() وget(i). هذا يعمل على List لأنها قائمة على المواضع؛ أما المجموعات والخرائط فلا فهرس لها، لذا لا ينطبق هذا الأسلوب عليها.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");

        for (int i = 0; i < langs.size(); i++) {
            System.out.println((i + 1) + ". " + langs.get(i));
        }
    }
}

لا تلجأ إلى هذا بدافع العادة فحسب. إذا لم تكن تستخدم i في شيء سوى get(i)، فإن نسخة for-each أقصر وأصعب على الخطأ.

المرور على Map

إن Map ليست Collection، لذا لا يمكنك تطبيق for-each عليها مباشرة. بدلاً من ذلك تمرّ على إحدى عروضها الثلاثة. أكثرها شيوعاً هو entrySet()، الذي يسلّمك كل زوج مفتاح-قيمة معاً:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 28);

        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

إذا كنت تحتاج إلى المفاتيح فقط، فمرّ على ages.keySet()؛ وإذا كنت تحتاج إلى القيم فقط، فمرّ على ages.values(). فضّل entrySet() حين تحتاج إلى كليهما - فالمرور على المفاتيح ثم استدعاء ages.get(key) في الداخل يُجري بحثاً ثانياً في كل تكرار دون أي داعٍ.

الـ Iterator

حلقة for-each هي في الحقيقة سكّر نحوي فوق Iterator - وهو كائن يسير عبر المجموعة عنصراً تلو الآخر عبر hasNext() وnext(). نادراً ما تكتب هذه الحلقة يدوياً، مع استثناء واحد مهم: إنها الطريقة الآمنة لحذف العناصر أثناء المرور.

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

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

        Iterator<Integer> it = nums.iterator();
        while (it.hasNext()) {
            int n = it.next();
            if (n % 2 == 0) {
                it.remove();   // آمن: يحذف العنصر الذي أُعيد للتو
            }
        }

        System.out.println(nums);
    }
}

تحذف it.remove() العنصر الذي أعادته next() آخر مرة، ويبقى المكرِّر صالحاً. هذه هي الطريقة المُجازة الوحيدة لتعديل مجموعة أثناء حلقة مكتوبة يدوياً.

الفخّ: ConcurrentModificationException

إذا استدعيت add أو remove على المجموعة نفسها داخل حلقة for-each، فستحصل على ConcurrentModificationException - يلاحظ المكرِّر أن المجموعة تغيّرت من تحته فيرفض المتابعة. وهذا من أكثر الأخطاء شيوعاً لدى المبتدئين.

List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4));
for (int n : nums) {
    if (n % 2 == 0) {
        nums.remove(Integer.valueOf(n));   // throws ConcurrentModificationException
    }
}

الحل في الغالب هو removeIf، الذي يعبّر عن القصد في سطر واحد ويتولّى المرور نيابةً عنك:

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

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
        nums.removeIf(n -> n % 2 == 0);   // إسقاط الأعداد الزوجية
        System.out.println(nums);
    }
}

تعمل removeIf على أي Collection، لذا فإن الاستدعاء نفسه ينظّف HashSet أيضاً.

دالة forEach

تملك كل مجموعة أيضاً دالة forEach تأخذ تعبير lambda وتشغّله على كل عنصر. وهي بديل أكثر اتّباعاً للنمط الوظيفي وعلى هيئة تعبير عن الحلقة - مفيدة للأسطر القصيرة المفردة:

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");
        langs.forEach(lang -> System.out.println(lang));

        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 28);
        ages.forEach((name, age) -> System.out.println(name + ": " + age));
    }
}

لاحظ أن Map.forEach تأخذ تعبير lambda بمعاملين (key, value) مباشرة - دون الحاجة إلى entrySet(). استخدم forEach للآثار الجانبية السريعة؛ وارجع إلى حلقة for العادية حين يكبر جسم الحلقة أو حين تحتاج إلى break للخروج مبكراً، وهو ما لا يستطيع تعبير lambda فعله.

التالي: الدوال (Methods)

لقد عبّأت الآن البيانات في مجموعات ومررت عليها بكل طريقة تقدّمها Java. الخطوة التالية هي تعبئة السلوك: كتابة دوالك الخاصة لتتمكّن من تسمية كتلة من المنطق وتمرير المدخلات إليها وإعادة استخدامها - وهذا ما تتناوله الصفحة التالية.