Java TreeSet

في هذا الدليل، سنتعلم من خلال الأمثلة فئة Java TreeSet وكافة عملياتها وأساليبها.

فئة TreeSet في إطار العمل الخاص بـ Java Collections Framework تقدم وظائف بنية البيانات الشجرة.

إنها ت扩لتواجهة NavigableSet.

إنشاء مجموعة شجرة

لإنشاء مجموعة شجرة، يجب علينا أولاً استيراد حزمة java.util.TreeSet.

بعد استيراد الحزم، إليك كيفية إنشاء TreeSet في Java.

TreeSet<Integer> numbers = new TreeSet<>();

في هذا المكان، قمنا بإنشاء TreeSet بدون أي معلمات. في هذا المثال، يتم ترتيب عناصر TreeSet بشكل طبيعي (ترتيب تصاعدي).

لكن يمكننا استخدام interface Comparator لتخصيص ترتيب العناصر. سنتعلم عنه في جزء لاحق من هذا الدليل.

طرق TreeSet

يقدم class TreeSet مجموعة من الطرق التي تسمح لنا بتنفيذ أنواع مختلفة من العمليات على المجموعة.

إدراج العنصر في TreeSet

• add() - إدراج العنصر المحدد في المجموعة

• addAll() - إدراج جميع العناصر من مجموعة محددة في المجموعة

على سبيل المثال،

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> evenNumbers = new TreeSet<>();
　　　　　　　　// استخدام method add()
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　evenNumbers.add(6);
　　　　　　　　System.out.println("TreeSet: " + evenNumbers);
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　// استخدام method addAll()
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("مجموعة TreeSet الجديدة: " + numbers);
　　　　}
}

نتائج الإخراج

TreeSet: [2, 4, 6]
TreeSet جديد: [1, 2, 4, 6]

زيارة عناصر TreeSet

لزيارة عناصر مجموعة TreeSet، يمكننا استخدام method iterator(). لاستخدام هذا الأسلوب، يجب علينا استيراد package java.util.Iterator. على سبيل المثال،

import java.util.TreeSet;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet:　"　+　numbers);
　　　　　　　　// استدعاء method iterator()
　　　　　　　　Iterator<Integer> iterate = numbers.iterator();
　　　　　　　　System.out.print("TreeSet يستخدم iterator: ");
　　　　　　　　// زيارة العنصر
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

نتائج الإخراج

TreeSet: [2, 5, 6]
استخدام TreeSet مع iterator: 2, 5, 6,

حذف العنصر

• remove() - حذف العنصر المحدد من المجموعة

• removeAll() - حذف جميع العناصر من المجموعة

على سبيل المثال،

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet:　"　+　numbers);
　　　　　　　　// استخدام method remove()
　　　　　　　　boolean value1 = numbers.remove(5);
　　　　　　　　System.out.println("هل تم حذف 5؟ " + value1);
　　　　　　　　// استخدام method removeAll()
　　　　　　　　boolean value2 = numbers.removeAll(numbers);
　　　　　　　　System.out.println("هل تم حذف جميع العناصر؟ " + value2);
　　　　}
}

نتائج الإخراج

TreeSet: [2, 5, 6]
هل تم حذف 5؟ true
هل تم حذف جميع العناصر؟ true

طرق التوجيه

لأن TreeSet class implements NavigableSet،يقدم هذا الميزات المختلفة لتحديد عناصر مجموعة الشجرة.

1. طرق first() و last()

• first() - يعود إلى العنصر الأول في المجموعة

• last() - يعود إلى العنصر الأخير في المجموعة

على سبيل المثال،

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet:　"　+　numbers);
　　　　　　　　// استخدام طريقة first()
　　　　　　　　int first = numbers.first();
　　　　　　　　System.out.println("رقم الأول: " + first);
　　　　　　　　// استخدام طريقة last()
　　　　　　　　int last = numbers.last();
　　　　　　　　System.out.println("رقم الأخر: " + last);
　　　　}
}

نتائج الإخراج

TreeSet: [2, 5, 6]
رقم الأول: 2
رقم الأخر: 6

2. طرق ceiling()،floor()،higher() و lower()

• Higher(element) - يعود إلى أصغر عنصر أكبر من العنصر المحدد (element).

• lower(element) - يعود إلى أكبر عنصر أقل من العنصر المحدد (element).

• ceiling(element) - يعود إلى أصغر عنصر أكبر من العنصر المحدد (element). إذا كان العنصر المحدد موجودًا في المجموعة، فإنه يعود إلى العنصر المحدد كمعامل.

• floor(element) - يعود إلى أكبر عنصر أقل من العنصر المحدد (element). إذا كان العنصر المحدد موجودًا في المجموعة، فإنه يعود إلى العنصر المحدد كمعامل.

على سبيل المثال،

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet:　"　+　numbers);
　　　　　　　　// استخدام higher()
　　　　　　　　System.out.println("استخدام higher: " + numbers.higher(4));
　　　　　　　　// استخدام lower()
　　　　　　　　System.out.println("استخدام lower: " + numbers.lower(4));
　　　　　　　　// استخدام ceiling()
　　　　　　　　System.out.println("استخدام ceiling: " + numbers.ceiling(4));
　　　　　　　　// استخدام floor()
　　　　　　　　System.out.println("استخدام floor: " + numbers.floor(3));
　　　　}
}

نتائج الإخراج

TreeSet:　[2,　4,　5,　6]
استخدام higher: 5
استخدام lower: 2
استخدام ceiling: 4
استخدام floor: 2

3. pollfirst() و pollLast() طرق

• pollFirst() - عودة العنصر الأول وإزالته من المجموعة

• pollLast() - عودة العنصر الأخير وإزالته من المجموعة

على سبيل المثال،

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet:　"　+　numbers);
　　　　　　　　// استخدام pollFirst()
　　　　　　　　System.out.println("حذف العنصر الأول: " + numbers.pollFirst());
　　　　　　　　// استخدام pollLast()
　　　　　　　　System.out.println("حذف العنصر الأخير: " + numbers.pollLast());
　　　　　　　　System.out.println("مجموعة TreeSet الجديدة: " + numbers);
　　　　}
}

نتائج الإخراج

TreeSet:　[2,　4,　5,　6]
حذف العنصر الأول: 2
حذف العنصر الأخير: 6
مجموعة TreeSet الجديدة: [4, 5]

4. طرق headSet، tailSet و subSet

headSet(element,booleanValue)

تستعيد طريقة headSet جميع العناصر في المجموعة المميزة قبل العنصر المحدد (تم إرساله كـ parameter).

المفردات القيمة الحقيقية هي اختيارية. القيمة default هي الصدقية.

إذا كانت القيمة الحقيقية للـ booleanValue هي الحقيقة، فإن هذه الطريقة سترجع جميع العناصر قبل العنصر المحدد، بما في ذلك العنصر المحدد.

على سبيل المثال،

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet:　"　+　numbers);
　　　　　　　　// استخدام headSet() مع القيمة الحقيقية default
　　　　　　　　System.out.println("استخدام headSet بدون القيمة الحقيقية: " + numbers.headSet(5));
　　　　　　　　// استخدام headSet() مع القيمة الحقيقية المحددة
　　　　　　　　System.out.println("استخدام headSet مع القيمة الحقيقية: " + numbers.headSet(5, true));
　　　　}
}

نتائج الإخراج

TreeSet:　[2,　4,　5,　6]
استخدام headSet بدون القيمة الحقيقية: [2, 4]
استخدام headSet مع القيمة الحقيقية: [2, 4, 5]

tailSet(element,booleanValue)

تستعيد طريقة tailSet جميع العناصر في المجموعة المميزة بعد العنصر المحدد (تم إرساله كـ parameter)، وهو عناصر المجموعة المميزة.

المفردات القيمة الحقيقية هي اختيارية. القيمة default هي الحقيقة.

إذا تم إرسال القيمة الحقيقية للـ false كـ a، فإن هذه الطريقة سترجع جميع العناصر بعد العنصر المحدد، العنصر وليس العنصر المحدد.

على سبيل المثال،

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet:　"　+　numbers);
　　　　　　　　// استخدام tailSet() مع القيمة الحقيقية default
　　　　　　　　System.out.println("استخدام default القيمة الحقيقة لـ tailSet: " + numbers.tailSet(4));
　　　　　　　　//استخدام tailSet() مع القيمة البولية المحددة
　　　　　　　　System.out.println("tailSet() مع القيمة البولية:　"　+　numbers.tailSet(4,　false));
　　　　}
}

نتائج الإخراج

TreeSet:　[2,　4,　5,　6]
استخدام tailSet() مع القيمة البولية الافتراضية:　[4,　5,　6]
tailSet() مع القيمة البولية:　[5,　6]

subSet(e1,bv1,e2,bv2)

تعود طريقة subSet() جميع العناصر بين e1 وe2، بما في ذلك e1.

bv1 وbv2 هي متغيرات اختيارية. 　قيمة bv1 الافتراضية هي true، وقيمة bv2 الافتراضية هي false.

إذا تم إرسال false كbv1، فإن هذه الطريقة تعود جميع العناصر بين e1 وe2، بدون e1.

إذا تم إرسال true كbv2، فإن هذه الطريقة تعود جميع العناصر بين e1 وe2، بما في ذلك e1.

على سبيل المثال،

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet:　"　+　numbers);
　　　　　　　　//استخدام subSet() مع القيمة البولية الافتراضية
　　　　　　　　System.out.println("subSet() باستخدام القيمة البولية الافتراضية:　"　+　numbers.subSet(4,　6));
　　　　　　　　//استخدام subSet() باستخدام القيمة البولية المحددة
　　　　　　　　System.out.println("subSet() باستخدام القيمة البولية المحددة:　"　+　numbers.subSet(4,　false,　6,　true));
　　　　}
}

نتائج الإخراج

TreeSet:　[2,　4,　5,　6]
subSet() باستخدام القيمة البولية الافتراضية:　[4,　5]
subSet() باستخدام القيمة البولية المحددة:　[5,　6]

طرق عمليات المجموعات

يمكن استخدام طرق TreeSet للقيام بعدة عمليات على المجموعات.

جمع المجموعات

لتنفيذ الجمع بين مجموعتين، نستخدم طريقة addAll()، على سبيل المثال،

import java.util.TreeSet;;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> evenNumbers = new TreeSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("TreeSet1: " + evenNumbers);
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("TreeSet2: " + numbers);
　　　　　　　　//جمع مجموعتين
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("الجمع هو:　"　+　numbers);
　　　　}
}

نتائج الإخراج

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
الجمع:　[1,　2,　3,　4]

تكامل المجموعات

لتنفيذ التكامل بين مجموعتين، نستخدم طريقة retainAll(). على سبيل المثال،

import java.util.TreeSet;;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> evenNumbers = new TreeSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("TreeSet1: " + evenNumbers);
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("TreeSet2: " + numbers);
　　　　　　　　//　ثلاثة مجموعات التكامل
　　　　　　　　numbers.retainAll(evenNumbers);
　　　　　　　　System.out.println("التفاوت المشترك: " + numbers);
　　　　}
}

نتائج الإخراج

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
التفاوت المشترك: [2]

الفرق بين المجموعتين

لحساب الفرق بين مجموعتين، يمكننا استخدام طريقة removeAll(). على سبيل المثال،

import java.util.TreeSet;;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> evenNumbers = new TreeSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("TreeSet1: " + evenNumbers);
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　numbers.add(4);
　　　　　　　　System.out.println("TreeSet2: " + numbers);
　　　　　　　　//الفرق بين المجموعتين
　　　　　　　　numbers.removeAll(evenNumbers);
　　　　　　　　System.out.println("الفرق: " + numbers);
　　　　}
}

نتائج الإخراج

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3, 4]
الفرق: [1, 3]

مجموعة الفرعية

للتحقق من whether مجموعة واحدة هي مجموعة فرعية لمجموعة أخرى، نستخدم طريقة containsAll(). على سبيل المثال،

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet<Integer> numbers = new TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　numbers.add(4);
　　　　　　　　System.out.println("TreeSet1: " + numbers);
　　　　　　　　TreeSet<Integer> primeNumbers = new TreeSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　System.out.println("TreeSet2: " + primeNumbers);
　　　　　　　　//تحقق من whether primeNumbers هو مجموعة فرعية لنظام numbers
　　　　　　　　boolean result = numbers.containsAll(primeNumbers);
　　　　　　　　System.out.println("TreeSet2 هو مجموعة فرعية لـ TreeSet1؟ " + result);
　　　　}
}

نتائج الإخراج

TreeSet1: [1, 2, 3, 4]
TreeSet2: [2, 3]
هل TreeSet2 هو مجموعة فرعية لـ TreeSet1؟ True

أساليب TreeSet الأخرى

مقارنة TreeSet و HashSet

يحقق TreeSet و HashSet واجهة Set. ومع ذلك، هناك بعض الاختلافات بينهما.

• على عكس HashSet، العناصر في TreeSet يتم تخزينها في ترتيب معين. هذا لأن TreeSet يمتلك أيضًا واجهة SortedSet.

• يقدم TreeSet بعض الأساليب سهلة التصفح. مثل first()، last()، headSet()، tailSet() وما إلى ذلك. هذا لأن TreeSet يمتلك أيضًا واجهة NavigableSet.

• على عكس HashSet، الأنواع في TreeSet يتم تخزينها في ترتيب معين. هذا لأن TreeSet يمتلك أيضًا واجهة SortedSet.

مقارنات مجموعة الأشجار

في جميع الأمثلة السابقة، العناصر في مجموعة الأشجار مرتبة بطريقة طبيعية. ولكن، يمكننا أيضًا تحديد ترتيب العناصر.

لذا، نحتاج إلى إنشاء فئة comparator الخاصة بنا، بناءً على ترتيب العناصر في مجموعة الأشجار. على سبيل المثال

import java.util.TreeSet;
import java.util.Comparator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　// 使用自定义比较器创建TreeSet
　　　　　　　　TreeSet<String> animals = new TreeSet<>(new CustomComparator());
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Zebra");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("TreeSet: " + animals);
　　　　}
　　　　// 创建一个比较器类
　　　　public static class CustomComparator implements Comparator<String> {
　　　　　　　　@Override
　　　　　　　　public int compare(String animal1, String animal2) {
　　　　　　　　　　　　int value = animal1.compareTo(animal2);
　　　　　　　　　　　　// ترتيب العناصر بترتيب معكوس
　　　　　　　　　　　　if (value > 0) {
　　　　　　　　　　　　　　　　return -1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else if (value < 0) {
　　　　　　　　　　　　　　　　return 1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else {
　　　　　　　　　　　　　　　　return 0;
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

نتائج الإخراج

TreeSet: [Zebra, Horse, Dog, Cat]

في المثال السابق، قمنا بإنشاء مجموعة شجرة، وتم تمرير فئة CustomComparator كمعامل.

فئة CustomComparator تحقق من واجهة Comparator.

ثم، نعيد كتابة طريقة compare(). الآن، ستقوم هذه الطريقة بترتيب العناصر في ترتيب معكوس.