Java TreeMap

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

إنها تنقلواجهة NavigableMap.

إنشاء TreeMap

لإنشاء TreeMap، يجب علينا أولاً استيراد حزمة java.util.TreeMap. بعد استيراد الحزمة، يمكن استخدام الطريقة التالية لإنشاء TreeMap في Java.

TreeMap<Key, Value> numbers = new TreeMap<>();

في الكود المذكور أعلاه، أنشأنا خريطة TreeMap تسمى numbers بدون أي معلمات. في هذا المثال، يتم ترتيب عناصر TreeMap بشكل طبيعي (تصاعدي).

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

هنا،

• المفتاح - هو المفتاح الفريد الذي يستخدم لربط كل عنصر (القيمة) في الخريطة

• القيمة - العنصر المرتبط بالمفتاح في الخريطة

طرق TreeMap

يقدم كلاس TreeMap مجموعة متنوعة من الطرق التي تسمح لنا بتنفيذ عمليات على الخريطة

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

• put() - أضف إدراج المفتاح/القيمة المحدد إلى الخريطة

• putAll() - أضف جميع الإدخالات من الخريطة المحددة إلى هذه الخريطة

• putIfAbsent() - إذا لم يكن المفتاح المحدد موجودًا في الخريطة، فأضف إدراج المفتاح/القيمة إلى الخريطة

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

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　// إنشاء خريطة الأعداد الصحيحة
　　　　　　　　TreeMap<String, Integer> evenNumbers = new TreeMap<>();
　　　　　　　　// استخدام put()
　　　　　　　　evenNumbers.put("Two", 2);
　　　　　　　　evenNumbers.put("Four", 4);
　　　　　　　　// استخدام putIfAbsent()
　　　　　　　　evenNumbers.putIfAbsent("Six", 6);
　　　　　　　　System.out.println("خريطة الأعداد الصحيحة: " + evenNumbers);
　　　　　　　　//إنشاء خريطة TreeMap من الأعداد
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One", 1);
　　　　　　　　// استخدام putAll()
　　　　　　　　numbers.putAll(evenNumbers);
　　　　　　　　System.out.println("خريطة الأعداد الصحيحة: " + numbers);
　　　　}
}

نتيجة الخروج

خريطة الأعداد الصحيحة: {Four=4, Six=6, Two=2}
عدد TreeMap {Four=4, One=1, Six=6, Two=2}

زيارة عناصر TreeMap

1.استخدام entrySet()،keySet() و values()

• entrySet() - يعود بكل إدراجات خريطة TreeMap من المفاتيح/القيم (الإدخالات)

• keySet() - يعيد مجموعة جميع المفاتيح في TreeMap

• values() - يعيد مجموعة جميع القيم في TreeMap

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

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One", 1);
　　　　　　　　numbers.put("Two", 2);
　　　　　　　　numbers.put("Three", 3);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　//استخدام entrySet()
　　　　　　　　System.out.println("مخطط المفتاح/القيمة: " + numbers.entrySet());
　　　　　　　　//استخدام keySet()
　　　　　　　　System.out.println("المفاتيح: " + numbers.keySet());
　　　　　　　　//استخدام values()
　　　　　　　　System.out.println("القيم: " + numbers.values());
　　　　}
}

نتيجة الخروج

خريطة "TreeMap": {One=1, Three=3, Two=2}
مخطط المفتاح/القيمة: [One=1, Three=3, Two=2]
المفاتيح: [One, Three, Two]
القيم: [1, 3, 2]

2.استخدام get() و getOrDefault()

• get() - يعيد القيمة المرتبطة بالمفتاح المحدد. إذا لم يتم العثور على المفتاح، يتم عودة null.

• getOrDefault() - يعيد القيمة المرتبطة بالمفتاح المحدد. إذا لم يتم العثور على المفتاح، يتم عودة القيمة الافتراضية المحددة.

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

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One", 1);
　　　　　　　　numbers.put("Two", 2);
　　　　　　　　numbers.put("Three", 3);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　//استخدام get()
　　　　　　　　int value1 = numbers.get("Three");
　　　　　　　　System.out.println("استخدام get(): " + value1);
　　　　　　　　//استخدام getOrDefault()
　　　　　　　　int value2 = numbers.getOrDefault("Five", 5);
　　　　　　　　System.out.println("استخدام getOrDefault(): " + value2);
　　　　}
}

نتيجة الخروج

خريطة "TreeMap": {One=1, Three=3, Two=2}
استخدام get(): 3
استخدام getOrDefault(): 5

حذف عنصر TeeMap

• remove(key) - يعيد ويحذف العنصر المرتبط بالمفتاح المحدد من TreeMap

• remove(key, value) - يتم حذف العنصر من المapping فقط إذا كان المفتاح والمقدار مرتبطين

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

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One", 1);
　　　　　　　　numbers.put("Two", 2);
　　　　　　　　numbers.put("Three", 3);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　//يحتوي على طريقة حذف بمعامل واحد
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("القيمة المحذوفة: " + value);
　　　　　　　　// طريقة الحذف بثلاثة معاملات
　　　　　　　　boolean result = numbers.remove("Three", 3);
　　　　　　　　System.out.println("هل تم حذف المدخل {Three=3}? " + result);
　　　　　　　　System.out.println("TreeMap بعد التحديث: " + numbers)
　　　　}
}

نتيجة الخروج

خريطة "TreeMap": {One=1, Three=3, Two=2}
القيمة المحذوفة = 2
هل تم حذف المدخل {Three=3}? True
خريطة "TreeMap" المعدلة: {One=1}

استبدال عناصر "TreeMap"

• replace(key, value) - استبدال القيمة المحددة بمفتاح جديد

• replace(key, old, new) - استبدال القيمة القديمة بالقيمة الجديدة فقط إذا كانت القيمة القديمة مرتبطة بكلمة المفتاح المحددة

• replaceAll(function) - استبدال كل قيمة في "map" باستخدام النتيجة المحددة function

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

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　numbers.put("Third", 3);
　　　　　　　　System.out.println("خريطة "TreeMap" الأصلية: " + numbers);
　　　　　　　　// استخدم "replace"
　　　　　　　　numbers.replace("Second", 22);
　　　　　　　　numbers.replace("Third", 3, 33);
　　　　　　　　System.out.println("استخدام "replace" في "TreeMap": " + numbers);
　　　　　　　　// استخدم "replaceAll"
　　　　　　　　numbers.replaceAll((key, oldValue) -> oldValue + 2);
　　　　　　　　System.out.println("استخدام "replaceAll" في "TreeMap": " + numbers);
　　　　}
}

نتيجة الخروج

خريطة "TreeMap" الأصلية: {First=1, Second=2, Third=3}
استخدام "TreeMap" لطريقة "replace": {First=1, Second=22, Third=33}
استخدام "TreeMap" لطريقة "replaceAll": {First=3, Second=24, Third=35}

في البرنامج السابق، لاحظوا جملة

numbers.replaceAll((key, oldValue) -> oldValue + 2);

في هذا السياق، قمنا بمرورتعبير "lambda".كمعامل.

يستخدم طريقة "replaceAll" لاستبدال جميع المدخلات في "map". ثم، يتم استبدال جميع العناصر بمقادير جديدة (المستخرجة من تعبير "lambda").

أساليب التنقل

بما أن صنف TreeMap implements NavigableMap، فإنه يقدم مجموعة متنوعة من الأساليب للتنقل عبر عناصر TreeMap.

1. أساليب أول وأخر

• firstKey() - يعود إلى أول مفتاح في الخريطة

• firstEntry() - يعود إلى أول مفتاح/قيمة في الخريطة

• lastKey() - يعود إلى أخر مفتاح في الخريطة

• lastEntry() - يعود إلى آخر مفتاح/قيمة في الخريطة

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

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　numbers.put("Third", 3);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　// استخدام firstKey()
　　　　　　　　String firstKey = numbers.firstKey();
　　　　　　　　System.out.println("أول المفاتيح: " + firstKey);
　　　　　　　　// استخدام lastKey()
　　　　　　　　String lastKey = numbers.lastKey();
　　　　　　　　System.out.println("أخر المفاتيح: " + lastKey);
　　　　　　　　// استخدام firstEntry()
　　　　　　　　System.out.println("أول النقاط: " + numbers.firstEntry());
　　　　　　　　// استخدام lastEntry()
　　　　　　　　System.out.println("أخر النقاط: " + numbers.lastEntry());
　　　　}
}

نتيجة الخروج

TreeMap: {First=1, Second=2, Third=3}
أول المفاتيح: First
أخر المفاتيح: Third
النقطة الأولى: First=1
النقطة الأخيرة: Third=3

2. أساليب التحكم في الاتجاه

• HigherKey() - يعود إلى المدخل المرتبط بالمفتاح الأصغر الذي هو أكبر من المفتاح المحدد.

• HigherEntry() - يعود إلى المدخل المرتبط بالمفتاح الأصغر الذي هو أكبر من المفتاح المحدد.

• lowerKey() - يعود إلى أكبر المفتاح الذي هو أقل من المفتاح المحدد.

• lowerEntry() - يعود إلى المدخل المرتبط بأكبر المفاتيح التي هي أقل من المفتاح المحدد.

• ceilingKey() - يعود إلى المدخل المرتبط بالمفتاح الأصغر الذي هو أقل من المفتاح المحدد. إذا كان هناك مفتاح في الخريطة، فإنه سيعد المفتاح هذا.

• ceilingEntry() - يعود إلى المدخل المرتبط بالمفتاح الأصغر الذي هو أكبر من المفتاح المحدد. إذا كان هناك مدخل مرتبط بالمفتاح الممرر كمعامل، فإنه سيعد المدخل المرتبط بالمفتاح هذا.

• floorKey() - يعود أكبر المفاتيح التي هي أقل من المفتاح المحدد. إذا كان هناك مفتاح تم تمريره كمعامل، فإنه سيعد المفتاح هذا.

• floorEntry() - عودة المدخل المرتبط بأكبر المفاتيح التي هي أقل من المفتاح المحدد. إذا كان هناك مفتاح تم تمريره كمعامل، فإنه سيعود إلى هذا المفتاح.

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

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put( "Second",  5);
　　　　　　　　numbers.put( "Third",  4);
　　　　　　　　numbers.put( "Fourth",  6);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　// استخدام  higher()
　　　　　　　　System.out.println( "استخدام  higherKey():  "  +  numbers.higherKey( "Fourth"));
　　　　　　　　System.out.println( "استخدام  higherEntry():  "  +  numbers.higherEntry( "Fourth"));
　　　　　　　　// استخدام  lower()
　　　　　　　　System.out.println( "\nاستخدام  lowerKey():  "  +  numbers.lowerKey( "Fourth"));
　　　　　　　　System.out.println( "استخدام  lowerEntry():  "  +  numbers.lowerEntry( "Fourth"));
　　　　　　　　// استخدام  ceiling()
　　　　　　　　System.out.println( "\nاستخدام  ceilingKey():  "  +  numbers.ceilingKey( "Fourth"));
　　　　　　　　System.out.println( "استخدام  ceilingEntry():  "  +  numbers.ceilingEntry( "Fourth"));
　　　　　　　　// استخدام  floor()
　　　　　　　　System.out.println( "\nاستخدام  floorKey():  "  +  numbers.floorKey( "Fourth"));
　　　　　　　　System.out.println( "استخدام  floorEntry():  "  +  numbers.floorEntry( "Fourth"));
　　　　}
}

نتيجة الخروج

TreeMap:  {First=1,  Fourth=6,  Second=5,  Third=4}
استخدام  higherKey():  Second
استخدام  higherEntry():  Second=5
استخدام  lowerKey():  First
استخدام  lowerEntry():  First=1
استخدام  ceilingKey():  Fourth
استخدام  ceilingEntry():  Fourth=6
استخدام  floorkey():  Fourth
استخدام طريقة floorEntry(): Fourth=6

3. طريقة pollFirstEntry() و طريقة pollLastEntry()

• pollFirstEntry() - عودة وإزالة العنصر المرتبط بالـ key الأول في المapping

• pollLastEntry() - عودة وإزالة العنصر المرتبط بالـ key الأخير في المapping

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

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　numbers.put("Third", 3);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　// استخدام طريقة pollFirstEntry()
　　　　　　　　System.out.println("استخدام pollFirstEntry(): " + numbers.pollFirstEntry())
　　　　　　　　// استخدام طريقة pollLastEntry()
　　　　　　　　System.out.println("استخدام pollLastEntry(): " + numbers.pollLastEntry())
　　　　　　　　System.out.println("TreeMap بعد التحديث: " + numbers)
　　　　}
}

نتيجة الخروج

TreeMap: {First=1, Second=2, Third=3}
استخدام pollFirstEntry(): First=1
استخدام pollLastEntry(): Third=3
TreeMap بعد التحديث: {Second=2}

4. طريقة headMap()، طريقة tailMap() و طريقة subMap()

headMap(key,booleanValue)

النصيب الحالي للبوليند هو اختياري. القيمة الافتراضية هي false.

إذا كانت القيمة الحالية للبوليند صحيحة، فإن هذه الطريقة تشمل أيضًا المفتاح/القيمة المحدد للـ key.

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

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　numbers.put("Third", 3);
　　　　　　　　numbers.put("Fourth", 4);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　System.out.println("\nاستخدام طريقة headMap():")
　　　　　　　　// استخدام headMap() مع القيمة الحالية الافتراضية كـ false
　　　　　　　　System.out.println("لم يتم تحديد القيمة الحالية للبوليند: " + numbers.headMap("Fourth"))
　　　　　　　　// استخدام headMap() مع القيمة الحالية المحددة كـ true
　　　　　　　　System.out.println("تحديد القيمة الحالية للبوليند كـ true: {Fourth=6}" + numbers.headMap("Fourth", true))
　　　　}
}

نتيجة الخروج

TreeMap: {First=1, Fourth=4, Second=2, Third=3}
استخدام طريقة headMap()　
لم يتم تحديد القيمة الحالية للبوليند: {First=1}
تحدد القيمة البوليانية صحيحة: {First=1, Fourth=4}

tailMap(key, booleanValue)

method tailMap() تبدأ من المفتاح المحدد (تم تقديمه كمعامل) وتعيد جميع أزواج المفاتيح/القيم في الخريطة.

booleanValue هو متغير اختياري. القيمة الافتراضية هي صحيحة.

إذا كان booleanValue خطأ، فإن هذا الطريقة لا تتضمن المفتاح المحدد والقيمة.

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

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　numbers.put("Third", 3);
　　　　　　　　numbers.put("Fourth", 4);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　System.out.println("\nاستخدام method tailMap():");
　　　　　　　　// استخدام method tailMap() للبولياني booleanValue باستخدام القيمة الافتراضية true
　　　　　　　　System.out.println("استخدام القيمة الافتراضية للبولياني true: " + numbers.tailMap("Second"));
　　　　　　　　// استخدام method tailMap() للبولياني booleanValue باستخدام القيمة المحددة false
　　　　　　　　System.out.println("استخدام القيمة المحددة للبولياني false: " + numbers.tailMap("Second", false));
　　　　}
}

نتيجة الخروج

TreeMap: {First=1, Fourth=4, Second=2, Third=3}
استخدام method tailMap():
استخدام القيمة الافتراضية للبولياني true: {Second=2, Third=3}
استخدام القيمة المحددة للبولياني false: {Third=3}

subMap(k1, bV1, k2, bV2)

method subMap() تعود بجميع المدخلات المرتبطة بالمفاتيح بين k1 و k2، بما في ذلك المدخل الخاص بك1.

bV1 و bV2 هي متغيرات بوليانية اختيارية. القيمة الافتراضية لبV1 هي صحيحة، والقيمة الافتراضية لبV2 هي خطأ.

إذا كان bV1 خطأ، فإن هذا الطريقة تعود بجميع المدخلات المرتبطة بالمفاتيح بين k1 و k2، لكنها لا تتضمن المدخل الخاص بك1.

إذا كان bV2 صحيحًا، فإن هذا الطريقة تعود بجميع المدخلات المرتبطة بالمفاتيح بين k1 و k2، بما في ذلك المدخل الخاص بك2.

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

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　numbers.put("Third", 3);
　　　　　　　　numbers.put("Fourth", 4);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　　　　　System.out.println("\nاستخدام method subMap():");
　　　　　　　　// استخدام method tailMap() باستخدام القيمة الافتراضية للبولياني
　　　　　　　　System.out.println("استخدام القيمة الافتراضية للبولياني: " + numbers.subMap("Fourth", "Third"));
　　　　　　　　// tailMap() القيمة المحددة
　　　　　　　　System.out.println("القيمة المحددة: " + numbers.subMap("Fourth", false, "Third", true));
　　　　}
}

نتيجة الخروج

TreeMap: {First=1, Fourth=2, Second=2, Third=3}
استخدام طريقة subMap():
استخدام القيمة المحددة الافتراضية: {Fourth=4, Second=2}
القيمة المحددة: {Second=2, Third=3}

طرق TreeMap الأخرى

مقارن TreeMap

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

لذا، نحتاج إلى إنشاء مقارن لدينا بناءً على ترتيب المفاتيح في الشجرة. على سبيل المثال،

import java.util.TreeMap;
import java.util.Comparator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　// 使用自定义比较器创建treemap
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>(new CustomComparator());
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　numbers.put("Third", 3);
　　　　　　　　numbers.put("Fourth", 4);
　　　　　　　　System.out.println("TreeMap: " + numbers);
　　　　}
　　　　// 创建一个比较器类
　　　　public static class CustomComparator implements Comparator<String> {
　　　　　　　　@Override
　　　　　　　　public int compare(String number1, String number2) {
　　　　　　　　　　　　int value = number1.compareTo(number2);
　　　　　　　　　　　　// العناصر مرتبة بعكس الترتيب
　　　　　　　　　　　　if (value > 0) {
　　　　　　　　　　　　　　　　return -1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else if (value < 0) {
　　　　　　　　　　　　　　　　return 1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else {
　　　　　　　　　　　　　　　　return 0;
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

نتيجة الخروج

TreeMap: {Third=3, Second=2, Fourth=4, First=1}

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

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

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