האַשמאַפּ מעטהאָדס Java  



האַשמאַפּ ז'אבא Java מאפע

האַשמאַפּ קלאַס אין Java סטאָרז די דאַטן אין די פאָרעם פון שליסל-ווערט פּערז ווו די שליסל דאַטן זאָל זיין יינציק. מיר קענען אַקסעס די וואַלועס באזירט אויף די קאָראַספּאַנדינג שליסל דאַטן. האַשמאַפּ איז פאָרשטעלן אין דזשאַוואַ ס קאַלעקשאַן פריימווערק און איז טייל פון דזשאַוואַ.וטיל פּעקל. עס אַרבעט לויט דעם פּרינציפּ פון די האַשינג טעכניק.

Java HashMap כייעראַרקי  

די HashMap קלאַס אין Java יקסטענדז די אַבסטראַקט קלאַס AbstractMap און ימפּלאַמאַנץ די מאַפּע צובינד ווי געוויזן אונטן.

האַשמאַפּ אין Javaשפּילקע

האַשמאַפּ סטרוקטור און ארבעטן פּרינציפּ  

האַשמאַפּ אין Java אַרבעט אויף דעם פּרינציפּ פון כאַשינג טעכניק. אין כאַשינג, מיר נוצן האַש פאַנגקשאַנז צו פאַרבינדן שליסל און ווערט אין אַ האַשמאַפּ. די HashMap סטאָרז די שליסל-ווערט פּערז אין די פאָרעם פון אַן מענגע פון נאָודז וואָס יעדער פּאָזיציע איז באטראכט ווי אַ עמער. א עמער איז גאָרנישט אָבער אַן עלעמענט אין אַ מענגע. יעדער נאָדע האט 3 וואַלועס: שליסל, ווערט, און לינק צו די ווייַטער נאָדע. ווען מער ווי 1 נאָדע שאַרעס דער זעלביקער אינדעקס, עס רעפּראַזענץ אַ לינגקט רשימה. יעדער נאָדע איז מאַפּט צו אַן אינדעקס אין די עמער וואָס איז קאַלקיאַלייטיד מיט hashcode ().

האַשמאַפּ אין Javaשפּילקע

האַשמאַפּ פאָרשטעלונג  

די פאָרשטעלונג פון HashMap אין Java דעפּענדס אויף די אונטן פּאַראַמעטערס:

  • ערשט קאַפּאַציטעט - עס דינאַמאַנץ ווי פילע באַקאַץ אַ האַשמאַפּ קענען קראָם ווען עס איז ינישיייטיד. דורך פעליקייַט, עס איז 16 שליסל-ווערט פּערז
  • מאַסע פאַקטאָר - דאָס איז דער פּראָצענט פון קאַפּאַציטעט וואָס דאַרף זיין ינקריסינג. דורך פעליקייַט, עס איז 0.75
  • שוועל - דאָס איז דער פּראָדוקט פון מאַסע פאַקטאָר און קאַפּאַציטעט וועמענס פעליקייַט ווערט איז 12 (16 * 0.75)
  • רעהאַשינג - דאָס איז דער פּראָצעס פון דאַבלינג די קאַפּאַציטעט נאָך עס ריטשאַז אַ שוועל ווערט.
זע אויך
ArrayBlockingQueue אין Java

Java HashMap דעקלאַראַציע  

צו נוצן HashMap אין Java, מיר דאַרפֿן צו אַרייַנפיר java.util.HashMap פּעקל. די סינטאַקס איז ווי אונטן:

HashMap<KeyType,ValueType> map = new HashMap<>();

KeyType - דאָס איז דער טיפּ פון שליסל דאַטן.עג: שטריקל אָדער ינטעגער

וואַלועטיפּע - דאָס איז דער טיפּ פון ווערט דאַטן. למשל: שטריקל אָדער ינטעגער

האַשמאַפּ פֿעיִקייטן  

אונטן זענען די פֿעיִקייטן פון HashMap אין Java:

  • סטאָרז וואַלועס קאָראַספּאַנדינג יעדער שליסל
  • כּולל בלויז יינציק שליסלען
  • קען נישט לאָזן דופּליקאַט שליסלען אָבער קענען האָבן דופּליקאַט וואַלועס
  • עס קען נישט האַלטן קיין סדר, וואָס די סדר אין וואָס די דאַטע איז ינסערטאַד איז נישט די זעלבע ווי די סדר עס איז ריטריווד.
  • עס איז ניט-סינגקראַנייזד

Java HashMap קלאַס קאָנסטרוקטאָרס  

HashMap שטיצט 4 פאַרשידענע קאַנסטראַקטערז ווי איר קענען זען אין די אונטן טיש:

קאָנסטרוקטאָרבאַשרייַבונג
HashMap ()יניטיאַליזעס אַ פעליקייַט האַשמאַפּ
HashMap (Mapm)יניטיאַליזעס די האַשמאַפּ מיט עלעמענטן פון Map m
האַשמאַפּ (ינט קאַפּאַציטעט)יניטיאַליזעס די כאַשמאַפּ מיט די ספּעסאַפייד קאַפּאַציטעט גאַנץ נומער
HashMap (ינט קאַפּאַציטעט, לאָזנ לאָדן פאַקטאָר)יניטיאַליזעס די כאַשמאַפּ מיט די ספּעסאַפייד קאַפּאַציטעט און לאָדן פאַקטאָר

האַשמאַפּ מעטהאָדס  

Java HashMap שטיצט אַלע מעטהאָדס וואָס געהערן צו מאַפּע צובינד, צוזאַמען מיט די מעטהאָדס אין די אונטן טיש

מעטאָדבאַשרייַבונגפּאַראַמעטער
פּאָסל קלאָר ()רימוווז אַלע מאַפּפּינגס אין דעם מאַפּע וואָס מיטל אַז מאַפּע וועט זיין ליידיק
כייפעץ קלאָון ()קערט אַ פּליטקע קאָפּיע פון ​​דעם HashMap בייַשפּיל. שליסל און וואַלועס זיך זענען נישט קלאָונד
באָאָלעאַן כּולל שליסל (כייפעץ שליסל)קערט אמת אויב עס איז אַ מאַפּינג ווערט פֿאַר די ספּעסאַפייד שליסלשליסל - דער שליסל פֿאַר וואָס מיר דאַרפֿן צו צוריקקריגן די ווערט
באָאָלעאַן כּולל ווערט (כייפעץ ווערט)קערט אמת אויב עס איז מאַפּינג שליסל פֿאַר די ספּעסאַפייד ווערטווערט - די ווערט פֿאַר וואָס ספּעציפיצירט שליסל איז מאַפּט
שטעלן entrySet ()רעטורנס אַ באַשטימט מיינונג פון די מאַפּינג פון די מאַפּע
באָאָלעאַן יקוואַלז (כייפעץ אָ)קערט אמת אויב די כייפעץ האט די זעלבע מאַפּינג פון די מאַפּעאָ - די כייפעץ צו זיין קאַמפּערד
ינטעגער באַקומען (כייפעץ שליסל)קערט די ווערט פון די ספּעסאַפייד שליסל אין דער מאַפּע. עס קערט נול אויב עס איז קיין מאַפּינגkey - דער שליסל פֿאַר וואָס ווערט מאַפּינג דאַרף זיין ריטריווד
ינטעגער getOrDefault (כייפעץ שליסל, ינטעגער פעליקייַט ווערט)רעטורנס די ווערט פון די ספּעסאַפייד שליסל אויב מאַפּט, אַנדערש קערט די פעליקייַט ווערט אויב עס איז קיין מאַפּינגשליסל - דער שליסל פֿאַר וואָס מיר באַטראַכטן דאַרף זיין אומגעקערט
defaultvalue - די פעליקייַט ווערט וואָס איז אומגעקערט ווען עס איז קיין מאַפּינג
ינט האַשקאָדע ()רעטורנס די האַשקאָדע ווערט פון די מאַפּע
באָאָלעאַן isEmpty ()קערט אמת איז אַז די כאַשמאַפּ האט קיין קיי-ווערט פּערז
באַשטעטיק קייסעט ()קערט די שטעלן מיינונג פון די שליסלען אין די מאַפּע
ינטעגער שטעלן (שטריקל שליסל, ינט ווערט)אַססאָסיאַטעס די שליסל מיט ווערט. אויב דער שליסל איז שוין פאָרשטעלן, עס ריפּלייסיז די אַלט ווערט מיט נייַע ווערטשליסל - שליסל פֿאַר מאַפּינג
ווערט - ווערט פֿאַר די ספּעסאַפייד שליסל
פּאָסל פּוטאַלל (מאַפּע ב)אַססאָסיאַטעס אַלע שליסל - ווערט מאַפּפּינגס פון עם צו די קראַנט מאַפּעעם - די קאפיעס פון די מאַפּינג צו זיין מוסיף צו די קראַנט מאַפּע
ינטעגער putIfAbsent (שטריקל שליסל, ינטעגער ווערט)אַססאָסיאַטעס די ווערט אויב שוין נישט מאַפּט צו די שליסל אַנדערש קערט דעם קראַנט ווערטשליסל - שליסל פֿאַר מאַפּינג
ווערט - ווערט צו זיין פארבונדן
ינטעגער באַזייַטיקן (כייפעץ שליסל)רימוווז די מאַפּינג פֿאַר די ספּעסאַפייד שליסל אין דער מאַפּעשליסל - דער שליסל אין די מאַפּע פֿאַר וואָס מאַפּינג דאַרף זיין אַוועקגענומען
באָאָלעאַן אַראָפּנעמען (כייפעץ שליסל, כייפעץ ווערט)רימוווז די פּאָזיציע פון ​​די ספּעסאַפייד שליסל בלויז אויב עס איז מאַפּט מיט די ספּעסאַפייד ווערטשליסל - שליסל אין מאַפּע
ווערט - ווערט מאַפּט צו די שליסל
ינטעגער פאַרבייַטן (שטריקל שליסל, ינטעגער ווערט)ריפּלייסיז די ווערט פון די ספּעסאַפייד שליסל מיט די ווערט בלויז אויב עס דערווייַל מאַפּט מיט עטלעכע ווערטשליסל - שליסל אין מאַפּע
ווערט - ווערט צו זיין ריפּלייסט
באָאָלעאַן פאַרבייַטן (שטריקל שליסל, ינטעגער אַלטוואַליו, ינטעגער נייַ ווערט)ריפּלייסיז די פּאָזיציע פון ​​די ספּעסאַפייד שליסל מיט נייַע ווערט נאָר אויב עס איז שוין מאַפּט מיט די ספּעסאַפייד אַלט ווערטשליסל - שליסל אין דער מאַפּע
oldvalue - oldvalue מאַפּט צו שליסל
newvalue - newvalue צו זיין מאַפּט צו די שליסל
ינט גרייס ()קערט די גרייס פון דער מאַפּע
שטריקל צו שטריקל ()רעטורנס אַ שטריקל פאַרטרעטונג פון די מאַפּע
זאַמלונג וואַלועס ()רעטורנס אַ זאַמלונג מיינונג פון וואַלועס פאָרשטעלן אין די מאַפּע
זע אויך
האַשסעט אין Java

האַשמאַפּ עקסעפּטיאָנס  

עס ווארפט ער די ונטער אויסנעמען אין Java:

  • ConcurrentModificationException
  • IllelgalMonitorStateException
  • NullPointerException
  • ינטעררופּטעד עקססעפּטיאָן
  • IllegalArgumentException

אַדדינג עלעמענטן צו HashMap  

ווי איר קענען זען אין די אונטן ביישפּיל, מיר ערשטער שאַפֿן אַ HashMap מיטן נאָמען 'תּלמיד' מיט דער שליסל פון סטרינג טיפּ און ווערט פון ינטעגער טיפּ. דערנאָך מיר לייגן יחיד שליסל-ווערט פּערז ניצן די שטעלן מעטאָד. אין דעם רעזולטאַט איר קענען באַמערקן אַז די סדר אין וואָס די עלעמענטן זענען ריטריווד איז נישט די זעלבע ווי די סדר אין וואָס עס איז געווען ינסערטאַד.

דערנאָך מיר שאַפֿן אַ צווייטע HashMap מיטן נאָמען 'סטו' און דערנאָך לייגן צוויי שליסל-ווערט פּערז. דערנאָך מיר לייג צו די 'תּלמיד' מאַפּע מיט די שטעלן אופֿן.

import java.util.HashMap;
public class HashMapAdd {

  public static void main(String[] args) {
    HashMap<String,Integer> student = new HashMap<>();
    student.put("Arthi", 100);
    student.put("Dev", 105);
    student.put("Banu",102);
    student.put("Rishi", 108);
    System.out.println("Elements in student map:");
    System.out.println(student);
    
    HashMap<String,Integer> stu = new HashMap<>();
    stu.put("Ravi",110);
    stu.put("Tejas", 112);
    System.out.println("Elements in stu map:");
    System.out.println(stu);
    
    student.putAll(stu);
    
    System.out.println("Elements in student map after invoking putAll method:");
    System.out.println(student);
  }

}
Elements in student map:
{Dev=105, Banu=102, Rishi=108, Arthi=100}
Elements in stu map:
{Ravi=110, Tejas=112}
Elements in student map after invoking putAll method:
{Dev=105, Ravi=110, Tejas=112, Banu=102, Rishi=108, Arthi=100}

קאָנטראָלירן צי די מאַפּע כּולל אַ ספּעציפיש שליסל אָדער ווערט  

מיר נוצן containKey מעטאָד צו קאָנטראָלירן צי אַ ספּעציפיש שליסל איז פאָרשטעלן אין די מאַפּע אָדער נישט. אין דעם פאַל, דעוו איז פאָרשטעלן און דעריבער עס קערט אמת און ראַווי איז נישט פאָרשטעלן און דעריבער קערט פאַלש.

סימילאַרלי, containValue מעטאָד טשעקס אויב אַ ספּעציפיש ווערט איז פאָרשטעלן. דאָ, 102 איז פאָרשטעלן אָבער 110 איז נישט פאָרשטעלן און דעריבער קערט פאַלש.

import java.util.HashMap;
public class HashMapAdd {

  public static void main(String[] args) {
    HashMap<String,Integer> student = new HashMap<>();
    student.put("Arthi", 100);
    student.put("Dev", 105);
    student.put("Banu",102);
    student.put("Rishi", 108);
    System.out.println("Elements in student map:");
    System.out.println(student);
    
    System.out.println(student.containsKey("Dev"));
    System.out.println(student.containsKey("Ravi"));
    
    System.out.println(student.containsValue(102));
    System.out.println(student.containsValue(110));
  }

}
Elements in student map:
{Dev=105, Banu=102, Rishi=108, Arthi=100}
true
false
true
false

אַראָפּנעמען און רעפּלאַסע אַ שליסל-ווערט פּאָר  

דאָ, מיר מאַכן אַ hashmap אין Java פון ינטעגער און שטריקל טיפּ צו קראָם שפּראַכן. מיר פאַרבייַטן די 2 ווערט מיט נייַע דאַטן און פאַרבייַטן די 3 ווערט אויב די ספּעציפיש שליסל-ווערט פּאָר איז פאָרשטעלן אין די מאַפּע ניצן פאַרבייַטן () אופֿן.

זע אויך
LinkedBlockingDeque אין Java

דערנאָך מיר באַזייַטיקן די 3 עלעמענט ניצן די שליסל און באַזייַטיקן די 1 עלעמענט ניצן די שליסל ווערט מיט די אַראָפּנעמען () אופֿן.

import java.util.HashMap;
public class RemoveHashMap {

  public static void main(String[] args) {
    HashMap<Integer,String> lang = new HashMap<>();
    lang.put(1, "Java");
    lang.put(2, "C");
    lang.putIfAbsent(3, "C++");
    System.out.println(lang);
    
    lang.replace(2, "PHP");
    System.out.println(lang);
    
    lang.replace(3, "C++", "JavaScript");
    System.out.println(lang);
    
    lang.remove(3);
    System.out.println(lang);
    
    lang.remove(1, "Java");		
    System.out.println(lang);
    
    
  }

}
{1=Java, 2=C, 3=C++}
{1=Java, 2=PHP, 3=C++}
{1=Java, 2=PHP, 3=JavaScript}
{1=Java, 2=PHP}
{2=PHP}

בייַשפּיל פון קלאָר און ליידיק מעטהאָדס  

האַשמאַפּ אין Java ניצט די קלאָר () מעטאָד צו קלאָר די מאַפּינג פון שליסל-ווערט פּערז אין די מאַפּע און יסעמפּטי מעטאָד טשעקס אויב די מאַפּע איז ליידיק. די 1 רעזולטאַט איז פאַלש זינט מאַפּינג איז פאָרשטעלן און 2 רעזולטאַט איז אמת זינט די מאַפּע האט קיין קיי-ווערט פּערז נאָך ינוואָוקינג די קלאָר () אופֿן.

import java.util.HashMap;
public class RemoveHashMap {

  public static void main(String[] args) {
    HashMap<Integer,String> lang = new HashMap<>();
    lang.put(1, "Java");
    lang.put(2, "C");
    
    System.out.println(lang.isEmpty());
    lang.clear();
    
    System.out.println(lang.isEmpty());
    
  }

}
false
true

יטעראַטינג דורך HashMap עלעמענטן מיט entrySet  

צו צוריקקריגן די יחיד שליסל-ווערט פּערז פון HashMap אין Java, מיר קענען נוצן די פּאָזיציע אופֿן פון HashMap צוזאמען מיט די פּאָזיציע מעטאַד פון די מאַפּע צובינד ניצן אַ פֿאַר-יעדער שלייף. די פּאָזיציע מעטהאָדס פון די מאַפּע צובינד האט אַ געבויט-אין מעטהאָדס אַזאַ ווי geyKey () צו באַקומען די שליסל און getValue () צו באַקומען די קאָראַספּאַנדינג ווערט. מיר קענען נוצן די גרייס () אופֿן צו באַקומען די גרייס פון דער מאַפּע.

import java.util.HashMap;
import java.util.Map;
public class IterateHashMap {

  public static void main(String[] args) {
    HashMap<String,String> cityState = new HashMap<>();
    cityState.put("Bangalore", "Karnataka");
    cityState.put("Chennai", "TamilNadu");
    cityState.put("Madurai", "TamilNadu");
    cityState.put("Mumbai", "Maharashtra");
    
    System.out.println("Size of map is : " + cityState.size());
    
    for(Map.Entry<String,String> m : cityState.entrySet())
    {
      System.out.println(m.getKey() + " : " + m.getValue());
    }

  }

}
Size of map is : 4
Chennai : TamilNadu
Madurai : TamilNadu
Mumbai : Maharashtra
Bangalore : Karnataka

שלייף דורך עלעמענטן ניצן קייסעט () און וואַלועס ()  

אן אנדער וועג צו שלייף דורך Hashmap עלעמענטן איז ניצן די קייסעט () מעטאָד. מיט דעם, מיר קענען באַקומען אַ סכום פון אַלע שליסלען סעפּעראַטלי ווי געזען אין די אונטן ביישפּיל. צו באַקומען אַלע וואַלועס סעפּעראַטלי, מיר קענען נוצן די וואַלועס () אופֿן און דרוקן זיי פֿאַר לופּ.

זע אויך
BlockingQueue צובינד אין Java

ניצן קייסעט, מיר קענען אויך דרוקן די שליסל-ווערט פּערז דורך יטערייטינג אין פֿאַר שלייף דורך ניצן באַקומען () אופֿן צו באַקומען די קאָראַספּאַנדינג וואַלועס.

import java.util.HashMap;
import java.util.Map;
public class IterateHashMap {

  public static void main(String[] args) {
    HashMap<String,String> cityState = new HashMap<>();
    cityState.put("Bangalore", "Karnataka");
    cityState.put("Chennai", "TamilNadu");
    cityState.put("Madurai", "TamilNadu");
    cityState.put("Mumbai", "Maharashtra");
    
    System.out.println("Printing only keys:");
    for(String s : cityState.keySet())
    {
      System.out.println(s);
    }
    System.out.println();
    System.out.println("Printing only values: ");
    for(String c : cityState.values())
    {
      System.out.println(c);
    }
    System.out.println();
    System.out.println("Printing both key-value pairs:");
    for(String v : cityState.keySet())
    {
      System.out.println("Key: " + v + " | value: " + cityState.get(v));
    }
  }

}
Printing only keys:
Chennai
Madurai
Mumbai
Bangalore

Printing only values: 
TamilNadu
TamilNadu
Maharashtra
Karnataka

Printing both key-value pairs:
Key: Chennai | value: TamilNadu
Key: Madurai | value: TamilNadu
Key: Mumbai | value: Maharashtra
Key: Bangalore | value: Karnataka

סאָף  

אין דעם טוטאָריאַל, איר האָט געלערנט וועגן HashMap און די פאַרשידענע מעטהאָדס, ווי ביישפילן.

דערמאָנען

1