ஜாவா செட் எடுத்துக்காட்டு  



ஜாவா ஜாவா செட் தொகுப்பு

ஜாவா செட் இடைமுகம் என்பது எந்த நகல் கூறுகளையும் கொண்டிருக்காத உறுப்புகளின் வரிசைப்படுத்தப்படாத தொகுப்பாகும். செட் இடைமுகம் ஜாவாவில் கணித தொகுப்பின் அம்சங்களை வழங்குகிறது. இந்த டுடோரியலில், ஜாவா செட் முறைகள் மற்றும் அவற்றின் பயன்பாடு பற்றிய பல்வேறு ஜாவா செட் எடுத்துக்காட்டுகளை நாங்கள் காண்போம்.

செட் இடைமுகத்தின் அம்சங்கள்  

  • இது தனித்துவமான கூறுகளைக் கொண்டுள்ளது, அதாவது இது நகல் மதிப்புகளை அனுமதிக்காது
  • உறுப்புகளை சேமிப்பதில் ஜாவா செட்டுக்கு எந்த வரிசையும் இல்லை
  • இதற்கு எந்த குறியீடும் இல்லை, எனவே நிலையின் அடிப்படையில் எந்த உறுப்புகளையும் அணுக முடியாது.
  • இது ஒரு இடைமுகம் என்பதால், எந்த செட் செயல்படுத்தல் வகுப்புகளையும் பயன்படுத்தி அதை செயல்படுத்தலாம்
  • சேகரிப்பு இடைமுகத்தை நீட்டிக்கிறது

ஜாவா செட் மற்றும் ஜாவா லிஸ்ட் இடையே வேறுபாடு  

  • ஜாவா செட் என்பது வரிசைப்படுத்தப்படாத உறுப்புகளின் தொகுப்பாகும் பட்டியல் உறுப்புகளின் வரிசைப்படுத்தப்பட்ட தொகுப்பு ஆகும்.
  • செட் குறியீட்டு அடிப்படையிலான அணுகலைக் கொண்டிருக்கவில்லை, ஆனால் பட்டியலில் நாம் கூறுகளை அணுகக்கூடிய ஒரு குறியீட்டைக் கொண்டுள்ளது.
  • தொகுப்பில், நகல் மதிப்புகளைச் சேர்க்க முடியாது, அதே சமயம் நகல் மதிப்புகளைச் சேர்க்க பட்டியல் அனுமதிக்கிறது.

அமலாக்கத்தை அமைக்கவும்  

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

  • ஹேஷ்செட் - தொகுப்பின் வழியாக செல்லும்போது உறுப்புகளின் வரிசை அல்லது வரிசை இல்லை.
  • ட்ரீசெட் - இது வரிசையாக்கத்துடன் உறுப்புகளின் வரிசையை பாதுகாக்கிறது
  • LinkedHashSet - இது செருகும் அதே உறுப்புகளின் வரிசையை பாதுகாக்கிறது
மேலும் காண்க
ஜாவா ஸ்கேனர்

ஜாவாவை அமைக்கவும்முள்

ஜாவா செட் எடுத்துக்காட்டு  

தொகுப்பு இடைமுகத்தை செயல்படுத்த, நாம் java.util ஐ இறக்குமதி செய்ய வேண்டும். * தொகுப்பு வேறு வகுப்பு தொகுப்புகளை தனித்தனியாக இறக்குமதி செய்கிறது.

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetExample {

  public static void main(String[] args) {
    Set set1 = new HashSet();
    Set set2 = new TreeSet();
    Set set3 = new LinkedHashSet();

  }

}

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

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetExample {

  public static void main(String[] args) {
    Set<String> setstring = new HashSet<String>();
    Set<Integer> setint = new TreeSet<Integer>();
  }
}

ஜாவா செட் முறைகள்  

தொகுப்பு கீழே குறிப்பிடப்பட்டுள்ள முறைகளுடன் சேகரிப்பு இடைமுகத்தின் அனைத்து முறைகளையும் உள்ளடக்கியது.

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

விதிவிலக்குகளை அமைக்கவும்  

ஜாவா செட் வீசுகிறது கீழே விதிவிலக்குகள்

  • ஆதரிக்கப்படாத செயல்பாடு
  • பூஜ்ய சுட்டிக்காட்டி விதிவிலக்கு
  • கிளாஸ் காஸ்ட் எக்ஸ்செப்ஷன்
  • சட்டவிரோத ஒழுங்குபடுத்தல்

ஒரு தொகுப்பிலிருந்து கூறுகளைச் சேர்த்து அகற்றவும்  

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

எடுத்துக்காட்டு நீக்குதலில், முதலில் 1 வது தொகுப்பிலிருந்து ஒரு உறுப்பை அகற்றிவிட்டு, பின்னர் இரண்டாவது தொகுப்பிலிருந்து எல்லா உறுப்புகளையும் அகற்றுவோம்.

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetExample {

  public static void main(String[] args) {

    Set<String> setstring = new HashSet<String>();
    setstring.add("Java");
    setstring.add("Javascript");
    System.out.println(setstring);
    
    Set<String> string2 = new HashSet<String>();
    string2.add("C");
    string2.add("C++");
    
    setstring.addAll(string2);
    System.out.println("Elements in set after addAll operation");
    System.out.println(setstring);
    
    setstring.remove("Javascript");
    System.out.println("Elements in the set after remove opertaion");
    System.out.println(setstring);
    
    setstring.removeAll(string2);
    System.out.println("Elements in the set after removeAll opertaion");
    System.out.println(setstring);
    
  }
  

}
Output:
[Java, Javascript]
Elements in set after addAll operation
[Java, C++, C, Javascript]
Elements in the set after remove opertaion
[Java, C++, C]
Elements in the set after removeAll opertaion
[Java]

ட்ரீசெட்டைப் பயன்படுத்தி கூறுகளை வரிசைப்படுத்துதல்  

இங்கே, முழு எண்களின் வரிசையை அறிவித்து, பின்னர் லூப்பைப் பயன்படுத்தி கூறுகளை ஹாஷ்செட்டில் சேர்த்துள்ளோம். வெளியீட்டில், "12" நகல் உறுப்பு சேர்க்கப்படவில்லை என்பதை நீங்கள் காணலாம், இது தொகுப்பு அம்சமாகும். கீழேயுள்ள எடுத்துக்காட்டில் காணப்படுவது போல் ட்ரீசெட்டைப் பயன்படுத்தி ஹாஷ்செட்டின் கூறுகளை நாம் வரிசைப்படுத்தலாம்.

import java.util.*;

public class SetSort {

  public static void main(String[] args) {
    Set<Integer> numbers = new HashSet<Integer>();
    int[] a = {34,78,12,67,45,23,12,89};
    for(int i=0;i<a.length;i++) {
      numbers.add(a[i]);
    }
    System.out.println("Elements in HashSet");
    System.out.println(numbers);
    
    Set<Integer> treeset = new TreeSet<Integer>(numbers);
    System.out.println("Elements in treeset after sort");
    System.out.println(treeset);
  }

}
Output:
Elements in HashSet
[34, 67, 23, 89, 12, 45, 78]
Elements in treeset after sort
[12, 23, 34, 45, 67, 78, 89]

ஜாவா செட்டை வரிசைக்கு மாற்றவும்  

நாம் தொகுப்பை ஒரு ஆக மாற்றலாம் வரிசை கீழே விவரிக்கப்பட்டுள்ளபடி toArray முறையைப் பயன்படுத்தும் உறுப்புகளின்.

import java.util.*;

public class SetArray {

  public static void main(String[] args) {
    Set<String> names = new HashSet<String>();
    names.add("Roshan");
    names.add("Kiran");
    names.add("Tejas");
    names.add("Karthik");
    
    String[] strnames = names.toArray(new String[names.size()]);
    for(String strvalues: strnames) {
      System.out.println(strvalues);
    }

  }

}
Output:
Roshan
Kiran
Tejas
Karthik

எடுத்துக்காட்டு தொகுப்பு செயல்பாடுகளின் ஜாவா நிரல் (யூனியன், குறுக்குவெட்டு மற்றும் வேறுபாடு)  

இந்த எடுத்துக்காட்டில், நாங்கள் 2 முழு எண் தொகுப்புகளை உருவாக்கியுள்ளோம். 2 செட் ஒன்றியத்தைச் செய்ய, நாங்கள் addAll முறையைப் பயன்படுத்துகிறோம், இது இரண்டு தொகுப்புகளிலிருந்தும் அனைத்து தனித்துவமான கூறுகளையும் சேர்க்கும். குறுக்குவெட்டுக்கு, தொகுப்புகளுக்கு இடையில் உள்ள பொதுவான கூறுகளை மட்டுமே தக்கவைத்துக்கொள்ள தக்கவைத்தல் அனைத்து முறையையும் பயன்படுத்துகிறோம். 2 செட்டுகளுக்கு இடையிலான வேறுபாட்டைக் கண்டுபிடிக்க, செட் 2 இல் உள்ள பொதுவான உறுப்புகளுடன் சேர்ந்து செட் 1 இல் உள்ள அனைத்து உறுப்புகளையும் அகற்றும் அனைத்து முறைகளையும் அகற்றுவோம்.

import java.util.*;

public class SetOperations {

  public static void main(String[] args) {
    Set<Integer> set1 = new HashSet<Integer>();
    set1.add(3);
    set1.add(7);
    set1.add(5);
    set1.add(1);
    System.out.println("Set 1 : " + set1);
    
    Set<Integer> set2 = new HashSet<Integer>();
    set2.add(3);
    set2.add(4);
    set2.add(9);
    set2.add(5);
    
    System.out.println("Set 2 : " + set2);
    
    Set<Integer> a = new HashSet<Integer>(set1);
    a.addAll(set2);
    
    System.out.println("Union of Set 1 and Set 2 : " + a);
    
    Set<Integer> b = new HashSet<Integer>(set1);
    b.retainAll(set2);
    System.out.println("Intersection of Set 1 and Set 2 : " + b);
    
    Set<Integer> c = new HashSet<Integer>(set1);
    c.removeAll(set2);
    System.out.println("Difference between Set 1 and Set 2 : " + c);
  }

}
Output:
Set 1 : [1, 3, 5, 7]
Set 2 : [3, 4, 5, 9]
Union of Set 1 and Set 2 : [1, 3, 4, 5, 7, 9]
Intersection of set 1 and set 2 : [3, 5]
Difference between 2 sets : [1, 7]

தீர்மானம்  

இந்த டுடோரியலில், ஜாவாவில் அமைத்தல் மற்றும் வெவ்வேறு கையாளுதல்களுக்கான தொகுப்பை எவ்வாறு உருவாக்குவது மற்றும் பயன்படுத்துவது பற்றி நீங்கள் கற்றுக்கொண்டீர்கள்.

மேலும் காண்க
ஜாவாவில் கணக்கீடுகள்

குறிப்பு

1