Java HashSet: القيم الفريدة والعضوية وعمليات المجموعات

المجموعة تخزّن القيم الفريدة

HashSet (من java.util) هي مجموعة تحتفظ بكل قيمة مرة واحدة على الأكثر. لا توجد مفاتيح ولا قيم مقترنة بها كما في HashMap - مجرد كيس من العناصر المتمايزة. وظيفتها الوحيدة هي الإجابة بسرعة عن سؤال واحد: «هل هذا الشيء موجود هنا؟»

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

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("java");
        tags.add("backend");
        tags.add("java");   // مكرّر - يُتجاهَل

        System.out.println(tags.contains("java"));     // true
        System.out.println(tags.contains("frontend")); // false
        System.out.println(tags.size());               // 2
    }
}

هناك معامل نوع واحد، <ElementType>. كما هو الحال مع ArrayList وHashMap، تُحدّد عادةً نوع المتغيّر بـواجهة Set وتُنشئ HashSet.

add يُرجِع ما إذا كانت القيمة جديدة

لا يكتفي add بتخزين القيمة - بل يُرجِع قيمة boolean تخبرك بما إذا كانت المجموعة قد تغيّرت فعلًا. إضافة قيمة موجودة مسبقًا تُرجِع false وتترك المجموعة دون تغيير.

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

public class Main {
    public static void main(String[] args) {
        Set<Integer> seen = new HashSet<>();

        System.out.println(seen.add(7));  // true  - 7 كانت جديدة
        System.out.println(seen.add(7));  // false - موجودة بالفعل
        System.out.println(seen);
    }
}

قيمة الإرجاع هذه مفيدة حقًا: if (!seen.add(x)) { /* x مكرّر */ } تتيح لك اكتشاف التكرارات في سطر واحد أثناء عملك.

إزالة التكرارات من قائمة

بما أن المجموعة ترفض التكرارات، فإن أسرع طريقة لإزالة التكرارات من مجموعة هي تفريغها داخل واحدة. مُنشئ HashSet يقبل أي مجموعة أخرى:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

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

        Set<String> unique = new HashSet<>(names);
        System.out.println(unique);          // كل اسم مرة واحدة
        System.out.println(unique.size());   // 3

        // أتحتاج إلى List مجددًا؟
        List<String> deduped = new ArrayList<>(unique);
        System.out.println(deduped.size());  // 3
    }
}

هذا هو السبب الأكثر شيوعًا الذي يدفع المبتدئين إلى اللجوء إلى مجموعة. فقط اعلم أنك تفقد الترتيب الأصلي في هذه الرحلة ذهابًا وإيابًا - استخدم LinkedHashSet إذا كان الترتيب مهمًا (سنتناوله أدناه).

contains وremove وsize

العمليات اليومية تماثل عمليات المجموعات الأخرى:

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

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("java");
        tags.add("backend");
        tags.add("api");

        System.out.println(tags.contains("api"));  // true
        System.out.println(tags.size());           // 3

        tags.remove("backend");
        System.out.println(tags.contains("backend")); // false

        tags.clear();
        System.out.println(tags.isEmpty());         // true
    }
}

الميزة الكبرى مقارنةً بـ ArrayList هي contains. على القائمة أن تمرّ على كل عنصر لتجيب عن ذلك (O(n))؛ أما HashSet فيقفز إلى الإجابة مباشرةً تقريبًا (نحو O(1)). وعندما تجد نفسك تستدعي list.contains(...) داخل حلقة، فهذه عادةً إشارة إلى الانتقال إلى مجموعة.

عمليات المجموعات: الاتحاد والتقاطع والفرق

تتألق المجموعات عند دمجها. تُقرأ التوابع وكأنها لغة عادية بمجرد أن تعرف أيّها يفعل ماذا:

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

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

        Set<Integer> union = new HashSet<>(a);
        union.addAll(b);            // كل ما يوجد في أيٍّ من المجموعتين
        System.out.println(union);  // 1 2 3 4 5 6

        Set<Integer> intersection = new HashSet<>(a);
        intersection.retainAll(b);  // فقط ما يوجد في كلتيهما
        System.out.println(intersection); // 3 4

        Set<Integer> difference = new HashSet<>(a);
        difference.removeAll(b);    // في a وليس في b
        System.out.println(difference);   // 1 2
    }
}

المزلق الأساسي: addAll وretainAll وremoveAll تُعدّل المجموعة التي تُستدعى عليها. ولهذا ينسخ كل مثال a أولًا في HashSet جديد - وإلا فستدمّر مجموعتك الأصلية. أنشئ مجموعة جديدة لكل نتيجة.

HashSet لا يحفظ الترتيب

مثل HashMap، لا يضمن HashSet أي ترتيب للمرور، وقد يختلف الترتيب بين تشغيلٍ وآخر. وإذا احتجت إلى قابلية التنبؤ:

• LinkedHashSet يحافظ على ترتيب الإدراج - الترتيب الذي أضفت به العناصر.
• TreeSet يبقي العناصر مرتَّبة وفق ترتيبها الطبيعي (أو وفق Comparator تزوّده به).

import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        Set<String> insertion = new LinkedHashSet<>();
        insertion.add("gamma");
        insertion.add("alpha");
        insertion.add("beta");
        System.out.println(insertion);  // [gamma, alpha, beta]

        Set<String> sorted = new TreeSet<>(insertion);
        System.out.println(sorted);      // [alpha, beta, gamma]
    }
}

جميعها الثلاثة تُنفّذ واجهة Set، لذا فإن التبديل بينها مجرد تغيير في سطر واحد في المُنشئ.

يجب أن تكون العناصر قابلة للتجزئة (Hashable)

يعتمد HashSet في صميمه على HashMap، لذا تنطبق القاعدة نفسها: فهو يحدّد مواقع العناصر بتجزئتها (hashing)، ما يعني أن hashCode() وequals() للعنصر يجب أن يتّسقا معًا. الأنواع المدمجة مثل String وInteger تفعل ذلك على نحو صحيح أصلًا، ولهذا انطوت سلاسل "java" المكرّرة في المثال أعلاه بشكل صحيح. وإذا خزّنت كائناتٍ من صنفك الخاص، فأعِد تعريف كلٍّ من equals وhashCode - وإلا فسيُعامَل كائنان «متساويان» في المعنى على أنهما متمايزان، وسيفشل contains وإزالة التكرارات بصمت.

التالي: المرور على المجموعات

لقد تعرّفت الآن على المجموعات الثلاث الأساسية - ArrayList وHashMap وHashSet. تمرّ على كلٍّ منها بطريقة مختلفة قليلًا، وهناك مزالق دقيقة (مثل تعديل مجموعة أثناء المرور عليها). سنجمع كل ذلك معًا تاليًا، ونتناول كيفية المرور على المجموعات بأناقة باستخدام حلقة for-each والمكرِّرات (iterators) وforEach.