Java HashMap – HashMap בְּשָׂפַת Java

מדריכים
Java

HashMap של Java

Java HashMap הוא אחד ממחלקות האוסף הפופולריות ביותר ב-Java. Java HashMap הוא יישום במבוסס טבלת גיבוב. HashMap ב-Java מרחיב את מחלקת AbstractMap המממשת את ממשק ה-Map.

  1. Java HashMap מאפשר נקודת קפיצה ריקה וערכים ריקים.
  2. HashMap אינו אוסף ממויין. ניתן לחזור על רשומות ה-HashMap דרך קבוצת המפתחות, אך אין הבטחה שהן יהיו בסדר הוספתן ל-HashMap.
  3. HashMap דומה בצורה כמעט זהה ל-Hashtable, עם ההבחנה שהוא אינו מסונכרן ומאפשר נקודת קפיצה ריקה וערכים ריקים.
  4. HashMap משתמש במחלקת הפנימית שלו, Node<K,V>, לאחסון רשומות המפה.
  5. HashMap אחסון רשומות במספר של רשימות מקושרות בודדות, הנקראות דליים או קופסאות. מספר ברירת המחדל של הדליים הוא 16 והוא תמיד חזקת שניים.
  6. HashMap משתמש בשיטות hashCode() ו-equals() על המפתחות לצורך פעולות get ו-put. לכן אובייקט המפתח ב-HashMap צריך לספק יישום טוב של שתי השיטות. זו הסיבה שכיתות אי-שינוי הן יותר מתאימות למפתחות, לדוגמה String ו-Integer.
  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. זה שימושי למניעת rehashing אם ידוע מספר המיפויים שיש לאחסן ב-HashMap.
  3. public HashMap(int initialCapacity, float loadFactor): בנאי HashMap זה ייצור HashMap ריק עם קיבולת ראשית ומקדם טעינה מסוימים. ניתן להשתמש בזה אם ידוע מראש המספר המרבי של המיפויים שיש לאחסן ב-HashMap. בתרחישים רגילים, כדאי להימנע מכך משום שמקדם הטעינה 0.75 מציע יחס טוב בין עלות השטח לעלות הזמן.
  4. public HashMap(Map<? extends K, ? extends V> m): יוצר Map עם אותם מיפויים כמו המפה שצוינה ועם מקדם טעינה של 0.75

דוגמא לבנאיים של Java HashMap

בקטע הקוד למעלה מוצג דוגמא לשימוש במחלקת 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);

שיטות HashMap של Java

בואו נסתכל על השיטות החשובות של HashMap ב-Java.

  1. public void clear(): שיטת HashMap זו תסיר את כל המיפויים וה-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(): שיטה זו תחזיר תצוגה של Set של המיפויים ב-HashMap. סט זה נתמך על ידי ה-Map, כך ששינויים במפה ישפיעו על הסט, ולהפך.
  5. public V get(Object key): מחזיר את הערך הממופה למפתח הספציפי, או null אם אין מיפוי עבור המפתח.
  6. public boolean isEmpty(): שיטת יוליליטי המחזירה 'true' אם אין מיפויים של זוגות מפתח-ערך.
  7. public Set<K> keySet(): מחזיר תצוגה של Set של המפתחות שמופיעות במפה זו. הסט נתמך על ידי המפה, כך ששינויים במפה ישפיעו על הסט, ולהפך.
  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 המובאות ב-Java 8.

  1. \public V computeIfAbsent(K key, Function mappingFunction)\: אם המפתח המצויין עדיין לא מקושר לערך (או מקושר לערך המתאים), שיטה זו מנסה לחשב את הערך שלו באמצעות הפונקציה המיפוי הנתונה ומכניסה אותו לתוך ה-HashMap למעט Null.
  2. \public V computeIfPresent(K key, BiFunction remappingFunction)\: אם הערך עבור המפתח המצויין קיים ולא-Null, השיטה מנסה לחשב מיפוי חדש לפי המפתח וערך המיפוי הנוכחי שלו.
  3. \public V compute(K key, BiFunction remappingFunction)\: שיטה זו מנסה לחשב מיפוי עבור המפתח המצויין וערך המיפוי הנוכחי שלו.
  4. public void forEach(BiConsumer<? super K, ? super V> action): ‏‏‎פעולה זו מבצעת את הפעולה הנתונה עבור כל ערך במפה זו.
  5. public V getOrDefault(Object key, V defaultValue): זהה ל-get אלא ש- defaultValue מוחזר אם לא נמצאה מיפוי עבור המפתח המסוים.
  6. public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction): אם המפתח המסוים עדיין לא מקושר לערך או מקושר ל-null, מקשר אותו עם הערך הלא-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<? super K, ? super V, ? extends V> function): מחליף את ערך הערך של כל ערך עם תוצאת הפעלת הפונקציה הנתונה על הערך הזה.

דוגמת HashMap ב-Java

הנה תכנית Java פשוטה עבור שיטות נפוצות ב-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 ב-Java שלמעלה.

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 פועל ב-Java?

HashMap ב-Java משתמש בתת-מחלקתו Node<K,V> עבור אחסון המיפויים. HashMap פועל על אלגוריתם האש ומשתמש בשיטות hashCode() ו-equals() על המפתח עבור פעולות get ו-put. HashMap משתמש ברשימה מקושרת יחידה על מנת לאחסן איברים, שנקראים תאים או דליים. כאשר אנו קוראים לשיטת put, נעשה שימוש ב-hashing של המפתח כדי לקבוע את הדלי שישמש לאחסון המיפוי. לאחר שהדלי זוהה, משתמשים ב-hashing כדי לבדוק האם כבר קיים מפתח עם אותו hashCode או לא. אם קיים מפתח קיים עם אותו hashCode, אז משתמשים בשיטת equals() על המפתח. אם equals מחזירה ערך true, אז הערך מחלף את הערך הקיים, אחרת מתבצע מיפוי חדש לתוך הדלי הזה של הרשימה המקושרת. אם אין מפתח קיים עם אותו hashCode, אז המיפוי מוכנס לתוך הדלי. עבור פעולת get של HashMap, שוב משתמשים ב-hashing של המפתח כדי לקבוע את הדלי שבו יש לחפש את הערך. לאחר שהדלי זוהה, נעבור על הערכים כדי למצוא את הערך באמצעות hashCode ושיטת equals. אם נמצא התאמה, מוחזר הערך, אחרת מוחזר null. קיימות עוד הרבה דברים הקשורים כגון אלגוריתם האש לקבלת הדלי עבור המפתח, rehashing של המיפויים וכו'. אך לצורך העבודה שלנו, יש לזכור כי פעולות HashMap עובדות על מפתח והטמעה טובה של שיטות hashCode ו-equals נדרשת כדי למנוע התנהגות לא רצויה. בתמונה מטה מוצג הסבר על פעולות get ו-put. קריאה מומלצת: חשיבות שיטת hashCode ו-equals ב-Java

גורם טעינת Java HashMap

גורם הטעינה משמש לקביעת מתי יתבצע rehash של HashMap וגודל הדליים יתרחב. ערך ברירת המחדל של הדליים או הקיבולת הוא 16 וערך הגורם הוא 0.75. אחוז הסף לביצוע rehash נחשב על ידי כפל הקיבולת והגורם. לכן, ערך ברירת המחדל של הסף יהיה 12. כך שכאשר ל-HashMap יש יותר מ-12 מיפויים, היא תתבצע rehash ומספר הדליים יתרחב לשוליים הבאים של 2 בחזקה, כלומר 32. שים לב שקיבולת ה-HashMap היא תמיד בחזקת 2. ערך ברירת המחדל של 0.75 מספק חילוף טוב בין מרחב וזמן הרצת קוד. אך תוכל להגדיר אותו לערכים שונים בהתאם לדרישותיך. אם ברצונך לחסוך מקום, תוכל להגדיר את ערך הסף ל-0.80 או 0.90, אך אז פעולות get/put ייקחו יותר זמן.

קבוצת מפתחות של Java HashMap

שיטת keySet של Java HashMap מחזירה את התצוגה Set של המפתחות ב-HashMap. תצוגה זו מתרחבת על ידי HashMap וכל שינוי ב-HashMap מתקיים גם ב-Set ולהפך. למטה תוכל למצוא דוגמא פשוטה לתכנית המדגימה דוגמאות ל-HashMap keySet ומהו הדרך ליצירת keySet שאינו מקושר למפה.

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 של Java

שיטת ערכי HashMap של Java מחזירה תצוגת אוסף של הערכים במפה. קולקציה זו נתמכת על ידי 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 של Java

שיטת entrySet של HashMap של Java מחזירה תצוגת Set של המיפויים. תצוגת ה- 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]

putIfAbsent של HashMap של Java

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 של HashMap של Java

שיטת forEach של HashMap הושקעה ב-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);
	}

}

פלט של תוכנית הדוגמה של forEach של HashMap מופיע למטה;

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

שיטת replaceAll של HashMap ניתן להשתמש בה כדי להחליף את ערך כל ערך עם תוצאת קריאה לפונקציה נתונה על הערך הזה. שיטה זו נוספה ב-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);

		// replaceAll באמצעות ביטויי למבדר
		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;
	}

}

פלט של תוכנית הדוגמה ל-replaceAll של 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

שיטת computeIfAbsent של HashMap מחשבת את הערך רק אם המפתח לא קיים במפה. לאחר החישוב של הערך, הוא מוכנס למפה אם הוא לא null.

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

שיטת computeIfPresent ב־Java HashMap מחשבת את הערך מחדש אם המפתח המסוים קיים והערך הוא לא־null. אם הפונקציה מחזירה null, המיפוי יוסר.

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. אם אין מיפוי ושיטה זו משתמשת, הערך יהיה null לפונקציית 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

אם המפתח המסוים אינו קיים או מקושר ל־null, אז מעציב אותו עם הערך הלא־null שניתן. להפך, מחליף את הערך המקושר עם תוצאות הפונקציה לצדדים מחדש, או מסיר אם התוצאה היא null.

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 אם המפתח או הערך הוא null
			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 ב-Java, אני מקווה שלא נעדר משהו חשוב. שתף זאת עם אחרים גם אם אהבת את זה. הפניה: API Doc

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