ஜாவா செட்

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

ஜாவா செட் என்றால் என்ன

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

செயலாக்கங்களை அமைக்கவும்

ஜாவா செட் என்பது ஒரு இடைமுகம், எனவே பொருட்களை உருவாக்க அதன் செயலாக்கங்களில் ஒன்றை நீங்கள் பயன்படுத்த வேண்டும். இவை ஹாஷ்செட் , ட்ரீசெட் மற்றும் லிங்க்ட்ஹாஷ்செட் . Set s இல் , ஒவ்வொரு உறுப்பும் ஒரே ஒரு நிகழ்வில் சேமிக்கப்படும், மேலும் Set இன் வெவ்வேறு செயலாக்கங்கள் கூறுகளைச் சேமிப்பதற்கு வெவ்வேறு வரிசையைப் பயன்படுத்துகின்றன. ஒரு HashSet இல் , உறுப்புகளின் வரிசை சிக்கலான வழிமுறையால் தீர்மானிக்கப்படுகிறது. சேமிப்பக வரிசை உங்களுக்கு முக்கியமானதாக இருந்தால், TreeSet கொள்கலனைப் பயன்படுத்தவும், இது ஒப்பீட்டு வரிசையில் ஏறுவரிசையில் வரிசைப்படுத்தப்பட்ட பொருட்களை சேமிக்கும் அல்லது LinkedHashSet ஐப் பயன்படுத்தவும்., இது கூடுதல் வரிசையில் உறுப்புகளை சேமிக்கிறது. மெம்பர்ஷிப் சோதனைக்கு செட்கள் பெரும்பாலும் பயன்படுத்தப்படுகின்றன, இதனால் ஒரு பொருள் கொடுக்கப்பட்ட தொகுப்பிற்கு சொந்தமானதா என்பதை நீங்கள் எளிதாகச் சரிபார்க்கலாம், எனவே நடைமுறையில் வேகமாகத் தேடுவதற்கு உகந்ததாக இருக்கும் ஹாஷ்செட் செயலாக்கம் பொதுவாகத் தேர்ந்தெடுக்கப்படுகிறது. ஹாஷ்செட் என்பது ஹேஷ்கோட்() முறை மூலம் கிடைக்கும் ஹாஷ் மதிப்புகளைப் பயன்படுத்தும் ஒரு தொகுப்பாகும் . அதாவது, HashSet<E> க்குள் , HashMap<E, Object> பொருள் சேமிக்கப்படுகிறது, இது HashSet இன் மதிப்புகளை விசைகளாக சேமிக்கிறது. ஹாஷ் குறியீடுகளைப் பயன்படுத்துவது, தொகுப்பிலிருந்து உறுப்புகளை விரைவாகத் தேட, சேர்க்க மற்றும் அகற்ற உங்களை அனுமதிக்கிறது . LinkedHashSet ஒரு HashSetஇது இணைக்கப்பட்ட பட்டியலில் உள்ள உறுப்புகளையும் சேமிக்கிறது. ஒரு சாதாரண HashSet உறுப்பு வரிசையை பராமரிக்காது. முதலாவதாக, அதிகாரப்பூர்வமாக அது வெறுமனே இல்லை, இரண்டாவதாக, ஒரே ஒரு உறுப்பு சேர்க்கப்படும்போது உள் ஒழுங்கு கூட வியத்தகு முறையில் மாறலாம். நீங்கள் LinkedHashSet இலிருந்து ஒரு இட்டரேட்டரைப் பெறலாம் மற்றும் LinkedHashSet இல் சேர்க்கப்பட்ட சரியான வரிசையில் அனைத்து உறுப்புகளையும் பார்க்க அதைப் பயன்படுத்தலாம் . அடிக்கடி இல்லை, ஆனால் சில நேரங்களில் அது மிகவும் அவசியமாக இருக்கலாம். ஒரு ட்ரீசெட் என்பது மதிப்பு-வரிசைப்படுத்தப்பட்ட மரமாக கூறுகளை சேமிக்கும் ஒரு தொகுப்பு ஆகும். TreeSet<E> க்குள் ஒரு TreeMap<E, Object> இந்த மதிப்புகள் அனைத்தையும் சேமிக்கிறது. மற்றும் இந்த TreeMapஉறுப்புகளை சேமிக்க சிவப்பு-கருப்பு சமநிலை பைனரி மரத்தைப் பயன்படுத்துகிறது. எனவே, இது மிக வேகமாக சேர்() , அகற்று() , செயல்பாடுகளை கொண்டுள்ளது .

ஒரு செட் பொருளை உருவாக்கவும்

ஒரு செட் ஆப்ஜெக்ட்டை உருவாக்க, பின்வரும் படிவங்களில் ஒன்றைப் பயன்படுத்தலாம்:

Set<Integer> intSet = new HashSet<>();
Set<String> vSet = new HashSet<>();
Set mySet = new LinkedHashSet();
HashSet<String> myHashset = new HashSet<>();

இங்கே ஒரு எளிய உதாரணம், நாம் 2 செட் கள், ஹாஷ்செட் மற்றும் லிங்க்ட்ஹாஷ்செட் ஆகியவற்றை உருவாக்கி , ஒவ்வொன்றிலும் 5 உறுப்புகளுக்குச் சேர்க்கிறோம். இதற்கு நாம் add() முறையைப் பயன்படுத்தலாம் .

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

public class HashSetTest {
    public static void main(String[] args) {
        Set mySet = new HashSet();
        Set mySet2 = new LinkedHashSet();
//adding some string elements
        mySet.add("Stuart");
        mySet.add("Alex");
        mySet.add("Johnny");
        mySet.add("Igor");
        mySet.add("Bel");
        System.out.println(mySet);
        mySet2.add("Stuart");
        mySet2.add("Alex");
        mySet2.add("Johnny");
        mySet2.add("Igor");
        mySet2.add("Bel");
        System.out.println(mySet2);
    }
}

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

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

ஜாவா செட் சில முக்கியமான முறைகள் இங்கே:

• பூலியன் சேர்(இ இ) . அது ஏற்கனவே இல்லை என்றால் குறிப்பிட்ட உறுப்பு தொகுப்பில் சேர்க்கிறது (விரும்பினால் செயல்பாடு).

• பூலியன் அகற்று(பொருள் o) . குறிப்பிட்ட உறுப்பு இருந்தால் இந்த தொகுப்பில் இருந்து நீக்குகிறது (விரும்பினால் செயல்பாடு).

• பூலியன் ரிமூவ்ஆல்(சேகரிப்பு c) . இந்த தொகுப்பிலிருந்து குறிப்பிட்ட சேகரிப்பில் உள்ள அனைத்து கூறுகளையும் நீக்குகிறது (விரும்பினால் செயல்பாடு).

• பூலியன் retainAll(சேகரிப்பு c) . குறிப்பிடப்பட்ட சேகரிப்பில் (விரும்பினால் இயக்கம்) உள்ள தனிமங்களை மட்டுமே இந்த தொகுப்பில் வைத்திருக்கிறது.

• வெற்றிடமற்ற தெளிவான() . தொகுப்பிலிருந்து அனைத்து கூறுகளையும் நீக்குகிறது.

• இடிரேட்டர் இடிரேட்டர்() . இந்தத் தொகுப்பில் உள்ள உறுப்புகளுக்கு மேல் ஒரு மறு செய்கையை வழங்குகிறது.

• int அளவு() . தொகுப்பில் உள்ள உறுப்புகளின் எண்ணிக்கையைப் பெற இது பயன்படுகிறது.

• boolean isEmpty() . செட் காலியாக உள்ளதா இல்லையா என்பதை சரிபார்க்க.

• பூலியன் கொண்டுள்ளது (பொருள் o) . இந்த தொகுப்பில் குறிப்பிடப்பட்ட உறுப்பு இருந்தால் உண்மை என வழங்கும்.

• இடிரேட்டர் இடிரேட்டர்() . இந்தத் தொகுப்பில் உள்ள உறுப்புகளுக்கு மேல் ஒரு மறு செய்கையை வழங்குகிறது. உறுப்புகள் குறிப்பிட்ட வரிசையில் திரும்பப்பெறவில்லை.

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

இந்த முறைகள் ArrayList இன் முறைகளைப் போலவே இருக்கும் , தவிர, add(Object o) முறையானது ஒரு பொருளைத் தொகுப்பில் சேர்க்கும். ஆப்ஜெக்ட் சேர்க்கப்பட்டிருந்தால் முறையின் திரும்ப மதிப்பு உண்மையாகவும், இல்லையெனில் தவறானதாகவும் இருக்கும். சேகரிப்பிலிருந்து பெறப்பட்ட சில முறைகளும் உள்ளன <> இடைமுகம்: parallelStream() , removeIf() , stream() and forEach() method from inherited from java.lang.Iterable Interface.

ஜாவா முக்கிய செயல்பாடுகளின் எடுத்துக்காட்டு

இந்த எடுத்துக்காட்டில், நாம் சரங்களின் வரிசையை உருவாக்கி, அதை Arrays.asList செயல்பாட்டைப் பயன்படுத்தி mySet க்கு அனுப்புவோம் . பின்னர் நாம் இன்னும் இரண்டு கூறுகளை அகற்றி, மேலும் ஒரு ஜோடியைச் சேர்க்கிறோம். இந்த வழக்கில், தொகுப்பில் உள்ள உறுப்புகளில் ஒன்று ஏற்கனவே உள்ளது: அது சேர்க்கப்படாது. வெறுமையை சரிபார்க்கும் செயல்பாடுகளையும் முயற்சிப்போம் isEmpty() , செட் அளவு () அளவை தீர்மானித்தல் மற்றும் அனைத்து உறுப்புகளின் தொகுப்பை தெளிவாக () அழிக்கவும் .

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class HashSetTest2 {
   public static void main(String[] args) {
       //creating a string Array with some names
       String [] friends =  {"Stuart", "Ivy", "Johnny", "Alex", "Igor", "Tanya"};
       //creating a new set and adding elements from string array into it
       Set<String> mySet = new HashSet<>(Arrays.asList(friends));
       System.out.println(mySet);
       //removing two elements from the set
       mySet.remove("Igor");
       mySet.remove("Stuart");

       System.out.println(mySet);

       //adding 2 new Elements into set
       mySet.add("Dasha");
       mySet.add("Alex"); //it's second Alex, can't be added
       System.out.println(mySet);
       //cheking the size of mySet
       int size = mySet.size();
       System.out.println("The quantity of set's elements = " + size);
       //Checking if the set is empty
       System.out.println("Is mySet empty? " + mySet.isEmpty());
       //checking if some elements are in set
       System.out.println("Is Igor in set? " + mySet.contains("Igor"));
       System.out.println("Is Johnny in set? "+ mySet.contains("Johnny"));
       //deleting all elements from the set
       mySet.clear();
       System.out.println("Is mySet empty now? " + mySet.isEmpty());

   }
}

நிரலின் வெளியீடு இங்கே:

LinkedHashSet உடன் எடுத்துக்காட்டு மற்றும் வரிசைக்கு அமைக்கவும்

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

import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;
   public class LinkedHashSet3 {
       public static void main(String[] args) {
           Set<String> set = new LinkedHashSet<>();
           set.add("C");
           set.add("D");
           set.add("E");
           set.add("F");
           set.add("G");
           set.add("A");
           set.add("B");
           System.out.println(set);
           set.remove("F");// removing an element from our set
           set.remove("C sharp");//trying to remove element that isn't in set
           System.out.println(set.remove("C sharp"));
           System.out.println("Print our set with elements removed: ");
           System.out.println(set);

//set to array
           String strArray[] = set.toArray(new String[set.size()]);
           System.out.println("New Array from set: ");
           System.out.println(Arrays.toString(strArray));
           System.out.println(strArray[0]);

       }
   }

நிரலின் வெளியீடு இங்கே:

இடிரேட்டருடன் உதாரணம் அமைக்கவும்

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

import java.util.*;

public class SetTest5
{
   public static void main(String[] args)
   {

       Set<Integer> mySet = new HashSe<>();
       for(int i = 0; i < 10; i++)
           mySet.add(i);

       Iterator iterator = mySet.iterator();

       //simple iteration
       while(iterator.hasNext()){
           int i = (int) iterator.next();
       }
       System.out.println(" " + mySet);

       //modification of mySet using iterator - removing all even numbers
       iterator = mySet.iterator();
       while(iterator.hasNext()){
           int x = (int) iterator.next();
           if(x%2 == 0) iterator.remove();
       }
       System.out.println(mySet);

       }
}

நிரலின் வெளியீடு இங்கே:

ட்ரீசெட் உடன் உதாரணம்

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

import java.util.Set;
import java.util.TreeSet;
public class TreeSetTest {

   public static void main(String[] args) {

       Set mySet = new TreeSet<>();
       mySet.add("Stuart");
       mySet.add("Alex");
       mySet.add("Johnny");
       mySet.add("Igor");
       mySet.add("Bel");
       System.out.println(mySet);

   }

வெளியீடு:

சுருக்கமான முடிவுகள்

• ஜாவா தொகுப்பு இடைமுகம் ஜாவா சேகரிப்பு கட்டமைப்பின் ஒரு பகுதியாகும்.

• செயல்படுத்தப்பட்ட வகுப்புகள்: AbstractSet , ConcurrentHashMap.KeySetView , ConcurrentSkipListSet , CopyOnWriteArraySet , EnumSet , HashSet , JobStateReasons , LinkedHashSet , TreeSet .

• HashSet , LinkedHashSet மற்றும் TreeSet ஆகியவை மிகவும் பிரபலமான செட் செயலாக்கங்கள் .

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

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

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

• ஒரு பூஜ்ய உறுப்பை மட்டும் சேர்க்க செட் உங்களை அனுமதிக்கிறது.

• தொகுப்பு என்பது பட்டியல் அல்ல மற்றும் அதன் உறுப்புகளின் குறியீடுகள் அல்லது நிலைகளை ஆதரிக்காது.