جافا هاشماب – هاشماب في جافا

الدروس التعليمية
Java

Java HashMap هو واحد من أكثر فئات المجموعات شعبية في جافا. تعتمد Java HashMap على تنفيذ جدول التجزئة. توسع HashMap في جافا فئة AbstractMap التي تنفذ واجهة Map.

Java HashMap

بعض النقاط المهمة حول HashMap في جافا؛

  1. يسمح Java HashMap بمفتاح فارغ وقيم فارغة.
  2. HashMap ليست مجموعة مرتبة. يمكنك تكرار إدخالات HashMap من خلال مجموعة المفاتيح ولكن لا يضمن أنها ستكون في ترتيب إضافتها إلى HashMap.
  3. HashMap تقريبًا مشابهة لـ Hashtable باستثناء أنها غير متزامنة وتسمح بمفتاح فارغ وقيم فارغة.
  4. يستخدم HashMap فئته الداخلية Node<K,V> لتخزين إدخالات الخريطة.
  5. تخزن HashMap الإدخالات في قوائم مرتبطة فردية متعددة ، تسمى الحاويات أو الصناديق. عدد الصناديق الافتراضي هو 16 وهو دائمًا قوة 2.
  6. يستخدم HashMap طرق hashCode() و equals() على المفاتيح لعمليات الحصول والوضع. لذلك يجب أن يوفر كائن مفتاح HashMap تنفيذًا جيدًا لهذه الطرق. هذا هو السبب في أن الفئات الغير قابلة للتغيير هي الأنسب للمفاتيح ، على سبيل المثال السلسلة والعدد الصحيح.
  7. Java HashMap غير مؤمنة للتعداد ، لبيئة متعددة الخيوط يجب عليك استخدام فئة ConcurrentHashMap أو الحصول على خريطة متزامنة باستخدام طريقة Collections.synchronizedMap().

بناة Java HashMap

توفر Java HashMap أربعة بناة.

  1. public HashMap(): أكثر بناء HashMap استخدامًا. سيقوم هذا البناء بإنشاء HashMap فارغة بسعة افتراضية 16 وعامل تحميل 0.75
  2. public HashMap(int initialCapacity): يُستخدم هذا بناء HashMap لتحديد السعة الابتدائية وعامل التحميل 0.75. يُفيد هذا في تجنب إعادة تجزئة إذا كنت تعرف عدد الرسميات التي ستخزن في HashMap.
  3. public HashMap(int initialCapacity, float loadFactor): سيقوم هذا البناء بإنشاء HashMap فارغة بسعة وعامل تحميل محددة. يمكنك استخدام هذا إذا كنت تعرف الحد الأقصى لعدد الرسميات التي سيتم تخزينها في HashMap. في السيناريوهات الشائعة يجب تجنب هذا لأن عامل التحميل 0.75 يقدم توازنًا جيدًا بين التكلفة الزمانية والمكانية.
  4. public HashMap(Map<? extends K, ? extends V> m): ينشئ Map يحتوي على نفس الرسميات كما في الخريطة المحددة وبعامل تحميل 0.75

مثال بناة Java HashMap

الكود أدناه يوضح مثالا على استخدام جميع البناة المذكورة أعلاه.

Map<String, String> map1 = new HashMap<>();

Map<String, String> map2 = new HashMap<>(2^5);

Map<String, String> map3 = new HashMap<>(32,0.80f);

Map<String,String> map4 = new HashMap<>(map1);

أساليب Java HashMap

لنلق نظرة على الأساليب المهمة لـ HashMap في جافا.

  1. public void clear(): هذه الأسلوب سيقوم بإزالة جميع التعيينات وستصبح HashMap فارغة.
  2. public boolean containsKey(Object key): يعيد هذا الأسلوب ‘true’ إذا كان المفتاح موجودًا وإلا فسيعيد ‘false’.
  3. public boolean containsValue(Object value): يعيد هذا الأسلوب في HashMap قيمة ‘true’ إذا كانت القيمة موجودة وإلا فسيعيد ‘false’.
  4. public Set<Map.Entry<K,V>> entrySet(): يعيد هذا الأسلوب مجموعة من عرض التعيينات HashMap. تدعم هذه المجموعة الخريطة، لذا التغييرات على الخريطة تنعكس على المجموعة، والعكس بالعكس.
  5. public V get(Object key): يعيد القيمة المعينة للمفتاح المحدد، أو القيمة الفارغة إذا لم يكن هناك تعيين للمفتاح.
  6. public boolean isEmpty(): أسلوب مساعد يعيد ‘true’ إذا لم يتم توفير أي تعيينات للمفتاح والقيمة.
  7. public Set<K> keySet(): يعيد عرضًا مجموعة من المفاتيح الواردة في هذه الخريطة. تدعم هذه المجموعة الخريطة، لذا التغييرات على الخريطة تنعكس على المجموعة، والعكس بالعكس.
  8. public V put(K key, V value): يرتبط القيمة المحددة بالمفتاح المحدد في هذه الخريطة. إذا كانت الخريطة تحتوي مسبقًا على تعيين للمفتاح، فإن القيمة القديمة ستُستبدل.
  9. public void putAll(Map m): ينسخ كل الإرتباطات من الخريطة المحددة إلى هذه الخريطة. ستحل هذه الإرتباطات مكان أي إرتباطات كانت في هذه الخريطة بالنسبة لأي من المفاتيح الموجودة حاليًا في الخريطة المحددة.
  10. public V remove(Object key): يزيل الإرتباط للمفتاح المحدد من هذه الخريطة إذا كان موجودًا.
  11. public int size(): يعيد عدد إرتباطات المفتاح-القيمة في هذه الخريطة.
  12. public Collection values(): يعيد عرض مجموعة القيم الموجودة في هذه الخريطة. المجموعة مدعومة من قبل الخريطة، لذا التغييرات في الخريطة تنعكس في المجموعة، والعكس صحيح.

هناك العديد من الأساليب الجديدة في HashMap تم إدخالها في جافا 8.

  1. public V computeIfAbsent(K key, Function mappingFunction): إذا لم يكن المفتاح المحدد مرتبطًا بالفعل بقيمة (أو مرتبط بقيمة فارغة)، فإن هذه الطريقة تحاول حساب قيمته باستخدام الدالة المعطاة وتدخلها في HashMap ما لم تكن فارغة.
  2. public V computeIfPresent(K key, BiFunction remappingFunction): إذا كانت القيمة للمفتاح المحددة موجودة وغير فارغة، تحاول حساب إرتباط جديد بناءً على المفتاح وقيمته المعطاة.
  3. public V compute(K key, BiFunction remappingFunction): هذه الطريقة في HashMap تحاول حساب إرتباط للمفتاح المحدد وقيمته الحالية.
  4. public void forEach(BiConsumer action): تنفذ هذه الطريقة العمل المعطى لكل مدخل في هذه الخريطة.
  5. public V getOrDefault(Object key, V defaultValue): نفس get باستثناء أن قيمة الافتراضية تُرجع إذا لم يتم العثور على تطابق للمفتاح المحدد.
  6. public V merge(K key, V value, BiFunction remappingFunction): إذا لم يكن المفتاح المحدد مرتبطًا بالفعل بقيمة أو مرتبطًا بقيمة null، فهو يرتبط بهذه القيمة غير الخالية من القيمة. في حالة العكس، يحل محل القيمة المرتبطة بالنتائج الناتجة عن وظيفة التصميم المعطاة، أو يتم إزالتها إذا كانت النتيجة null.
  7. public V putIfAbsent(K key, V value): إذا لم يكن المفتاح المحدد مرتبطًا بالفعل بقيمة (أو مرتبطًا بقيمة null)، فهو يرتبط بهذه القيمة المعطاة ويُرجع null، وإلا فإنه يعيد القيمة الحالية.
  8. public boolean remove(Object key, Object value): يقوم بإزالة المدخل للمفتاح المحدد فقط إذا كان حاليًا مرتبطًا بالقيمة المحددة.
  9. public boolean replace(K key, V oldValue, V newValue): يحل المدخل للمفتاح المحدد فقط إذا كان حاليًا مرتبطًا بالقيمة المحددة.
  10. public V replace(K key, V value): يحل المدخل للمفتاح المحدد فقط إذا كان حاليًا مرتبطًا بقيمة ما.
  11. public void replaceAll(BiFunction function): يحل قيمة كل مدخل بنتيجة استدعاء الوظيفة المعطاة على هذا المدخل.

مثال على HashMap في جافا

إليك برنامج جافا بسيط لأساليب استخدام HashMap الشائعة.

package com.journaldev.examples;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class HashMapExample {

	public static void main(String[] args) {

		Map<String, String> map = new HashMap<>();

		map.put("1", "1"); // put example
		map.put("2", "2");
		map.put("3", "3");
		map.put("4", null); // null value
		map.put(null, "100"); // null key

		String value = map.get("3"); // get example
		System.out.println("Key = 3, Value = " + value);

		value = map.getOrDefault("5", "Default Value");
		System.out.println("Key = 5, Value=" + value);

		boolean keyExists = map.containsKey(null);
		boolean valueExists = map.containsValue("100");

		System.out.println("keyExists=" + keyExists + ", valueExists=" + valueExists);

		Set<Entry<String, String>> entrySet = map.entrySet();
		System.out.println(entrySet);

		System.out.println("map size=" + map.size());

		Map<String, String> map1 = new HashMap<>();
		map1.putAll(map);
		System.out.println("map1 mappings= " + map1);

		String nullKeyValue = map1.remove(null);
		System.out.println("map1 null key value = " + nullKeyValue);
		System.out.println("map1 after removing null key = " + map1);

		Set<String> keySet = map.keySet();
		System.out.println("map keys = " + keySet);

		Collection<String> values = map.values();
		System.out.println("map values = " + values);

		map.clear();
		System.out.println("map is empty=" + map.isEmpty());

	}

}

أدناه ناتج البرنامج المذكور أعلاه كمثال على HashMap في جافا.

Key = 3, Value = 3
Key = 5, Value=Default Value
keyExists=true, valueExists=true
[null=100, 1=1, 2=2, 3=3, 4=null]
map size=5
map1 mappings= {null=100, 1=1, 2=2, 3=3, 4=null}
map1 null key value = 100
map1 after removing null key = {1=1, 2=2, 3=3, 4=null}
map keys = [null, 1, 2, 3, 4]
map values = [100, 1, 2, 3, null]
map is empty=true

كيف يعمل HashMap في جافا؟

HashMap في جافا يستخدم فئته الداخلية Node<K,V> لتخزين الرسم البياني. يعمل HashMap على خوارزمية التجزئة ويستخدم طريقة hashCode() و equals() على المفتاح لعمليات get و put. يستخدم HashMap قائمة روابط متصلة بشكل فردي لتخزين العناصر، وتُسمى هذه العناصر “حاويات” أو “دلاء”. عند استدعاء طريقة put، يُستخدم تجزئة المفتاح لتحديد الحاوية التي ستستخدم لتخزين الرسم البياني. بمجرد تحديد الحاوية، يُستخدم تجزئة المفتاح للتحقق مما إذا كان هناك مفتاح موجود بنفس تجزئة المفتاح أم لا. إذا كان هناك مفتاح موجود بنفس تجزئة المفتاح، يُستخدم طريقة equals() على المفتاح. إذا كانت القيمة تعيد قيمة صحيحة، يتم استبدال القيمة، وإلا يتم إنشاء رسم بياني جديد لهذه الحاوية في القائمة المتصلة بشكل فردي. إذا لم يكن هناك مفتاح بنفس تجزئة المفتاح، يتم إدراج الرسم البياني في الحاوية. بالنسبة لعملية الحصول على HashMap، يُستخدم مجددًا تجزئة مفتاح الحاوية للبحث عن القيمة. بعد تحديد الحاوية، يتم تحويل الإدخالات للعثور على الإدخال باستخدام طريقة التجزئة و equals. إذا تم العثور على تطابق، يتم إرجاع القيمة وإلا يتم إرجاع قيمة null. هناك الكثير من الأشياء المشاركة مثل خوارزمية التجزئة للحصول على الحاوية للمفتاح، إعادة تجزئة الرسم البياني وما إلى ذلك. ولكن بالنسبة لعملنا، تذكر فقط أن عمليات HashMap تعمل على المفتاح وأنه يُطلب تنفيذ جيد لطريقة hashCode و equals لتجنب السلوك غير المرغوب فيه. تظهر الصورة أدناه شرح عمليات get و put. قراءة موصى بها: أهمية طريقة hashCode و equals في جافا

تحميل العامل لـ Java HashMap

يتم استخدام العامل للتعرف على متى سيتم إعادة تشكيل HashMap وزيادة حجم الحاوية. القيمة الافتراضية لحجم الحاوية أو السعة هي 16 والعامل التحميل هو 0.75. يتم حساب عتبة إعادة التشكيل بضرب السعة والعامل التحميل. لذا ستكون القيمة العتبة الافتراضية 12. لذا عندما يكون لديه HashMap أكثر من 12 تعيينًا ، سيتم إعادة تشكيله وسيتم زيادة عدد الحاويات إلى القوة التالية من 2 أي 32. يرجى ملاحظة أن سعة HashMap دائمًا قوة من 2. يوفر العامل التحميل الافتراضي 0.75 توازنًا جيدًا بين معقل الزمان والمكان. ولكن يمكنك تعيين قيم مختلفة بناءً على احتياجاتك. إذا كنت تريد حفظ المساحة ، يمكنك زيادة قيمته إلى 0.80 أو 0.90 ولكن ستأخذ عمليات الحصول/الوضع وقتًا أطول.

Java HashMap keySet

تعيد طريقة keySet في Java HashMap مجموعة عرض المفاتيح في HashMap. يعتمد هذا العرض على HashMap ويتم انعكاس أي تغيير في HashMap في المجموعة والعكس صحيح. فيما يلي برنامج بسيط يوضح أمثلة على مجموعة المفاتيح في HashMap وما هو السبيل إلى الذهاب إذا كنت ترغب في مجموعة مفاتيح ليست مدعومة بواسطة الخريطة.

package com.journaldev.examples;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class HashMapKeySetExample {

	public static void main(String[] args) {

		Map<String, String> map = new HashMap<>();
		map.put("1", "1");
		map.put("2", "2");
		map.put("3", "3");

		Set<String> keySet = map.keySet();
		System.out.println(keySet);

		map.put("4", "4");
		System.out.println(keySet); // keySet is backed by Map

		keySet.remove("1");
		System.out.println(map); // map is also modified

		keySet = new HashSet<>(map.keySet()); // copies the key to new Set
		map.put("5", "5");
		System.out.println(keySet); // keySet is not modified
	}

}

سيجعل إخراج البرنامج أعلاه واضحًا أن keySet مدعومة بواسطة الخريطة.

[1, 2, 3]
[1, 2, 3, 4]
{2=2, 3=3, 4=4}
[2, 3, 4]

قيم HashMap في جافا

تُعيد طريقة قيم HashMap في جافا مجموعة من القيم الموجودة في الخريطة. تعتمد هذه المجموعة على HashMap ، لذا ستنعكس أي تغييرات في HashMap على مجموعة القيم والعكس صحيح. مثال بسيط أدناه يؤكد هذا السلوك لمجموعة قيم HashMap.

package com.journaldev.examples;

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

public class HashMapValuesExample {

	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		map.put("1", "1");
		map.put("2", "2");
		map.put("3", null);
		map.put("4", null);
		map.put(null, "100");

		Collection<String> values = map.values();
		System.out.println("map values = " + values);

		map.remove(null);
		System.out.println("map values after removing null key = " + values);

		map.put("5", "5");
		System.out.println("map values after put = " + values);

		System.out.println(map);
		values.remove("1"); // changing values collection
		System.out.println(map); // updates in map too

	}

}

إخراج البرنامج أعلاه كالتالي.

map values = [100, 1, 2, null, null]
map values after removing null key = [1, 2, null, null]
map values after put = [1, 2, null, null, 5]
{1=1, 2=2, 3=null, 4=null, 5=5}
{2=2, 3=null, 4=null, 5=5}

مجموعة entrySet في جافا HashMap

تُعيد طريقة entrySet في جافا HashMap عرضًا لمجموعة التعيينات. تعتمد هذه entrySet على HashMap ، لذا ستنعكس أي تغييرات في الخريطة على مجموعة التعيينات والعكس صحيح. تحقق من البرنامج المثالي أدناه لمثال entrySet في HashMap.

package com.journaldev.examples;

import java.util.AbstractMap;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class HashMapEntrySetExample {

	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		map.put("1", "1");
		map.put("2", null);
		map.put(null, "100");

		Set<Entry<String,String>> entrySet = map.entrySet();
		Iterator<Entry<String, String>> iterator = entrySet.iterator();
		Entry<String, String> next = null;
		
		System.out.println("map before processing = "+map);
		System.out.println("entrySet before processing = "+entrySet);
		while(iterator.hasNext()){
			next = iterator.next();
			System.out.println("Processing on: "+next.getValue());
			if(next.getKey() == null) iterator.remove();
		}
		
		System.out.println("map after processing = "+map);
		System.out.println("entrySet after processing = "+entrySet);
		
		Entry<String, String> simpleEntry = new AbstractMap.SimpleEntry<String, String>("1","1");
		entrySet.remove(simpleEntry);
		System.out.println("map after removing Entry = "+map);
		System.out.println("entrySet after removing Entry = "+entrySet);
	}

}

إليك الإخراج الناتج عن البرنامج أعلاه.

map before processing = {null=100, 1=1, 2=null}
entrySet before processing = [null=100, 1=1, 2=null]
Processing on: 100
Processing on: 1
Processing on: null
map after processing = {1=1, 2=null}
entrySet after processing = [1=1, 2=null]
map after removing Entry = {2=null}
entrySet after removing Entry = [2=null]

Java HashMap putIfAbsent

A simple example for HashMap putIfAbsent method introduced in Java 8.

package com.journaldev.examples;

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

public class HashMapPutIfAbsentExample {

	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		map.put("1", "1");
		map.put("2", null);
		map.put(null, "100");

		System.out.println("map before putIfAbsent = "+map);
		String value = map.putIfAbsent("1", "4");
		System.out.println("map after putIfAbsent = "+map);
		System.out.println("putIfAbsent returns: "+value);
		
		System.out.println("map before putIfAbsent = "+map);
		value = map.putIfAbsent("3", "3");
		System.out.println("map after putIfAbsent = "+map);
		System.out.println("putIfAbsent returns: "+value);
	}

}

إخراج البرنامج أعلاه؛

map before putIfAbsent = {null=100, 1=1, 2=null}
map after putIfAbsent = {null=100, 1=1, 2=null}
putIfAbsent returns: 1
map before putIfAbsent = {null=100, 1=1, 2=null}
map after putIfAbsent = {null=100, 1=1, 2=null, 3=3}
putIfAbsent returns: null

forEach في Java HashMap

HashMap forEach الأسلوب مُقَدِم في Java 8. إنها طريقة مفيدة جدًا لأداء الإجراء المعطى لكل إدخال في الخريطة حتى يتم معالجة جميع الإدخالات أو حتى يقوم الإجراء بإلقاء استثناء.

package com.journaldev.examples;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class HashMapForEachExample {

	public static void main(String[] args) {
		Map map = new HashMap<>();
		map.put("1", "1");
		map.put("2", null);
		map.put(null, "100");

		BiConsumer action = new MyBiConsumer();
		map.forEach(action);
		
		//مثال تعبير لامبدا
		System.out.println("\nHashMap forEach lambda example\n");
		map.forEach((k,v) -> {System.out.println("Key = "+k+", Value = "+v);});
	}

}

class MyBiConsumer implements BiConsumer {

	@Override
	public void accept(String t, String u) {
		System.out.println("Key = " + t);
		System.out.println("Processing on value = " + u);
	}

}

إخراج برنامج مثال HashMap forEach أعلاه هو:

Key = null
Processing on value = 100
Key = 1
Processing on value = 1
Key = 2
Processing on value = null

HashMap forEach lambda example

Key = null, Value = 100
Key = 1, Value = 1
Key = 2, Value = null

Java HashMap replaceAll

يمكن استخدام طريقة HashMap replaceAll لاستبدال قيمة كل إدخال بنتيجة استدعاء الدالة المعطاة على هذا الإدخال. تمت إضافة هذه الطريقة في Java 8 ويمكننا استخدام تعبيرات لامبدا لوسيط هذه الطريقة.

package com.journaldev.examples;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;

public class HashMapReplaceAllExample {

	public static void main(String[] args) {
		Map map = new HashMap<>();
		map.put("1", "1");
		map.put("2", "2");
		map.put(null, "100");

		System.out.println("map before replaceAll = " + map);
		BiFunction function = new MyBiFunction();
		map.replaceAll(function);
		System.out.println("map after replaceAll = " + map);

		// استبدال باستخدام تعبيرات لامبدا
		map.replaceAll((k, v) -> {
			if (k != null) return k + v;
			else return v;});
		System.out.println("map after replaceAll lambda expression = " + map);

	}

}

class MyBiFunction implements BiFunction {

	@Override
	public String apply(String t, String u) {
		if (t != null)
			return t + u;
		else
			return u;
	}

}

إخراج برنامج استبدال HashMap أعلاه هو:

map before replaceAll = {null=100, 1=1, 2=2}
map after replaceAll = {null=100, 1=11, 2=22}
map after replaceAll lambda example = {null=100, 1=111, 2=222}

Java HashMap computeIfAbsent

تقوم طريقة HashMap computeIfAbsent بحساب القيمة فقط إذا لم يكن المفتاح موجودًا في الخريطة. بعد حساب القيمة، يتم وضعها في الخريطة إذا لم تكن فارغة.

package com.journaldev.examples;

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

public class HashMapComputeIfAbsent {

	public static void main(String[] args) {
		Map map = new HashMap<>();
		map.put("1", "10");
		map.put("2", "20");
		map.put(null, "100");

		Function function = new MyFunction();
		map.computeIfAbsent("3", function); //key not present
		map.computeIfAbsent("2", function); //key already present
		
		// الطريقة لامبدا
		map.computeIfAbsent("4", v -> {return v;});
		map.computeIfAbsent("5", v -> {return null;}); //null value won't get inserted
		System.out.println(map);
	}

}

class MyFunction implements Function {

	@Override
	public String apply(String t) {
		return t;
	}
	
}

إخراج البرنامج أعلاه هو:

{null=100, 1=10, 2=20, 3=3, 4=4}

Java HashMap computeIfPresent

تقوم طريقة Java HashMap computeIfPresent بإعادة حساب القيمة إذا كان المفتاح المحدد موجودًا والقيمة غير قيمة فارغة. إذا كانت الوظيفة تعيد قيمة فارغة، يتم إزالة الإرتباط.

package com.journaldev.examples;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;

public class HashMapComputeIfPresentExample {

	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		map.put("1", "10");
		map.put("2", "20");
		map.put(null, "100");
		map.put("10", null);

		System.out.println("map before computeIfPresent = " + map);
		BiFunction<String, String, String> function = new MyBiFunction1();
		for (String key : map.keySet()) {
			map.computeIfPresent(key, function);
		}
		
		System.out.println("map after computeIfPresent = " + map);
		map.computeIfPresent("1", (k,v) -> {return null;}); // mapping will be removed
		System.out.println("map after computeIfPresent = " + map);

	}

}

class MyBiFunction1 implements BiFunction<String, String, String> {

	@Override
	public String apply(String t, String u) {
		return t + u;
	}

}

الناتج الذي تنتجه مثال HashMap computeIfPresent هو؛

map before computeIfPresent = {null=100, 1=10, 2=20, 10=null}
map after computeIfPresent = {null=null100, 1=110, 2=220, 10=null}
map after computeIfPresent = {null=null100, 2=220, 10=null}

Java HashMap compute

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

package com.journaldev.examples;

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

public class HashMapComputeExample {

	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		map.put("1", "1");
		map.put("2", "2");
		map.put(null, "10");
		map.put("10", null);

		System.out.println("map before compute = "+map);
		for (String key : map.keySet()) {
			map.compute(key, (k,v) -> {return k+v;});
		}
		map.compute("5", (k,v) -> {return k+v;}); //key not present, v = null
		System.out.println("map after compute = "+map);
	}

}

الناتج من مثال HashMap compute هو؛

map before compute = {null=10, 1=1, 2=2, 10=null}
map after compute = {null=null10, 1=11, 2=22, 5=5null, 10=10null}

Java HashMap merge

إذا لم يكن المفتاح المحدد موجودًا أو مرتبطًا بقيمة فارغة، فإنه يقوم بربطه بالقيمة غير الفارغة المعطاة. في حالة أخرى، يقوم بتبديل القيمة المرتبطة بنتائج الوظيفة المعادة التعيين، أو يقوم بإزالتها إذا كانت النتيجة فارغة.

package com.journaldev.examples;

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

public class HashMapMergeExample {

	public static void main(String[] args) {
		Map map = new HashMap<>();
		map.put("1", "1");
		map.put("2", "2");
		map.put(null, "10");
		map.put("10", null);

		for (Entry entry : map.entrySet()) {
			String key = entry.getKey();
			String value = entry.getValue();
			// يُثير merge استثناء NullPointerException إذا كان المفتاح أو القيمة فارغة
			if(key != null && value != null) 
			map.merge(entry.getKey(), entry.getValue(), 
					(k, v) -> {return k + v;});
		}
		System.out.println(map);
		
		map.merge("5", "5", (k, v) -> {return k + v;}); // key not present
		System.out.println(map);
		
		map.merge("1", "1", (k, v) -> {return null;}); // method return null, so remove
		System.out.println(map);

	}

}

الناتج من البرنامج أعلاه هو؛

{null=10, 1=11, 2=22, 10=null}
{null=10, 1=11, 2=22, 5=5, 10=null}
{null=10, 2=22, 5=5, 10=null}

هذا كل شيء بخصوص HashMap في جافا، آمل أن لا يتم تفويت أي شيء مهم. شاركها مع الآخرين أيضًا إذا أعجبتك. المرجع: API Doc

Source:
https://www.digitalocean.com/community/tutorials/java-hashmap