ஜாவாவில் ஹாஷ்செட்



ஜாவா ஜாவா செட்

ஜாவாவில் ஒரு ஹாஷ்செட் என்றால் என்ன

ஜாவாவில் உள்ள ஹாஷ்செட் என்பது ஒரு வகுப்பாகும் தொகுப்பு இடைமுகம் மற்றும் தரவை ஒரு ஹேஸ்டேபிளில் சேமிக்கிறது. இது java.util தொகுப்பின் ஒரு பகுதியாகும். இது ஹாஷ்செட்டிலிருந்து உறுப்புகளை சேமித்து மீட்டெடுக்க ஹாஷிங் நுட்பத்தைப் பயன்படுத்துகிறது. ஹாஷிங் செயல்பாட்டின் போது, ​​தேவையான குறியீட்டில் உறுப்புகளை சேமிக்க உருவாக்கப்பட்ட ஹாஷ்கோட் மதிப்பை இது பயன்படுத்துகிறது.

ஜாவா ஹாஷ்செட்டின் அம்சங்கள்

  • இது தனித்துவமான மதிப்பை மட்டுமே சேமிக்கிறது, அதாவது இது நகல் மதிப்புகளை அனுமதிக்காது.
  • இது எந்த செருகும் வரிசையையும் பராமரிக்காது, ஏனெனில் இது ஹாஷ்கோட் மதிப்பின் அடிப்படையில் தரவை சேமிக்கிறது.
  • ஹாஷ்செட் பூஜ்ய மதிப்புகளை சேமிக்க அனுமதிக்கிறது.
  • இது ஒத்திசைக்கப்படாதது.
  • ஜாவா ஹாஷ்செட் வகுப்பை அதன் செயல்திறன் வேகமாக இருப்பதால் தேடல் நடவடிக்கைகளுக்கு சிறந்த தேர்வாக பயன்படுத்தப்படலாம்.

ஹாஷ்செட்டின் வரிசைமுறை

ஜாவாவில் ஹாஷ்செட்

ஹாஷ்செட்டில் கட்டமைப்பாளர்கள்

கன்ஸ்ட்ரக்டர்விளக்கம்
ஹாஷ்செட் ()இயல்புநிலை ஹாஷ்செட்டை உருவாக்குகிறது
ஹாஷ்செட் (முழு திறன்)குறிப்பிட்ட திறன் கொண்ட ஹாஷ்செட்டை உருவாக்குகிறது
ஹாஷ்செட் (முழு திறன், மிதவை சுமைபாக்டர்)குறிப்பிட்ட திறன் மற்றும் சுமை காரணி கொண்ட ஹாஷ்செட்டை உருவாக்குகிறது.
ஹாஷ்செட் (தொகுப்பு சி)குறிப்பிட்ட சேகரிப்புடன் ஒரு ஹாஷ்செட்டை உருவாக்குகிறது

ஹாஷ்செட்டில் முறைகள்

கீழே இருக்கும் முறைகள் ஜாவா ஹாஷ்செட் வகுப்பால் ஆதரிக்கப்படுகிறது.

முறைவிளக்கம்துப்புகள்
பூலியன் சேர் (பொருள் இ)குறிப்பிட்ட உறுப்பை தொகுப்பில் சேர்க்கிறதுe - சேர்க்க வேண்டிய உறுப்பு
உறுப்பு ஏற்கனவே இல்லையென்றால் உண்மை அளிக்கிறது
உறுப்பு ஏற்கனவே இருந்தால் தவறானது
பூலியன் addAll (தொகுப்பு c)குறிப்பிட்ட தொகுப்பில் உள்ள அனைத்து கூறுகளையும் சேர்க்கிறதுc - சேர்க்க வேண்டிய கூறுகளைக் கொண்ட தொகுப்பு
வெற்றிட தெளிவு ()தொகுப்பில் உள்ள அனைத்து உறுப்புகளையும் நீக்கி, தொகுப்பை காலியாக ஆக்குகிறது
பொருள் குளோன் ()ட்ரீசெட் நிகழ்வின் ஆழமற்ற நகலை வழங்குகிறது
பூலியன் கொண்டுள்ளது (பொருள் ஓ)தொகுப்பில் குறிப்பிட்ட உறுப்பு இருந்தால் உண்மை அளிக்கிறதுo - தேட வேண்டிய உறுப்பு
பூலியன் அனைத்தையும் கொண்டுள்ளது (தொகுப்பு சி)தொகுப்பில் குறிப்பிடப்பட்டுள்ள அனைத்து கூறுகளும் தொகுப்பில் இருந்தால் உண்மை அளிக்கிறதுc - தேட சேகரிப்பு கூறுகள்
பூலியன் சமம் (பொருள் ஓ)தொகுப்பில் குறிப்பிட்ட பொருளை ஒப்பிடுகிறதுஇருந்தால் உண்மை அளிக்கிறது
இல்லாவிட்டால் பொய்யைத் தருகிறது
பூலியன் isEmpty ()தொகுப்பு காலியாக இருந்தால் எந்த உறுப்புகளும் இல்லை என்றால் உண்மை அளிக்கிறது
Iterator iterator ()ஏறுவரிசையில் உள்ள உறுப்புகள் மீது ஒரு ஈரேட்டரை வழங்குகிறது
பூலியன் அகற்று (பொருள் ஓ)தொகுப்பிலிருந்து குறிப்பிட்ட உறுப்பை நீக்குகிறதுo - அகற்றப்பட வேண்டிய உறுப்பு
பூலியன் அகற்றுதல்அல் (சேகரிப்பு சி)குறிப்பிட்ட தொகுப்பில் உள்ள அனைத்து கூறுகளையும் நீக்குகிறதுc - அகற்றப்பட வேண்டிய கூறுகளின் தொகுப்பு
பூலியன் தக்கவைத்தல் அனைத்தும் (தொகுப்பு சி)தொகுப்பில் குறிப்பிட்ட சேகரிப்பில் உள்ள அனைத்து கூறுகளையும் தக்க வைத்துக் கொண்டு, தொகுப்பில் உள்ள மற்ற கூறுகளை நீக்குகிறதுc - தக்கவைக்க வேண்டிய கூறுகளின் தொகுப்பு
முழு அளவு ()தொகுப்பின் உறுப்புகளின் எண்ணிக்கையான தொகுப்பின் அளவை வழங்குகிறது
Spliterator spliterator ()தொகுப்பில் உள்ள உறுப்புகள் மீது ஸ்ப்ளிடரேட்டரை வழங்குகிறது
பொருள் [] toArray ()தொகுப்பில் உள்ள உறுப்புகளின் வரிசை பிரதிநிதித்துவத்தை வழங்குகிறது
ஸ்ட்ரிங் toString ()தொகுப்பில் உள்ள உறுப்புகளின் சரம் பிரதிநிதித்துவத்தை வழங்குகிறது

எடுத்துக்காட்டு: கூறுகளைச் சேர்க்கவும்

ஐப் பயன்படுத்தி ஜாவா ஹேஷ்செட்டில் கூறுகளைச் சேர்க்க ஒரு எடுத்துக்காட்டு கீழே add() முறை. நாம் பயன்படுத்தி தொகுப்பில் கூறுகளின் தொகுப்பையும் சேர்க்கலாம் addAll() முறை.

import java.util.HashSet;

public class AddHashSetElements {

  public static void main(String[] args) {
    HashSet<Integer> hs = new HashSet<Integer>();
    hs.add(30);
    hs.add(10);
    hs.add(20);
    hs.add(40);
    
    System.out.println("Elements in the HashSet after add operation: " + hs);
    
    HashSet<Integer> h = new HashSet<Integer>();
    h.add(60);
    h.add(50);
    
    hs.addAll(h);
    
    System.out.println("ELements in the HashSet after addAll operation: " + hs);
    

  }

}
Elements in the HashSet after add operation: [20, 40, 10, 30]
ELements in the HashSet after addAll operation: [50, 20, 40, 10, 60, 30]

எடுத்துக்காட்டு: கூறுகளை அகற்று

ஜாவாவில் உள்ள ஹாஷ்செட்டிலிருந்து உறுப்புகளை எவ்வாறு அகற்றுவது என்பதை கீழே உள்ள எடுத்துக்காட்டு காட்டுகிறது remove() முறை. உறுப்புகளின் தொகுப்பை அகற்ற, நாம் பயன்படுத்தலாம் removeAll() முறை, மற்றும் சேகரிப்பு கூறுகளை மட்டுமே தக்க வைத்துக் கொள்ள நாம் பயன்படுத்தலாம் retainAll() முறை.

import java.util.HashSet;

public class RemoveHashSetElements {

  public static void main(String[] args) {
    HashSet<Integer> hs = new HashSet<Integer>();
    hs.add(30);
    hs.add(10);
    hs.add(20);
    hs.add(40);
    
    HashSet<Integer> h = new HashSet<Integer>();
    h.add(60);
    h.add(50);
    hs.addAll(h);
    
    System.out.println("Elements in the HashSet: " + hs);
    
    hs.remove(30);
    System.out.println("Elements in the HashSet after remove method: " + hs);
    
    hs.retainAll(h);
    System.out.println("Elements in the HashSet after retainAll method: " + hs);

    hs.removeAll(h);
    System.out.println("Elements in the HashSet after removeAll method: " + hs);

  }

}
Elements in the HashSet: [50, 20, 40, 10, 60, 30]
Elements in the HashSet after remove method: [50, 20, 40, 10, 60]
ELements in the HashSet after retainAll method: [50, 60]
Elements in the HashSet after removeAll method: []

எடுத்துக்காட்டு: ஹாஷ்செட்டை அழித்து காலியாக இருந்தால் சரிபார்க்கவும்

ஐப் பயன்படுத்தி ஹாஷ்செட்டை அழிக்க முடியும் clear() தொகுப்பிலிருந்து அனைத்து உறுப்புகளையும் நீக்கும் முறை. தி isEmpty() ஹாஷ்செட் காலியாக இருக்கிறதா இல்லையா என்பதை முறை சரிபார்க்கிறது.

import java.util.HashSet;

public class RemoveHashSetElements {

  public static void main(String[] args) {
    HashSet<Integer> hs = new HashSet<Integer>();
    hs.add(30);
    hs.add(10);
    hs.add(20);
    hs.add(40);
    
    System.out.println("Elements in the HashSet: " + hs);
    System.out.println("Size of the HashSet: " + hs.size());
    
    hs.clear();
    System.out.println("Is HashSet empty: " + hs.isEmpty());

  }

}
Elements in the HashSet: [20, 40, 10, 30]
Size of the HashSet: 4
Is HashSet empty: true

எடுத்துக்காட்டு: கூறுகள் இருக்கிறதா என்று சோதிக்கவும்

கீழே உள்ள எடுத்துக்காட்டு பயன்படுத்துகிறது contains() ஹாஷ்செட்டில் குறிப்பிட்ட உறுப்பு இருக்கிறதா என்று சோதிக்கும் முறை. நாம் பயன்படுத்தலாம் containsAll() தொகுப்பில் உறுப்புகளின் தொகுப்பு இருக்கிறதா என்று சோதிக்கும் முறை.

import java.util.HashSet;
public class CheckElement {

  public static void main(String[] args) {
    HashSet<String> city = new HashSet<String>();
    city.add("Bangalore");
    city.add("Chennai");
    city.add("Delhi");
    city.add("Mumbai");
    
    System.out.println("Elements in the HashSet: " + city);
    System.out.println("Check if Chennai exist: " + city.contains("Chennai"));
    System.out.println("Check if Hyderabad exist: " + city.contains("Hyderabad"));
    
    HashSet<String> c = new HashSet<String>();
    c.add("Hyderabad");
    c.add("Jaipur");
    
    city.addAll(c);
    System.out.println("Elements after addAll method: " + city);
    System.out.println("Check if collection exist: " + city.containsAll(c));
  }

}
Elements in the HashSet: [Delhi, Chennai, Mumbai, Bangalore]
Check if Chennai exist: true
Check if Hyderabad exist: false
Elements after addAll method: [Delhi, Chennai, Jaipur, Mumbai, Hyderabad, Bangalore]
Check if collection exist: true

எடுத்துக்காட்டு: ஹாஷ்செட் கூறுகள் மீது இட்ரேட்

ஜாவாவில் உள்ள ஹாஷ்செட்டில் உள்ள உறுப்புகள் வழியாக நாம் பயணிக்க முடியும் iterator() முறை. அதையே விளக்குவதற்கு கீழே ஒரு எடுத்துக்காட்டு.

import java.util.HashSet;
import java.util.Iterator;
public class IterateHashSet {

  public static void main(String[] args) {
    HashSet<String> names = new HashSet<String>();
    names.add("Ravi");
    names.add("Rakesh");
    names.add("Suresh");
    names.add("Dinesh");
    
    Iterator<String> it = names.iterator();
    while(it.hasNext())
      System.out.println(it.next());

  }

}
Suresh
Ravi
Dinesh
Rakesh

 

குறிப்பு