Java Set

Ang Set ay isang interface sa Java Collection Framework. Maaari mong gamitin ang Java Set upang ipatupad ang mga hindi nakaayos na koleksyon na may mga natatanging elemento. Sa artikulong ito, titingnan natin ang interface na ito at ang mga pagpapatupad nito sa wikang Java, mga pamamaraan para sa pagtatrabaho sa isang set, at magbibigay din ng ilang mga halimbawa.

Ano ang Java Set

Ang Set ay isang interface mula sa Java Collection Framework, ngunit ang Set ay hindi isang order na koleksyon, hindi katulad ng List . Nangangahulugan iyon na ang mga elemento ng Java Set ay pinananatili nang walang partikular na pagkakasunud-sunod. Kaya walang kontrol sa posisyon kung saan maaari kang magpasok ng isang elemento. Gayundin, hindi mo maa-access ang mga elemento sa pamamagitan ng kanilang index. Sa matematika, ang isang Set ay isang koleksyon ng mga natatanging elemento. Sa katunayan, ito ay isang hindi nakaayos na Koleksyon (hindi nakaayos na Koleksyon), kung saan hindi maiimbak ang mga magkakaparehong elemento. Kung sinasadya mong magdagdag ng duplicate na elemento sa isang Set , babalewalain ang pagkilos na ito at hindi magbabago ang Set . Gayunpaman, pinahihintulutan na mag-imbak ng isang null na elemento dito.

Itakda ang mga pagpapatupad

Ang Java Set ay isang interface, kaya kailangan mong gumamit ng isa sa mga pagpapatupad nito upang lumikha ng mga bagay. Ito ay ang HashSet , TreeSet at LinkedHashSet . Sa Set s, ang bawat elemento ay iniimbak sa isang pagkakataon lamang, at ang iba't ibang pagpapatupad ng Set ay gumagamit ng ibang pagkakasunud-sunod para sa pag-iimbak ng mga elemento. Sa isang HashSet , ang pagkakasunud-sunod ng mga elemento ay tinutukoy ng isang kumplikadong algorithm. Kung mahalaga sa iyo ang pagkakasunud-sunod ng imbakan, gumamit ng lalagyan ng TreeSet , na nag-iimbak ng mga bagay na pinagsunod-sunod sa pataas na pagkakasunud-sunod sa pagkakasunud-sunod ng paghahambing, o isang LinkedHashSet, na nag-iimbak ng mga elemento sa pagkakasunud-sunod ng karagdagan. Ang mga set ay kadalasang ginagamit para sa pagsubok ng membership upang madali mong masuri kung ang isang bagay ay kabilang sa isang naibigay na hanay, kaya sa pagsasagawa ng isang pagpapatupad ng HashSet na na-optimize para sa mabilis na paghahanap ay karaniwang pinipili. Ang HashSet ay isang koleksyon na gumagamit ng kanilang mga hash value na ibinalik ng hashCode() na paraan upang mag-imbak ng mga elemento sa loob. Iyon ay, sa loob ng HashSet<E> , ang HashMap<E, Object> na bagay ay naka-imbak, na nag-iimbak ng mga halaga ng HashSet bilang mga susi. Ang paggamit ng mga hash code ay nagbibigay-daan sa iyong mabilis na maghanap, magdagdag at mag-alis ng mga elemento mula sa isang Set . Ang LinkedHashSet ay isang HashSetna nag-iimbak din ng mga elemento sa isang naka-link na listahan. Ang isang normal na HashSet ay hindi nagpapanatili ng pagkakasunud-sunod ng elemento. Una, opisyal na hindi ito umiiral, at pangalawa, kahit na ang panloob na pagkakasunud-sunod ay maaaring magbago nang malaki kapag isang elemento lamang ang idinagdag. At maaari kang makakuha ng isang iterator mula sa LinkedHashSet at gamitin ito upang suriin ang lahat ng mga elemento sa eksaktong pagkakasunud-sunod kung saan sila idinagdag sa LinkedHashSet . Hindi madalas, ngunit kung minsan maaari itong maging lubhang kailangan. Ang TreeSet ay isang koleksyon na nag-iimbak ng mga elemento bilang isang value-ordered tree. Sa loob ng TreeSet<E> ay isang TreeMap<E, Object> na nag-iimbak ng lahat ng mga halagang ito. At itong TreeMapgumagamit ng red-black balanced binary tree upang mag-imbak ng mga elemento. Samakatuwid, mayroon itong napakabilis na add() , remove() , contains() operations.

Gumawa ng Set Object

Upang lumikha ng isang Set Object maaari mong gamitin ang isa sa susunod na form:

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

Narito ang isang simpleng halimbawa, kung saan gumagawa kami ng 2 Set s, HashSet at LinkedHashSet , at idinagdag sa bawat isa para sa 5 elemento. Maaari naming gamitin ang paraan ng add() para dito.

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);
    }
}

Narito ang output ng programa: Tulad ng nabanggit namin sa itaas, hindi pinapanatili ng HashSet ang pagkakasunud-sunod ng mga elemento, ngunit ginagawa ng LinkedHashSet . Ang LinkedHashSet ang nagbigay sa amin ng mga elemento sa pagkakasunud-sunod na isinulat namin sa set.

Mga Paraan ng Itakda ng Java

Narito ang ilan sa mahahalagang pamamaraan ng Java Set :

• boolean add(E e) . Idinaragdag ang tinukoy na elemento sa set kung wala pa ito (opsyonal na operasyon).

• boolean remove(Object o) . Inaalis ang tinukoy na elemento mula sa set na ito kung ito ay naroroon (opsyonal na operasyon).

• boolean removeAll(Collection c) . Aalisin sa set na ito ang lahat ng elemento nito na nakapaloob sa tinukoy na koleksyon (opsyonal na operasyon).

• boolean retainAll(Collection c) . Pinapanatili lamang ang mga elemento sa set na ito na nakapaloob sa tinukoy na koleksyon (opsyonal na operasyon).

• void clear() . Tinatanggal ang lahat ng elemento mula sa set.

• Iterator iterator() . Nagbabalik ng iterator sa mga elemento sa set na ito.

• int size() . ito ay ginagamit upang makuha ang bilang ng mga elemento sa Set.

• boolean isEmpty() . para tingnan kung walang laman ang Set o wala.

• naglalaman ang boolean(Object o) . Nagbabalik ng true kung naglalaman ang Set na ito ng tinukoy na elemento.

• Iterator iterator() . Nagbabalik ng iterator sa mga elemento sa set na ito. Ang mga elemento ay ibinalik sa walang partikular na pagkakasunud-sunod.

• Object[] toArray() . Nagbabalik ng array na naglalaman ng lahat ng elemento sa set na ito. Kung ang set na ito ay gumagawa ng anumang mga garantiya kung anong pagkakasunud-sunod ang mga elemento nito ay ibinalik ng kanyang iterator, ang pamamaraang ito ay dapat na ibalik ang mga elemento sa parehong pagkakasunud-sunod.

Ang mga pamamaraan ay katulad ng sa ArrayList , maliban na ang add(Object o) na paraan ay nagdaragdag lamang ng isang bagay sa set kung wala pa ito. Ang return value ng method ay true kung ang object ay naidagdag, at false kung hindi. Mayroon ding ilang mga pamamaraan na minana mula sa Collection<> Interface: parallelStream() , removeIf() , stream() at forEach() na pamamaraan na minana mula sa java.lang.Iterable Interface.

Java Itakda ang halimbawa ng pangunahing pagpapatakbo

Sa halimbawang ito, gumawa kami ng array ng mga string at pagkatapos ay ipapasa ito sa mySet gamit ang Arrays.asList operation. Pagkatapos ay aalisin namin ang ilang higit pang elemento, at magdagdag ng ilang higit pa. Sa kasong ito, umiiral na ang isa sa mga elemento sa set: hindi ito idadagdag. Susubukan din namin ang mga operasyon ng pagsuri para sa kawalan ng laman isEmpty() , pagtukoy sa laki ng set size() at pag-clear sa set ng lahat ng elemento clear() .

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());

   }
}

Ang output ng programa ay narito:

Halimbawa sa LinkedHashSet at nakatakda sa Array

Sumulat tayo ng isa pang programa. Sa loob nito, gagawa kami ng set batay sa LinkedHashSet , magdagdag ng mga elemento dito, at pagkatapos ay i-convert ang set sa isang array.

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]);

       }
   }

Narito ang output ng programa:

Magtakda ng halimbawa sa iterator

Gumawa tayo ng isang set, pagkatapos ay i-print ito gamit ang isang iterator, at pagkatapos ay alisin ang lahat ng mga numero mula dito, gamit din ang isang iterator.

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);

       }
}

Ang output ng programa ay narito:

Halimbawa sa TreeSet

Kung mahalaga sa iyo ang pag-uuri, pagkatapos ay gamitin ang pagpapatupad ng TreeSet . Sa maikling halimbawang ito, pupunuin natin ang hanay ng mga pangalan ng mga kaibigan, tulad ng sa mga nakaraang halimbawa. Gayunpaman, sa isang pinagsunod-sunod na TreeSet , ang mga elemento ay agad na isusulat sa pinagsunod-sunod na pagkakasunud-sunod. Sa kasong ito, ang mga pangalan ay ipapakita ayon sa alpabeto.

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);

   }

Ang output ay:

Maikling konklusyon

• Ang interface ng Java Set ay bahagi ng Java Collections Framework.

• Mga ipinatupad na klase: AbstractSet , ConcurrentHashMap.KeySetView , ConcurrentSkipListSet , CopyOnWriteArraySet , EnumSet , HashSet , JobStateReasons , LinkedHashSet , TreeSet .

• Ang pinakasikat na pagpapatupad ng Set ay ang HashSet , LinkedHashSet at TreeSet .

• Ang pagkakasunud-sunod ng elemento ng HashSet ay tinutukoy ng isang kumplikadong algorithm. Kung mahalaga sa iyo ang pagkakasunud-sunod ng imbakan, gumamit ng lalagyan ng TreeSet , na nag-iimbak ng mga bagay na pinagsunod-sunod sa pataas na pagkakasunud-sunod sa pagkakasunud-sunod ng paghahambing, o isang LinkedHashSet , na nag-iimbak ng mga elemento sa pagkakasunud-sunod ng karagdagan.

• Kadalasan, ginagamit ang mga set para subukan ang membership. Iyon ay, upang suriin kung ang isang bagay ay kabilang sa isang ibinigay na set sa matematikal na kahulugan. Kaya kadalasan sa lahat ng mga pagpapatupad ng Set sa pagsasanay, karaniwang pinipili ang HashSet . Ang pagpapatupad na ito ay na-optimize para sa mabilis na paghahanap.

• Hindi ka maaaring magdagdag ng mga duplicate na elemento sa isang set, kaya maaari mong gamitin ang mga pagpapatupad ng Set interface upang mag-imbak ng mga natatanging elemento.

• Binibigyang-daan ka ng set na magdagdag lamang ng isang null element.

• Ang set ay hindi isang listahan at hindi sumusuporta sa mga index o posisyon ng mga elemento nito.