HashMap في Java

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

فئة HashMap في إطار العمل Java Collection تقدمواجهة Mapتنفيذ جدول الاستعلام.

إنشاء HashMap

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

// إنشاء HashMap يحتوي على 8 سعة و معامل تحميل 0.6
HashMap<كائن، قيمة> numbers = new HashMap<>(8, 0.6f);

في الكود المقدم، قمنا بإنشاء hashmap يحتوي على اسم numbers.

هنا،

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

• Value - العنصر المرتبط بالمفتاح في المفتاح

لاحظ جزء new HashMap<>(8, 0.6). هنا، الم 参数 هو سعة، والثاني هو عامل التحميل.

• capacity - سعة hashmap هي 8. هذا يعني، يمكنها تخزين 8 مدخل.

• loadFactor - عامل التحميل في hashmap هو 0.6. هذا يعني، عند ملء جدول البيانات إلى 60%، يتم نقل المدخلات إلى جدول بيانات جديد، حجمه ضعف حجم الجدول الأصلي.

سعة افتراضية وعامل تحميل

إنشاء جدول بيانات بدون تحديد سعته وعامل التحميل هو مسموحًا به. على سبيل المثال،

//HashMap مع سعة افتراضية وعامل تحميل
HashMap<Key, Value> numbers1 = new HashMap<>();

بافتراض

• سعة HashMap سيكون 16

• عامل التحميل سيكون 0.75

إنشاء hashmap من hashmap أخرى

هذه هي الطريقة التي يمكننا بها إنشاء hashmap يحتوي على جميع العناصر من hashmap أخرى

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//يتم إنشاء hashmap للعدد المزوج
　　　　　　　　HashMap<String, Integer> evenNumbers = new HashMap<>();
　　　　　　　　evenNumbers.put("Two", 2);
　　　　　　　　evenNumbers.put("Four", 4);
　　　　　　　　System.out.println("HashMap1: " + evenNumbers);
　　　　　　　　//يتم إنشاء hashmap من hashmap أخرى
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>(evenNumbers);
　　　　　　　　numbers.put("Three", 3);
　　　　　　　　System.out.println("HashMap2: " + numbers);
　　　　}
}

نتيجة الإخراج

HashMap1: {Four=4, Two=2}
HashMap2: {Two=2, Three=3, Four=4}

أساليب HashMap

يقدم هذا الفئة HashMap各种方法، مما يتيح لنا تنفيذ أنواع مختلفة من العمليات على المفتاح

يضيف العنصر إلى HashMap

• put() - يضيف المفتاح/القيمة المحددة إلى المفتاح

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

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

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

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

نتيجة الإخراج

HashMap الأعداد الصحيحة: {Six=6, Four=4, Two=2}
HashMap numbers: {Six=6, One=1, Four=4, Two=2}

زيارة عناصر HashMap

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

• entrySet() - يعود مجموعة من جميع映射ات المفاتيح/القيم الخاصة بكلب المفاتيح

• keySet() - يعود مجموعة المفاتيح الخاصة بكلب المفاتيح

• values() - يعود مجموعة القيم الخاصة بكلب المفاتيح

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

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

نتيجة الإخراج

HashMap: {One=1, Two=2, Three=3}
映射 المفتاح/القيمة: [One=1, Two=2, Three=3]
المفاتيح: [One, Two, Three]
القيم: [1, 2, 3]

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

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

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

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

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

نتيجة الإخراج

HashMap: {One=1, Two=2, Three=3}
يعود الرقم: 3
يعود الرقم: 5

حذف العنصر

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

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

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

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

نتيجة الإخراج

HashMap: {One=1, Two=2, Three=3}
حذف القيمة: 2
هل تم حذف السجل 3؟ True
HashMap المعدل: {One=1}

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

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

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

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

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

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

نتيجة الإخراج

HashMap الأصلي: {Second=2, Third=3, First=1}
استخدام replace لتحديث قيم HashMap: {Second=22, Third=33, First=1}
استخدام replaceAll لتحديث قيم HashMap: {Second=24, Third=35, First=3}

في البرنامج المذكور أعلاه، لاحظ الجملة

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

في هذا السياق، ستقوم هذه الطريقة بزيارة جميع المدخلات في المفسر. ثم ستجعل جميع القيموظيفة lambdaالقيمة الجديدة التي تقدمها.

إعادة حساب القيمة

1. استخدام طريقة compute()

• compute() - يستخدم الدالة المحددة لحساب قيمة جديدة. ثم سيتم ربط هذه القيمة بالمفتاح المحدد.

• computeIfAbsent() - إذا لم يكن المفتاح مرتبطًا بأي قيمة، فإن هذه الطريقة ستستخدم الدالة المحددة لحساب قيمة جديدة. ثم سيتم ربط هذه القيمة بالمفتاح.

• computeIfPresent() - إذا كان المفتاح مرتبطًا بأي قيمة، فإن هذا الطريقة ستستخدم الدالة المحددة لحساب قيمة جديدة. ثم سيتم ربط هذه القيمة بالمفتاح.

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

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　System.out.println("HashMap الأصلي: " + numbers);
　　　　　　　　// استخدام compute()
　　　　　　　　numbers.compute("First", (key, oldValue) -> oldValue + 2);
　　　　　　　　numbers.compute("Second", (key, oldValue) -> oldValue + 1);
　　　　　　　　System.out.println("استخدام HashMap compute(): " + numbers);
　　　　　　　　// استخدام computeIfAbsent()
　　　　　　　　numbers.computeIfAbsent("Three", key -> 5);
　　　　　　　　System.out.println("استخدام HashMap computeIfAbsent(): " + numbers);
　　　　　　　　// استخدام computeIfPresent()
　　　　　　　　numbers.computeIfPresent("Second", (key, oldValue) -> oldValue * 2);
　　　　　　　　System.out.println("استخدام HashMap computeIfPresent(): " + numbers);
　　　　}
}

نتيجة الإخراج

HashMap الأصلي: {Second=2, First=1}
استخدام compute(): {Second=3, First=3}
HashMap　使用　computeIfAbsent():　{Second=3　First=3,　Three=5}
HashMap باستخدام computeIfAbsent(): {Second=3 First=3, Three=5}

HashMap باستخدام computeIfPresent(): {Second=6, First=3, three=5}

في هذا المثال، نستخدم وظيفة compute() لإعادة حساب قيمة المفسر.وظيفة lambdaكمعلمة للطريقة لإعادة حساب القيمة.

2. استخدام طريقة merge()

إذا لم يكن المفتاح المحدد مرتبطًا بعد، فإن طريقة merge() سترتبط القيمة المحددة مع المفتاح المحدد.

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

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("First", 1);
　　　　　　　　numbers.put("Second", 2);
　　　　　　　　System.out.println("HashMap الأصلي: " + numbers);
　　　　　　　　//استخدام طريقة merge()
　　　　　　　　numbers.merge("First", 4, (oldValue, newValue) -> oldValue + newValue);
　　　　　　　　System.out.println("HashMap جديد: " + numbers);
　　　　}
}

نتيجة الإخراج

HashMap الأصلي: {Second=2, First=1}
HashMap جديد: {Second=2, First=5}

في المثال السابق، يستخدم طريقة merge() ثلاثة معلمات:key,newValueووظيفة lambda (لحساب القيمة الجديدة المدمجة).

طرق أخرى لHashMap

استكشاف HashMap

في HashMap، يمكننا

• استكشافها المفتاح

• استكشافها القيمة

• استكشافها المفتاح/القيمة

1. استخدام دورة forEach

import java.util.HashMap;
import java.util.Map.Entry;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//إنشاء HashMap
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One", 1);
　　　　　　　　numbers.put("Two", 2);
　　　　　　　　numbers.put("Three", 3);
　　　　　　　　System.out.println("HashMap: " + numbers);
　　　　　　　　//زيارة زوج المفتاح/القيمة (key/value)
　　　　　　　　System.out.print("المشروع: ");
　　　　　　　　للدخول في (Entry<String, Integer> entry: numbers.entrySet()) {
　　　　　　　　　　　　System.out.print(entry);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　// زيارة المفتاح
　　　　　　　　System.out.print("\nجميع المفاتيح: ");
　　　　　　　　for(String key: numbers.keySet()) {
　　　　　　　　　　　　System.out.print(key);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　// زيارة القيمة
　　　　　　　　System.out.print("
جميع القيم: ");
　　　　　　　　for(Integer value: numbers.values()) {
　　　　　　　　　　　　System.out.print(value);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

نتيجة الإخراج

HashMap: {One=1, Two=2, Three=3}
جميع المدخلات: One=1, Two=2, Three=3
جميع المفاتيح: One, Two, Three,
جميع القيم: 1, 2, ,3,

في البرنامج المذكور أعلاه، لاحظ أننا قمنا باستيراد حزمة java.util.Map.Entry. هنا Map.Entry هي فئة محصورة داخل واجهة Map.

هذه الفئة المنغمسة تعود رؤية المفتاح (العناصر) لـ map.

2. استخدام طريقة iterator()

يمكننا أيضًا استخدام طريقة iterator() لاستنساخ HashMap. لاستخدام هذه الطريقة، يجب علينا استيراد حزمة java.util.Iterator.

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　// إنشاء HashMap
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One", 1);
　　　　　　　　numbers.put("Two", 2);
　　　　　　　　numbers.put("Three", 3);
　　　　　　　　System.out.println("HashMap: " + numbers);
　　　　　　　　// إنشاء كائن Iterator
　　　　　　　　Iterator<Entry<String, Integer>> iterate1 = numbers.entrySet().iterator();
　　　　　　　　// زيارة زوج المفتاح/القيمة
　　　　　　　　System.out.print("جميع المدخلات: ");
　　　　　　　　while(iterate1.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate1.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　// زيارة المفتاح
　　　　　　　　Iterator<String> iterate2 = numbers.keySet().iterator();
　　　　　　　　System.out.print("\nجميع المفاتيح: ");
　　　　　　　　while(iterate2.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate2.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　// زيارة القيمة
　　　　　　　　Iterator<Integer> iterate3 = numbers.values().iterator();
　　　　　　　　　System.out.print("
جميع القيم: ");
　　　　　　　　while(iterate3.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate3.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

نتيجة الإخراج

HashMap: {One=1, Two=2, Three=3}
جميع المدخلات: One=1, Two=2, Three=3
جميع المفاتيح: One, Two, Three,
جميع القيم: 1, 2, 3,

في البرنامج المسبق، لاحظ أننا قمنا بتحميل مكتبة java.util.Map.Entry. هنا Map.Entry هي فئة منغمسة لواجهة Map.

هذه الفئة المنغمسة تعود رؤية المفتاح (العناصر) لـ map.