હેશમેપ પદ્ધતિઓ જાવા



હેશમેપ જાવા જાવા નકશો

જાવામાં હેશમેપ ક્લાસ ડેટાના સ્વરૂપમાં સ્ટોર કરે છે કી-મૂલ્ય જોડી જ્યાં કી ડેટા અનન્ય હોવો જોઈએ. અમે સંબંધિત કી ડેટાના આધારે મૂલ્યો accessક્સેસ કરી શકીએ છીએ. હેશમેપ જાવાના સંગ્રહ સંગ્રહમાં હાજર છે અને java.util પેકેજનો ભાગ છે. તે હેશિંગ તકનીકના સિદ્ધાંત પર કાર્ય કરે છે.

જાવા હેશમેપ હાયરાર્કી

જાવામાં હેશમેપ વર્ગ લંબાવે છે એબ્સ્ટ્રેક્ટ વર્ગ એબ્સ્ટ્રેક્ટમેપ અને અમલ કરે છે નકશો ઈન્ટરફેસ નીચે બતાવ્યા પ્રમાણે.

જાવામાં હેશમેપ

હેશમેપ સ્ટ્રક્ચર અને કાર્યકારી સિદ્ધાંત

જાવા માં હેશમેપ ના સિદ્ધાંત પર કામ કરે છે હેશીંગ તકનીક. હેશીંગમાં, અમે હેશમેપમાં કી અને મૂલ્યને લિંક કરવા માટે હેશ ફંક્શનનો ઉપયોગ કરીએ છીએ. હેશમેપ કી-મૂલ્યના જોડીઓને એ.ના રૂપમાં સંગ્રહિત કરે છે એરે ગાંઠો જ્યાં દરેક પ્રવેશ ડોલ તરીકે ગણવામાં આવે છે. એક ડોલ એરેમાં તત્વ સિવાય કંઈ નથી. દરેક નોડના 3 મૂલ્યો છે: કી, મૂલ્ય, અને લિંક આગામી નોડ જ્યારે 1 કરતા વધુ નોડ સમાન અનુક્રમણિકાને શેર કરે છે, ત્યારે તે એક કડી થયેલ સૂચિનું પ્રતિનિધિત્વ કરે છે. દરેક નોડને ડોલમાં અનુક્રમણિકામાં મેપ કરવામાં આવે છે જે હેશકોડ () ની મદદથી ગણતરી કરવામાં આવે છે.

જાવામાં હેશમેપ

હેશમેપ પર્ફોર્મન્સ

જાવામાં હેશમેપનું પ્રદર્શન નીચેના પરિમાણો પર આધારીત છે:

  • પ્રારંભિક ક્ષમતા - તે સૂચવે છે કે જ્યારે હેશમેપ પ્રારંભ થાય છે ત્યારે તે કેટલી ડોલથી સંગ્રહિત કરી શકે છે. મૂળભૂત રીતે, તે છે 16 કી-મૂલ્યની જોડી
  • લોડ ફેક્ટર - તે ક્ષમતાની ટકાવારી છે જેને વધારવાની જરૂર છે. મૂળભૂત રીતે, તે છે 0.75
  • થ્રેશોલ્ડ - આ લોડ ફેક્ટર અને ક્ષમતાનું ઉત્પાદન છે, જેનું ડિફ defaultલ્ટ મૂલ્ય છે 12 (16 * 0.75)
  • રીશેશિંગ - થ્રેશોલ્ડ મૂલ્ય સુધી પહોંચ્યા પછી ક્ષમતા બમણી કરવાની આ પ્રક્રિયા છે.

જાવા હેશમેપ ઘોષણા

જાવામાં હેશમેપનો ઉપયોગ કરવા માટે, આપણે આયાત કરવાની જરૂર છે java.util.HashMap પેકેજ વાક્યરચના નીચે મુજબ છે:

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

કી ટાઇપ - તે કી ડેટાનો પ્રકાર છે.Eg: શબ્દમાળા અથવા પૂર્ણાંક

વેલ્યુ ટાઇપ - તે મૂલ્ય ડેટાનો પ્રકાર છે. દા.ત. શબ્દમાળા અથવા પૂર્ણાંક

હેશમેપ સુવિધાઓ

જાવામાં હેશમેપની સુવિધાઓ નીચે છે:

  • સ્ટોર દરેક કીને અનુરૂપ મૂલ્યો
  • ફક્ત અનન્ય કીઓ શામેલ છે
  • ડુપ્લિકેટ કીઓની મંજૂરી આપતું નથી પરંતુ તેમાં ડુપ્લિકેટ મૂલ્યો હોઈ શકે છે
  • તે કોઈપણ ઓર્ડરને જાળવી શકતો નથી, જેનો અર્થ છે કે જે ક્રમમાં ડેટા શામેલ છે તે ર્ડર જેવો નથી જેમાં તે પાછો મેળવવામાં આવે છે.
  • તે બિન-સિંક્રનાઇઝ થયેલ છે

જાવા હેશમેપ ક્લાસ કન્સ્ટ્રકટર્સ

હેશમેપ 4 જુદા જુદા બાંધકામોને ટેકો આપે છે કારણ કે તમે નીચેના કોષ્ટકમાં જોઈ શકો છો:

કન્સ્ટ્રક્ટરવર્ણન
હેશમેપ ()ડિફોલ્ટ હેશમેપ પ્રારંભ કરે છે
હેશમેપ (મેપમ)નકશા એમના તત્વોથી હાશમpપ પ્રારંભ કરે છે
હેશમેપ (પૂર્ણાંક ક્ષમતા)ઉલ્લેખિત ક્ષમતા પૂર્ણાંક મૂલ્ય સાથે હેશમેપ પ્રારંભ કરે છે
હેશમેપ (પૂર્વી ક્ષમતા, ફ્લોટ લોડફેક્ટર)ઉલ્લેખિત ક્ષમતા અને લોડફેક્ટરથી હેશમેપ પ્રારંભ કરે છે

હેશમેપ પદ્ધતિઓ

જાવા હેશમેપ નીચેની કોષ્ટકમાં જણાવેલ પદ્ધતિઓ સાથે તે તમામ પદ્ધતિઓનું સમર્થન કરે છે જે નકશા ઇન્ટરફેસથી સંબંધિત છે

પદ્ધતિવર્ણનપરિમાણ
રદબાતલ સ્પષ્ટ ()આ નકશામાંના બધા મેપિંગ્સ દૂર કરે છે જેનો અર્થ છે કે નકશો ખાલી હશે
Clબ્જેક્ટ ક્લોન ()આ હેશમેપ દાખલાની છીછરી નકલ પરત કરે છે. કી અને મૂલ્યો પોતાને ક્લોન કર્યાં નથી
બુલિયન સમાવે છે કી (keyબ્જેક્ટ કી)જો સ્પષ્ટ કી માટે મેપિંગ મૂલ્ય હોય તો સાચું પરત આપે છેકી - તે કી કે જેના માટે આપણે મૂલ્ય પાછું મેળવવાની જરૂર છે
બુલિયન સમાવે છે વેલ્યુ (valueબ્જેક્ટ મૂલ્ય)જો ત્યાં ઉલ્લેખિત મૂલ્ય માટે કીનો મેપિંગ હોય તો સાચું પરત આપે છેમૂલ્ય - મૂલ્ય કે જેના માટે સ્પષ્ટ કી મેપ કરેલી છે
સેટ કરો એન્ટ્રીસેટ ()નકશાના મેપિંગનું એક સેટ દૃશ્ય આપે છે
બુલિયન બરાબર (ઓબ્જેક્ટ ઓ)જો theબ્જેક્ટમાં નકશાની સમાન મેપિંગ હોય તો સાચું પરત આપે છેઓ - comparedબ્જેક્ટની તુલના કરવી
પૂર્ણાંક મેળવો (keyબ્જેક્ટ કી)નકશામાં નિર્દિષ્ટ કીનું મૂલ્ય આપે છે. જો કોઈ મેપિંગ ન હોય તો તે નલ પરત આવે છેકી - કી જેના માટે મૂલ્ય મેપિંગને પુન beપ્રાપ્ત કરવું પડશે
પૂર્ણાંક getOrDefault (keyબ્જેક્ટ કી, પૂર્ણાંક ડિફોલ્ટ મૂલ્ય)જો મેપ કરેલું હોય તો નિર્દિષ્ટ કીનું મૂલ્ય આપે છે, નહીં તો કોઈ મેપિંગ હોય તો ડિફોલ્ટ મૂલ્ય આપે છેકી - તે કી કે જેના માટે આપણે મૂલ્ય આપીએ છીએ
defaultvalue - જ્યારે મેપિંગ ન હોય ત્યારે પાછા આપવાનું મૂળભૂત મૂલ્ય
પૂર્ણાંક હેશકોડ ()નકશાના હેશકોડ મૂલ્ય પરત કરે છે
બુલિયન ઇમ્પ્ટી છે ()વળતર સાચું એ છે કે હેશમેપમાં કી-મૂલ્યની જોડી નથી
કીસેટ સેટ કરો ()નકશામાં હાજર કીઓનો સેટ દૃશ્ય પરત કરે છે
પૂર્ણાંક મૂકો (શબ્દમાળા કી, પૂર્ણાંક મૂલ્ય)કી સાથે મૂલ્ય જોડે છે. જો કી પહેલેથી હાજર છે, તો તે જૂના મૂલ્યને નવા મૂલ્યથી બદલી દે છેકી - મેપિંગ માટે કી
કિંમત - સ્પષ્ટ કી માટે મૂલ્ય
રદબાતલ પુલ (નકશો એમ)વર્તમાન નકશા પર એમની બધી કી - મૂલ્યના મેપિંગ્સને સાંકળે છેએમ - વર્તમાન નકશામાં ઉમેરવા માટેના મેપિંગની નકલો
પૂર્ણાંક પુટઆઈફએબસેન્ટ (શબ્દમાળા કી, પૂર્ણાંક મૂલ્ય)કી સાથે મેપ કરેલું ન હોય તો મૂલ્યને સાંકળે છે અન્યથા વર્તમાન મૂલ્ય આપે છેકી - મેપિંગ માટે કી
મૂલ્ય - મૂલ્ય જોડવું
પૂર્ણાંક દૂર કરો (keyબ્જેક્ટ કી)નકશામાં નિર્દિષ્ટ કી માટેના મેપિંગને દૂર કરે છેકી - નકશામાંની કી, જેના માટે મેપિંગને દૂર કરવી પડશે
બુલિયન દૂર કરો (keyબ્જેક્ટ કી, valueબ્જેક્ટ મૂલ્ય)નિર્દિષ્ટ કીની એન્ટ્રી દૂર કરે છે જો તે નિર્દિષ્ટ મૂલ્ય સાથે મેપ કરેલું હોયકી - નકશામાં કી
કી - મૂલ્ય કી પર મેપ કરેલું છે
પૂર્ણાંક બદલો (શબ્દમાળા કી, પૂર્ણાંક મૂલ્ય)નિર્દિષ્ટ કીના મૂલ્યને મૂલ્યથી બદલી દે છે જો તે હાલમાં કેટલાક મૂલ્ય સાથે મેપ કરેલું હોયકી - નકશામાં કી
મૂલ્ય - મૂલ્ય બદલવું
બુલિયન બદલો (શબ્દમાળા કી, પૂર્ણાંકનું જૂનું મૂલ્ય, પૂર્ણાંક નવું મૂલ્ય)નિર્દિષ્ટ કીની એન્ટ્રીને નવા મૂલ્ય સાથે જ બદલી લે છે જો તે પહેલાથી જ ઉલ્લેખિત જુના મૂલ્ય સાથે મેપ કરે છેકી - નકશામાં કી
Oldvalue - oldvalue કી પર મેપ કરેલું
newvalue - newvalue ને કી પર મેપ કરવા
પૂર્ણાંક કદ ()નકશાના કદ પરત આપે છે
સ્ટ્રિંગ ટૂ સ્ટ્રિંગ ()નકશાની શબ્દમાળા રજૂઆત પરત કરે છે
સંગ્રહ મૂલ્યો ()નકશામાં હાજર કિંમતોનો સંગ્રહ દૃશ્ય પરત કરે છે

હેશમેપ અપવાદો

તે જાવા નીચેના અપવાદોને ફેંકી દે છે:

  • સમકાલીનમોડિફિકેશન કલ્પના
  • ગેરકાયદેસર મોનિટરસ્ટેક્સેપ્શન
  • નલપોઇન્ટરએક્સેપ્શન
  • વિક્ષેપિત કલ્પના
  • ગેરકાયદેસરકલ્પના

હેશમેપમાં તત્વો ઉમેરવાનું

તમે નીચેના ઉદાહરણમાં જોઈ શકો છો, પહેલા આપણે શબ્દમાળાની કી અને પૂર્ણાંક પ્રકારની કિંમત સાથે 'વિદ્યાર્થી' નામનો હેશમેપ બનાવીએ છીએ. ત્યારબાદ અમે. નો ઉપયોગ કરીને વ્યક્તિગત કી-મૂલ્ય જોડીઓ ઉમેરીશું મૂકી પદ્ધતિ. તમે આઉટપુટમાં નોંધ કરી શકો છો કે જે ક્રમમાં તત્વો પુન areપ્રાપ્ત થાય છે તે ક્રમમાં તે શામેલ કરવામાં આવ્યો તેવો નથી.

આગળ, આપણે 'સ્ટુ' નામનું બીજું હેશમેપ બનાવીશું અને પછી 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}

નકશામાં કોઈ વિશિષ્ટ કી અથવા મૂલ્ય છે કે કેમ તે તપાસો

અમે ઉપયોગ કરીએ છીએ સમાવે છે નકશામાં કોઈ વિશિષ્ટ કી હાજર છે કે કેમ તે તપાસવાની પદ્ધતિ. આ કિસ્સામાં, દેવ હાજર છે અને તેથી તે સાચું પરત આવે છે અને રવિ હાજર નથી અને તેથી ખોટા વળતર આપે છે.

તેવી જ રીતે, સમાવે છે વિશિષ્ટ મૂલ્ય હાજર છે કે નહીં તેની પદ્ધતિ તપાસ કરે છે. અહીં, 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

કી-મૂલ્યની જોડી દૂર કરો અને બદલો

અહીં, આપણે પૂર્ણાંક અને જાવા માં હેશમેપ બનાવીએ છીએ શબ્દમાળા ભાષાઓ સંગ્રહવા માટે ટાઇપ કરો. અમે નવા ડેટા સાથે 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}

સ્પષ્ટ અને ખાલી પદ્ધતિઓનું ઉદાહરણ

જાવામાં હેશમેપ આનો ઉપયોગ કરે છે ચોખ્ખુ() નકશામાં કી-મૂલ્યવાળા જોડીઓના મેપિંગને સાફ કરવાની પદ્ધતિ અને ખાલી છે નકશો ખાલી છે કે નહીં તેની પદ્ધતિ તપાસ કરે છે. પહેલું આઉટપુટ ખોટું છે કારણ કે મેપિંગ હાજર છે અને 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");
    
    System.out.println(lang.isEmpty());
    lang.clear();
    
    System.out.println(lang.isEmpty());
    
  }

}
false
true

એન્ટ્રીસેટનો ઉપયોગ કરીને હેશમેપ તત્વો દ્વારા ફેરવણી

જાવામાં હેશમેપના વ્યક્તિગત કી-મૂલ્યનાં જોડીઓ મેળવવા માટે, આપણે આનો ઉપયોગ કરી શકીએ છીએ એન્ટ્રીસેટ ની સાથે હેશમેપની પદ્ધતિ એન્ટ્રી ની મદદથી નકશા ઇન્ટરફેસની પદ્ધતિ દરેક લૂપ માટે. નકશા ઇન્ટરફેસની એન્ટ્રી પદ્ધતિમાં આંતરિક પદ્ધતિઓ છે જેમ કે 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

કીસેટ () અને મૂલ્યો () નો ઉપયોગ કરીને તત્વો દ્વારા લૂપ કરો

હાશમpપ તત્વો દ્વારા લૂપ કરવાની બીજી રીત છે કીસેટ () પદ્ધતિ. આનો ઉપયોગ કરીને, આપણે નીચેના ઉદાહરણમાં બતાવ્યા પ્રમાણે, બધી કીઓનો સેટ અલગથી મેળવી શકીએ છીએ. બધા કિંમતોને અલગથી મેળવવા માટે, આપણે આનો ઉપયોગ કરી શકીએ છીએ મૂલ્યો () પદ્ધતિ અને તેમને લૂપ માટે છાપો.

કીસેટનો ઉપયોગ કરીને, આપણે લૂપનો ઉપયોગ કરીને પુનરાવર્તિત કરીને કી-વેલ્યુ જોડીઓને પણ છાપી શકીએ છીએ મેળવો () સંબંધિત કિંમતો મેળવવા માટેની પદ્ધતિ.

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

ઉપસંહાર

આ ટ્યુટોરિયલમાં, તમે હેશમapપ અને તેની વિવિધ પદ્ધતિઓ વિશે વિવિધ ઉદાહરણો સાથે શીખ્યા છો.

સંદર્ભ