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:
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.
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.
GO TO FULL VERSION