HashMap მეთოდები ჯავა



HashMap Java ჯავის რუკა

HashMap კლასი Java- ში ინახავს მონაცემებს საკვანძო მნიშვნელობა წყვილი, სადაც ძირითადი მონაცემები უნდა იყოს უნიკალური. მნიშვნელობებზე წვდომა შეგვიძლია შესაბამისი ძირითადი მონაცემების საფუძველზე. HashMap იმყოფება Java- ს კოლექციის ჩარჩოში და არის java.util პაკეტის ნაწილი. იგი მუშაობს ჰაშინგის ტექნიკის პრინციპზე.

Java HashMap იერარქია

HashMap კლასი ჯავაში ვრცელდება აბსტრაქტული კლასი რეზიუმე რუკა და ახორციელებს რუკა ინტერფეისი, როგორც ნაჩვენებია ქვემოთ.

HashMap ჯავაში

HashMap სტრუქტურა და მუშაობის პრინციპი

HashMap ჯავაში მუშაობს პრინციპით ჰასინგი ტექნიკა. ჰაშირებისას ვიყენებთ ჰეშის ფუნქციებს HashMap- ში გასაღებისა და მნიშვნელობის დასაკავშირებლად. HashMap ინახავს საკვანძო მნიშვნელობის წყვილებს სახით მასივი კვანძების, სადაც თითოეული ჩანაწერი ითვლება ვედროდ. ვედრო სხვა არაფერია, თუ არა მასივის ელემენტი. თითოეულ კვანძს აქვს 3 მნიშვნელობა: ძირითადი, მნიშვნელობა, და ბმული შემდეგი კვანძი როდესაც 1-ზე მეტი კვანძი იზიარებს ერთსა და იმავე ინდექსს, ეს წარმოადგენს დაკავშირებულ სიას. ყველა კვანძი აისახება ვედროში ინდექსზე, რომელიც გამოითვლება hashcode () - ის გამოყენებით.

HashMap ჯავაში

HashMap შესრულება

HashMap- ის შესრულება Java- ში დამოკიდებულია ქვემოთ მოცემულ პარამეტრებზე:

  • საწყისი მოცულობა - ეს აღნიშნავს რამდენი თაიგულის შენახვა შეუძლია HashMap– ს, როდესაც ხდება მისი ინიციალიზაცია. სტანდარტულად, ეს არის 16 გასაღები-მნიშვნელობის წყვილი
  • დატვირთვის ფაქტორი - ეს არის შესაძლებლობების პროცენტი, რომელიც უნდა გაიზარდოს. სტანდარტულად, ეს არის 0.75
  • ბარიერი - ეს არის დატვირთვის ფაქტორისა და სიმძლავრის პროდუქტი, რომლის ნაგულისხმევი მნიშვნელობაა 12 (16 * 0.75)
  • Rehashing - ეს არის სიმძლავრის გაორმაგების პროცესი, მას შემდეგ რაც იგი მიაღწევს ზღურბლურ მნიშვნელობას.

Java HashMap დეკლარაცია

იმისათვის, რომ გამოვიყენოთ HashMap Java- ში, საჭიროა იმპორტი java.util.HashMap პაკეტი სინტაქსი მოცემულია ქვემოთ:

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

ძირითადი ტიპი - ეს არის ძირითადი მონაცემების ტიპიეგ.: სიმებიანი ან მთელი რიცხვი

ValueType - ეს არის მნიშვნელობის მონაცემთა ტიპი. მაგ: სიმებიანი ან მთელი რიცხვი

HashMap თვისებები

ქვემოთ მოცემულია HashMap– ის მახასიათებლები ჯავაში:

  • ინახავს თითოეული გასაღების შესაბამის მნიშვნელობებს
  • შეიცავს მხოლოდ უნიკალურ გასაღებებს
  • არ იძლევა დუბლიკატის გასაღებებს, მაგრამ შეიძლება ჰქონდეს დუბლირებული მნიშვნელობები
  • იგი არ ინახავს რაიმე წესრიგს, რაც ნიშნავს, რომ მონაცემთა ჩასმის თანმიმდევრობა არ არის იგივე, რაც მისი მოძიების თანმიმდევრობით.
  • ეს არ არის სინქრონიზებული

Java HashMap კლასის კონსტრუქტორები

HashMap მხარს უჭერს 4 სხვადასხვა კონსტრუქტორს, როგორც ხედავთ ქვემოთ მოცემულ ცხრილში:

კონსტრუქტორიაღწერა
HashMap ()იწყებს ნაგულისხმევ HashMap- ს
HashMap (რუქა)იწყებს ჰეშმპის რუკას Map m ელემენტებით
HashMap (ტევადობა)იწყებს ჰეშმაპის მითითებულ სიმძლავრის მთელი მნიშვნელობის მნიშვნელობას
HashMap (შიდა სიმძლავრე, float loadfactor)ინიციალებს ჰეშმაპს მითითებული სიმძლავრით და loadfactor- ით

HashMap მეთოდები

Java HashMap მხარს უჭერს ყველა მეთოდს, რომელიც ეკუთვნის Map ინტერფეისს, ქვემოთ მოცემულ ცხრილში აღნიშნულ მეთოდებთან ერთად

მეთოდიაღწერაპარამეტრი
ბათილია გასაგები ()შლის ამ რუკის ყველა რუკას, რაც ნიშნავს, რომ რუკა ცარიელი იქნება
ობიექტის კლონი ()აბრუნებს ამ HashMap ინსტანციის ზედაპირულ ასლს. გასაღები და ღირებულებები არ არის კლონირებული
ლოგიკური შეიცავს გასაღები (ობიექტის გასაღები)უბრუნდება true თუ მითითებული გასაღებისთვის არის რუკების მნიშვნელობაგასაღები - გასაღები, რომლისთვისაც საჭიროა მნიშვნელობის აღდგენა
ლოგიკური შეიცავს ღირებულებას (ობიექტის მნიშვნელობა)უბრუნდება true თუ მითითებულია მნიშვნელობის გასაღების ასახვამნიშვნელობა - მნიშვნელობა, რომლისთვისაც მითითებულია მითითებული გასაღები
დაყენება entrySet ()აბრუნებს რუკის ასახვის მითითებულ ხედს
ლოგიკური ტოლი (ობიექტი o)უბრუნდება true თუ ობიექტს აქვს რუქის იგივე ასახვაo - შესადარებელი ობიექტი
მთელი რიცხვის მიღება (ობიექტის გასაღები)აბრუნებს მითითებული გასაღების მნიშვნელობას რუკაზე. იგი უბრუნდება ნულს, თუ არ არის ასახვაგასაღები - გასაღები, რომლისთვისაც უნდა იქნას მოძიებული მნიშვნელობის ასახვა
მთელი რიცხვი getOrDefault (ობიექტის გასაღები, მთელი მნიშვნელობის ნაგულისხმევი მნიშვნელობა)აბრუნებს მითითებული გასაღების მნიშვნელობას, თუ ასახულია, წინააღმდეგ შემთხვევაში უბრუნდება ნაგულისხმევი მნიშვნელობა, თუ არ არის ასახვაგასაღები - გასაღები, რომლისთვისაც ჩვენ ვაფასებთ, უნდა დაუბრუნდეს
defaultvalue - ნაგულისხმევი მნიშვნელობა, რომელიც უნდა დაუბრუნდეს, როდესაც არ არის ასახვა
int hashCode ()აბრუნებს რუკის ჰეშკოდის მნიშვნელობას
ლოგიკური არის ცარიელი ()ბრუნდება მართალია, ჰეშმაპს არ აქვს საკვანძო მნიშვნელობის წყვილი
მითითებული keySet ()აბრუნებს რუკაში არსებული გასაღებების მითითებულ ხედს
მთელი რიცხვი (სიმების გასაღები, int მნიშვნელობა)ასოცირდება გასაღები მნიშვნელობასთან. თუ გასაღები უკვე არსებობს, ის ანაცვლებს ძველ მნიშვნელობას ახალი მნიშვნელობითგასაღები - გასაღები რუკების შედგენისთვის
მნიშვნელობა - მნიშვნელობა მითითებული გასაღებისთვის
ბათილი ყველა (რუქა m)ასოცირდება მ-ის ყველა მნიშვნელოვანი მნიშვნელობის ასახვა მიმდინარე რუკაზემ - რუკის ასლები, რომლებიც დაემატება მიმდინარე რუკას
მთელი putIfAbsent (სიმების გასაღები, მთელი რიცხვის მნიშვნელობა)ასოცირებს მნიშვნელობას, თუ ის გასაღებამდე არ არის შეტანილი, სხვა დააბრუნებს მიმდინარე მნიშვნელობასგასაღები - გასაღები რუკების შედგენისთვის
მნიშვნელობა - მნიშვნელობა, რომელიც ასოცირდება
მთელი რიცხვის ამოღება (ობიექტის გასაღები)ხსნის რუკაში მითითებული გასაღების რუკებსგასაღები - გასაღები რუქაზე, რომლისთვისაც საჭიროა რუკების ამოღება
ლოგიკური ამოღება (ობიექტის გასაღები, ობიექტის მნიშვნელობა)ხსნის მითითებული გასაღების ჩანაწერს მხოლოდ იმ შემთხვევაში, თუ ის ასახულია მითითებული მნიშვნელობითგასაღები - გასაღები რუკაზე
მნიშვნელობა - გასაღები, რომელიც გამოსახულია გასაღებაზე
მთელი რიცხვის ჩანაცვლება (სიმების გასაღები, მთელი მნიშვნელობის მნიშვნელობა)შეცვლის მითითებული გასაღების მნიშვნელობას მხოლოდ იმ შემთხვევაში, თუ ის ამჟამად გარკვეული მნიშვნელობითაა ასახულიგასაღები - გასაღები რუკაზე
მნიშვნელობა - შესაცვლელი მნიშვნელობა
ლოგიკური ჩანაცვლება (სიმების გასაღები, მთელი ძველი ძველი, მთელი ახალი მნიშვნელობის)შეცვლის მითითებული გასვლის შესვლას ახალი მნიშვნელობით მხოლოდ იმ შემთხვევაში, თუ ის უკვე ასახულია მითითებული ძველი მნიშვნელობითგასაღები - გასაღები რუკაზე
oldvalue - გასაღები
newvalue - newvalue გასაღებად ასახული
int ზომა ()აბრუნებს რუკის ზომას
სიმებიანი toString ()აბრუნებს რუკის სტრიქონულ წარმოდგენას
კოლექციის მნიშვნელობები ()აბრუნებს რუკაში არსებული მნიშვნელობების კრებულს

HashMap გამონაკლისები

ეს ქვემოთ მოყვანილ გამონაკლისებს აჩენს Java- ში:

  • ერთდროული მოდიფიკაცია გამონაკლისი
  • IllelgalMonitorStateException
  • NullPointerException
  • შეწყვეტილი გამონაკლისი
  • IllegalArgumentException

ელემენტების დამატება HashMap- ში

როგორც ხედავთ ქვემოთ მოცემულ მაგალითში, პირველ რიგში, ჩვენ ვქმნით HashMap სახელწოდებით 'student', სიმების ტიპის გასაღებით და მთელი ტიპის ტიპის მნიშვნელობით. შემდეგ ჩვენ ვუმატებთ საკვანძო მნიშვნელობის ინდივიდუალურ წყვილებს ბოლო მეთოდი გამოცემაში შეგიძლიათ შეამჩნიოთ, რომ ელემენტების მოძიების თანმიმდევრობა არ არის იგივე, რაც ჩასმული იყო.

შემდეგ, ჩვენ ვქმნით მეორე HashMap სახელწოდებით 'stu' და შემდეგ ვამატებთ 2 საკვანძო მნიშვნელობის წყვილს. შემდეგ მას ვამატებთ "სტუდენტის" რუქას დააყენა ყველა მეთოდი.

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}

შეამოწმეთ, შეიცავს თუ არა რუქა კონკრეტულ გასაღებს ან მნიშვნელობას

ჩვენ ვიყენებთ შეიცავს გასაღები მეთოდი, რათა გადაამოწმონ, არის თუ არა კონკრეტული გასაღები რუკაში. ამ შემთხვევაში, Dev იმყოფება და, შესაბამისად, ის ბრუნდება ჭეშმარიტი და Ravi არ არის და, შესაბამისად, ცრუ ხდება.

ანალოგიურად, შეიცავს ღირებულებას მეთოდი ამოწმებს, არის თუ არა კონკრეტული მნიშვნელობა. აქ, 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

ამოიღეთ და შეცვალეთ საკვანძო მნიშვნელობის წყვილი

აქ, ჩვენ ვქმნით ჰეშმაპს Java- ში Integer და სიმებიანი აკრიფეთ ენების შესანახად. ჩვენ ვანაცვლებთ მე –2 მნიშვნელობას ახალი მონაცემებით და ვანაცვლებთ მე –3 მნიშვნელობას, თუ გასაღები – მნიშვნელობის წყვილი შედგენილია რუკაზე შეცვლა () მეთოდი.

შემდეგ, ჩვენ ამოვიღებთ მე -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}

ნათელი და ცარიელი მეთოდების მაგალითი

HashMap ჯავაში იყენებს გასაგები () მეთოდი გასაგებად გასაღები მნიშვნელობის წყვილების რუკების შედგენაზე და ცარიელია მეთოდი ამოწმებს რუკა ცარიელია. 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- ის საკვანძო მნიშვნელობის ინდივიდუალური წყვილების აღსადგენად, ჩვენ შეგვიძლია გამოვიყენოთ შესვლის დაყენება HashMap– ის მეთოდი ერთად Entry რუქის ინტერფეისის მეთოდი ა თითოეული მარყუჟისთვის. რუქის ინტერფეისის შესვლის მეთოდს აქვს ჩაშენებული მეთოდები, როგორიცაა 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

ელემენტების გადახვევა keySet () და მნიშვნელობების გამოყენებით

Hashmap ელემენტების გადახვევის კიდევ ერთი გზაა keySet () მეთოდი ამის გამოყენებით, ჩვენ შეგვიძლია მივიღოთ ყველა გასაღების კომპლექტი ცალკე, როგორც ჩანს ქვემოთ მოცემულ მაგალითში. ყველა მნიშვნელობის ცალკე მისაღებად შეგვიძლია გამოვიყენოთ მნიშვნელობები () მეთოდი და ბეჭდვა მათ მარყუჟისთვის.

KeySet– ის გამოყენებით, ჩვენ ასევე შეგვიძლია დაბეჭდოთ გასაღები მნიშვნელობის წყვილები მარყუჟის განმეორებით გამოყენებით მიიღეთ () მეთოდი შესაბამისი მნიშვნელობების მისაღებად.

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- ს და მის სხვადასხვა მეთოდებს, სხვადასხვა მაგალითებთან ერთად.

Reference