Naglalaman ang Framework ng Koleksyon ng Java ng maraming mga interface, isa na rito ay ang Set Interface. Ang artikulong ito ay magbibigay sa iyo ng isang detalyadong pagpapakilala sa Sets In . Ang mga sumusunod ay ang mga payo upang masakop sa artikulong ito:
- Nagtatakda sa Java
- Paano lumikha ng Isang Set?
- Itakda ang Mga Pamamaraan
- Pangunahing Mga Operasyon sa isang Itakda
Nagtatakda sa Java
Itakda ang tinukoy bilang isang koleksyon ng mga hindi naayos na mga elemento kung saan ang mga dobleng halaga ay hindi maiimbak. Pinahahaba nito ang Koleksyon at sa gayon lahat ng mga pamamaraan sa ay magagamit sa interface na Itakda. Ito ay ipinatupad ng HashSet, LinkedHashSet, o ng TreeSort.
Ang bawat isa sa mga pagpapatupad na ito ay kumilos nang magkakaiba habang inuulit ang hanay, karamihan na patungkol sa pag-order ng mga elemento, at ang oras na ginugol para sa pagpapasok at para sa pag-access sa mga elemento.
- Ang Hash Set ay hindi nagbibigay ng anumang garantiya tungkol sa pagkakasunud-sunod ng mga elemento habang paulit-ulit ang hanay.
- Naka-linkHashSet sa kabilang banda, ay nagbibigay ng isang garantiya tungkol sa pagkakasunud-sunod ng mga elemento habang paulit-ulit sa kanila.
- TreeSet nagbibigay ng garantiya, ngunit ang hanay ay pinagsunod-sunod ayon sa natural na pagkakasunud-sunod, o sa pamamagitan ng isang tukoy na pagpapatupad ng kumpare.
Paano lumikha ng isang Set?
Tinutukoy ng sumusunod na code ang paraan ng paglikha ng isang bagong hanay:
Itakda ang num = bagong HashSet ()
Nagamit na namin generics upang ideklara ang hanay ng isang uri ng integer.
Itakda ang Mga Paraan sa Java:
Maaari kaming magsagawa ng maraming pagpapatakbo sa isang hanay tulad ng sumusunod:
Magdagdag ng Paraan
Ang paraan ng pagdaragdag ay nagsisingit ng isang elemento sa . Sa code sa ibaba, naglalagay kami ng isang hanay ng mga pangalan.
Itakda ang strName = bagong HashSet () strName.add ('John') strName.add ('Doe') System.out.println (strName)Output:
[John, Doe]
Alisin ang Paraan
Tinatanggal ng pamamaraang ito ang tinukoy na elemento mula sa hanay.
import java.util. * pampublikong klase Pangunahing {public static void main (String args []) {// Lumilikha ng isang Empty Set Set = bagong HashSet () // Pagdaragdag ng mga elemento sa set set.add (set '' John ') .add ('Doe') // Ipakita ang itinakdang System.out.println ('Set:' + set) // Pag-aalis ng elementong 'Doe' gamit ang alisin () na set ng paraan. alisin ('Doe') // Pagpapakita ng binago ang itinakdang System.out.println ('Itakda:' + set)}}Output:
ano ang pinakamahusay na ide para sa java
Itakda: [John, Doe]
Itakda: [John]
Ay Walang Paraan na Pamamaraan
Tinutukoy ng pagsusuri ng pamamaraang ito kung ang walang laman ay hindi. Magbabalik ito ng totoo kung ang set ay walang laman, at hindi totoo kung hindi man.
import java.io. * import java.util. * pampublikong klase Pangunahing {public static void main (String args []) {Set javaSet = new HashSet () // Pagdaragdag ng mga elemento sa Set javaSet.add ('John') javaSet .add ('Doe') // Ipakita ang itinakdang System.out.println ('Set:' + javaSet) // Sinusuri kung ang set ay walang laman na System.out.println ('Empty Set:' + javaSet.isEmpty () ) // Pag-clear ng set gamit ang malinaw () na paraan javaSet.clear () // Sinusuri kung ang set ay walang laman System.out.println ('Empty Set:' + javaSet.isEmpty ())}}Output:
Itakda: [John, Doe]
Walang laman na Hanay: hindi totoo
Walang laman na Set: totoo
Laki ng Paraan
Ang laki () na paraan ay nagbabalik ng laki ng hanay, ibig sabihin ang bilang ng mga elemento na naroroon sa hanay.
import java.util. * pampublikong klase Pangunahing {public static void main (String args []) {// Lumilikha ng isang set Set = new HashSet () set.add ('John') set.add ('Doe') System .out.println ('Set:' + set) // Ipinapakita ang laki ng ipinadala na System.out.println ('Laki ng set:' + set.size ())}}Output:
Itakda: [John, Doe]
Laki ng hanay: 2
Iterating Over A Set
Maaari naming ulitin ang lahat ng mga elemento na naroroon sa set ng sumusunod na pamamaraan:
import java.util. * import java.util.HashSet pampublikong klase Pangunahing {public static void main (String args []) {// Lumilikha ng isang HashSet HashSet javaSet = bagong HashSet () javaSet.add ('John') javaSet.add ('Doe') // Pagpapakita ng itinakdang System.out.println ('HashSet:' + javaSet) // Lumilikha ng isang iterator Iterator itr = javaSet.iterator () // Pagpapakita ng mga halaga pagkatapos ng pag-ulit System.out.println (' Mga halaga ng Iterator: ') habang (itr.hasNext ()) {System.out.println (itr.next ())}}}Output:
HashSet: [John, Doe]
Mga Halaga ng Iterator:
John
Gawin
Naghahanap sa Isang Hanay
Ginagamit namin ang naglalaman ng () pamamaraan upang matukoy kung ang hanay ay naglalaman ng isang tinukoy na elemento. Nagbabalik ng totoo kung ang elemento ay nahanap at hindi totoo.
import java.io. * import java.util.HashSet pampublikong klase Pangunahing {public static void main (String args []) {// Lumilikha ng isang HashSet HashSet javaSet = bagong HashSet () javaSet.add ('John') javaSet.add ('Doe') // Pagpapakita ng HashSet System.out.println ('HashSet:' + javaSet) // Sinusuri ang 'John' sa itinakdang System.out.println ('John in set:' + javaSet.contains ( 'John')) // Sinusuri ang 'Hazel' sa itinakdang System.out.println ('Hazel in set:' + javaSet.contains ('Hazel'))}}Output:
HashSet: [John, Doe]
John in set: totoo
Nakatakda ang Hazel: false
Pangunahing Operasyon Sa Mga Sets sa Java
- Union: Upang magdagdag ng isang hanay sa isa pa, ginagamit namin ang pagpapatakbo ng Union
- Interseksyon: Upang mapanatili ang mga karaniwang halaga mula sa parehong mga set, ginagamit namin ang operasyon ng intersection.
- Pagkakaiba: Upang alisin ang mga halaga ng isang hanay, mula sa kabilang hanay, ginagamit ang operasyon ng pagkakaiba.
Halimbawa
import java.util. * pampublikong klase Pangunahing {public static void main (String args []) {Set d = new HashSet () d.addAll (Arrays.asList (bagong Integer [] {3, 2, 1, 9, 6 , 4, 0})) Itakda ang e = bagong HashSet () e.addAll (Arrays.asList (bagong Integer [] {3, 1, 9, 5, 2, 0, 7,})) // Union Operation Set union = bagong HashSet (d) union.addAll (e) System.out.println ('Union:' + union) // Intersection Operation Set intersection = bagong HashSet (d) intersection.retainAll (e) System.out.println (' Intersection: '+ intersection) // Pagkakaiba ng Set ng Operation set = bagong HashSet (d) pagkakaiba.removeAll (e) System.out.println (' Pagkakaiba: '+ pagkakaiba)}}Output:
Union: [0, 1, 2, 3, 4, 5, 6, 7, 9]
ano ang pamamahala ng pagkuha ng proyekto
Interseksyon: [0, 1, 2, 3, 9]
Pagkakaiba: [4, 6]
Ang mga pamamaraan at pagpapatakbo na nabanggit sa pamamaraan ay gumagawa ng itinakdang interface na elemental at mahusay sa likas na katangian.
Sa gayon ay natapos na kami sa artikulong ito sa 'Sets in Java'. Kung nais mong matuto nang higit pa, tingnan ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online. Ang kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo upang sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring.
May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng artikulong 'nagtatakda sa java' at babalikan ka namin sa lalong madaling panahon.