מאַפּע אין Java



ז'אבא Java מאפע

מאַפּע צובינד אין Java

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

פֿעיִקייטן פון Java Map

  • כּולל בלויז יינציק שליסלען און ניט דערלויבן סטאָרידזש דופּליקאַט שליסלען.
  • יעדער שליסל מאַפּס בלויז איין ווערט
  • דער סדר פון דאַטן דעפּענדס אויף די מאַפּע ימפּלאַמענטיישאַן.
  • עס זענען 5 קלאסן וואָס ימפּלאַמענאַד די מאַפּע צובינד: HashMap, EnumMap, LinkedHashMap, WeakHashMap און TreeMap.
  • עס זענען 3 ינטערפייסיז וואָס פאַרברייטערן די מאַפּע צובינד: SortedMap, NavigableMap און ConcurrentMap.

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

מאַפּע אין Java

מעטהאָדס פון Java Map

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

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

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

האַשמאַפּ

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

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

  public static void main(String[] args) {
    Map<Integer,String> m = new HashMap<Integer,String>();
    m.put(1, "Chennai");
    m.put(2,"Bangalore");
    m.put(3, "Delhi");
    
    System.out.println(m);
  }

}
{1=Chennai, 2=Bangalore, 3=Delhi}

לינקעדהאַשמאַפּ

לינקעדהאַשמאַפּ ימפּלאַמאַנץ אַ לינקעדיסט דאַטן סטרוקטור און דעריבער מיינט ינסערשאַן סדר. דאָס יקסטענדז די HashMap קלאַס. עס ניצט אַ טאָפּל לינקעדיסט צו דורכפאָר אָדער יטעראַטע דורך אַלע די נאָודז.

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapDemo {

  public static void main(String[] args) {
    Map<Integer, String> m = new LinkedHashMap<Integer, String>();
    m.put(1, "Chennai");
    m.put(2, "Bangalore");
    m.put(3, "Delhi");
    
    System.out.println(m);
  }

}
{1=Chennai, 2=Bangalore, 3=Delhi}

ענוממאַפּ

EnumMap איז אַ ספּעציעל ימפּלאַמענטיישאַן פון די מאַפּע צובינד וואָס איז געניצט פֿאַר די נומעראַטיאָן אָדער ענום data type. עס מיינטיינז די נאַטירלעך סאָרטירונג סדר באזירט אויף די שליסלען. יעדער שליסל אין אַן EnumMap איז אַ בייַשפּיל פון יעדער Enum דאַטן.

import java.util.EnumMap;

enum Speed {
  LOW, MEDIUM, HIGH
}
public class EnumMapDemo {

  public static void main(String[] args) {
    EnumMap<Speed, String> e = new EnumMap<Speed, String>(Speed.class);
    e.put(Speed.LOW, "Low");
    e.put(Speed.MEDIUM, "Medium");
    e.put(Speed.HIGH, "High");
    
    System.out.println("Size of EnumMap: " + e.size());
    System.out.println("Values in EnumMap" + e);

  }

}
Size of EnumMap: 3
Values in EnumMap{LOW=Low, MEDIUM=Medium, HIGH=High}

וויקאַשאַשמאַפּ

א WeakHashMap איז ענלעך צו אַ HashMap אָבער האט בלויז שוואַך באַווייַזן צו זיין שליסלען. דעם מיטל אויב עס ניט מער האָבן אַ שטאַרק דערמאָנען צו די כייפעץ פון דער שליסל, דער Java מעמאָרי פאַרוואַלטער וועט באַזייַטיקן דעם פּאָזיציע פֿון דער מאַפּע.

טרעעמאַפּ

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

import java.util.Map;
import java.util.TreeMap;

public class TreeMapDemo {

  public static void main(String[] args) {
    Map<Integer, String> m = new TreeMap<Integer, String>();
    m.put(1, "Sharma");
    m.put(2, "Sabarish");
    m.put(3, "Rakesh");
    
    System.out.println(m);

  }

}
{1=Sharma, 2=Sabarish, 3=Rakesh}

ינטערפייסיז וואָס פאַרברייטערן די מאַפּע צובינד

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

SortedMap

די SortedMap מיינט אַ נאַטירלעך סאָרטינג סדר באזירט אויף די שליסלען. דער טרעעמאַפּ קלאַס ימפּלאַמאַנץ די סאָרטעדמאַפּ צובינד. מיר קענען אויך סאָרט די יסודות באזירט אויף די קאָמפּאַראַטאָר. עס קען נישט לאָזן שטאַרק נול שליסלען אָדער וואַלועס.

NavigableMap

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

קאָנקוררענטמאַפּ

קאָנקוררענטמאַפּ איז אַ ספּעציעל מאַפּע צובינד וואָס כאַנדאַלז קאַנקעראַנט אַקסעס אָן אַפעקטינג די קאָנסיסטענסי פון די איינסן אין דער מאַפּע. די ConcurrentHashMap און ConcurrentSkipListMap ימפּלאַמאַנץ דעם צובינד.

Map.Entry צובינד

פּאָזיציע איז אן אנדער סאַב-ינטערפרייד פון מאַפּע וואָס מיר נוצן צו באַקומען שליסלען און וואַלועס. מיר קענען אַקסעס דאָס מיט די Map.Entry נאָמען. דעם צובינד גיט מעטהאָדס צו באַקומען און שטעלן שליסל און וואַלועס, למשל: געטקיי (), געטוואַלעו (), סעטוואַלוע (), עטק.

עס זענען אויך אנדערע מעטהאָדס וואָס ווייַזן די זאַמלונג מיינונג אין אַסענדינג און אַראָפּגיין סדר מיט די קאָמפּאַרינגבייקיי () און קאָמפּאַרינגביוואַלוע ().

בייַשפּיל: ComparingByKey אופֿן

ונטער איז אַ ביישפּיל פון ניצן די ComparingByKey מעטהאָדס פון די Map.Entry צובינד צו סאָרט אַרויף און אַראָפּגיין, באזירט אויף די שליסלען.

import java.util.*;

public class ComparingByKeyDemo {

  public static void main(String[] args) {
    Map<Integer, String> m = new HashMap<Integer, String>();
    m.put(1, "Anu");
    m.put(2, "Ravi");
    m.put(3, "Chaitanya");
    
    //Print in ascending order
    System.out.println("Ascending order");
    m.entrySet()
    .stream()
    .sorted(Map.Entry.comparingByKey())
    .forEach(System.out:: println);
    
    //Print in descending order
    System.out.println("Descending order");
    m.entrySet()
    .stream()
    .sorted(Map.Entry.comparingByKey(Comparator.reverseOrder()))
    .forEach(System.out:: println);

  }

}
Ascending order
1=Anu
2=Ravi
3=Chaitanya
Descending order
3=Chaitanya
2=Ravi
1=Anu

בייַשפּיל: CompareByValue אופֿן

ונטער איז אַ ביישפּיל פון די CompareByValue מעטהאָדס פון די Map.Entry צובינד צו סאָרט אַרויף און אַראָפּגיין, באזירט אויף די וואַלועס.

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

public class ComparingByValueDemo {

  public static void main(String[] args) {
      Map<Integer, String> m = new HashMap<Integer, String>();
      m.put(1, "Anu");
      m.put(2, "Ravi");
      m.put(3, "Chaitanya");
      
      //Print in ascending order
      System.out.println("Ascending order");
      m.entrySet()
      .stream()
      .sorted(Map.Entry.comparingByValue())
      .forEach(System.out:: println);
      
      //Print in descending order
      System.out.println("Descending order");
      m.entrySet()
      .stream()
      .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
      .forEach(System.out:: println);
      

  }

}
Ascending order
1=Anu
3=Chaitanya
2=Ravi
Descending order
2=Ravi
3=Chaitanya
1=Anu

 

דערמאָנען