Ang ' umuulit ” paraan ay nag-aalok ng isang ligtas at madaling paraan upang alisin o tanggalin ang mga partikular na elemento ng data mula sa isang koleksyon habang inuulit ito. Pinipigilan nito ang paglitaw ng ' ConcurrentModificationException ” na lumalabas kapag sinubukan ng enhanced for loop na baguhin ang koleksyon. Iniimbak nito ang track ng kasalukuyang posisyon at nag-aalok ng mga programmer ng pagkakataong sumulong at alisin ang mga pinagbabatayan na elemento kung kinakailangan.
Ipinapakita ng blog na ito ang proseso ng pag-alis ng elemento mula sa isang koleksyon sa pamamagitan ng paggamit ng pamamaraan ng iterator.
Paano Gamitin ang Paraan ng Iterator upang Mag-alis ng Elemento Mula sa isang Koleksyon sa Java?
Ang pamamaraan ng iterator ay unidirectional at maaaring gamitin sa iba't ibang uri ng koleksyon, kabilang ang ' ArrayList', 'LinkedList ”, atbp. Nag-aalok ito ng pare-parehong paraan upang alisin ang mga elemento mula sa anumang koleksyon na nagpapatupad ng “ Iterable ” interface.
Bisitahin natin ang ilang halimbawa upang mas maunawaan ang pamamaraan ng iterator:
Halimbawa 1: Pag-alis ng Mga Partikular na Elemento Mula sa Koleksyon Gamit ang Paraan ng Iterator
Ang pamamaraan ng iterator ay maaaring magamit sa ' kung ” mga pahayag o mga loop upang piliin ang mga tinukoy na elemento. At pagkatapos ay ang ' tanggalin ()' na paraan ay ginagamit upang isagawa ang operasyon ng pagtanggal tulad ng ipinapakita sa ibaba:
angkat java.util.* ;
klase IterExam
{
pampubliko static walang bisa pangunahing ( String [ ] args )
{
ArrayList < Integer > demoArrList = bago ArrayList < Integer > ( ) ;
para sa ( int i = 0 ; i <= dalawampu ; i = i + 2 )
{
demoArrList. idagdag ( i ) ;
}
Tagapag-ulit < Integer > itr = demoArrList. umuulit ( ) ;
Sistema . palabas . println ( 'Ibinigay na ArrayList:' ) ;
para sa ( int i = 0 ; i < demoArrList. laki ( ) ; i ++ )
{
Sistema . palabas . print ( demoArrList. makuha ( i ) + ' ' ) ;
}
habang ( itr. maySusunod ( ) )
{
kung ( itr. susunod ( ) % 3 == 0 )
itr. tanggalin ( ) ;
}
Sistema . palabas . println ( ' \n Pagkatapos Mag-alis ng Mga Odd ArrayList Elements' ) ;
para sa ( int i = 0 ; i < demoArrList. laki ( ) ; i ++ )
{
Sistema . palabas . print ( demoArrList. makuha ( i ) + ' ' ) ;
}
}
}
Paglalarawan ng code sa itaas:
- Una, ang ArrayList ay nilikha at pagkatapos ay isang maramihang ng ' 2 ' ay ipinasok hanggang sa hanay ng ' dalawampu 'sa tulong ng' para sa ” loop.
- Susunod, magdeklara ng ' umuulit ” method object upang ipakita ang mga elemento ng ArrayList sa console.
- Pagkatapos, gamitin ang ' maySusunod ()” na may object ng iterator na tatawid sa lahat ng naninirahan na elemento ng ArrayList.
- Pagkatapos nito, ang ' kung 'Ang pahayag ay ginagamit upang suriin ang mga elemento na ganap na nahahati ng ' 3 ” sa loob nito.
- Pagkatapos, ang ' tanggalin ()' na paraan ay ginagamit upang tanggalin ang mga elemento na ibinalik ng ' kung ” pahayag.
- Sa huli, ang na-update na ArrayList ay ipinakita gamit ang ' para sa ” loop.
Pagkatapos ng compilation:
Ang output ay nagpapakita ng mga partikular na elemento, na nahahati sa tatlo at inalis mula sa ArrayList gamit ang isang iterator method.
Halimbawa 2: Pag-alis ng Lahat ng Elemento Mula sa Koleksyon
Upang alisin ang lahat ng naninirahan na elemento ng koleksyon, ang pamamaraan ng iterator ay maaaring gamitin kasama ng ' tanggalin ()' na pamamaraan tulad ng ipinapakita sa ibaba:
angkat java.util.* ;klase kawalan ng laman
{
pampubliko static walang bisa pangunahing ( String arg [ ] )
{
Vector < Integer > testVector = bago Vector < Integer > ( ) ;
testVector. idagdag ( 18 ) ;
testVector. idagdag ( dalawampu't isa ) ;
testVector. idagdag ( 25 ) ;
testVector. idagdag ( 27 ) ;
testVector. idagdag ( 30 ) ;
Tagapag-ulit < Integer > tumawid = testVector. umuulit ( ) ;
Sistema . palabas . print ( 'Mga kasalukuyang elemento:' ) ;
habang ( tumawid. maySusunod ( ) )
Sistema . palabas . print ( tumawid. susunod ( ) + ' ' ) ;
Sistema . palabas . print ( ' \n Ang testVector ay naglalaman ng ' + testVector. laki ( ) + ' mga elemento ' ) ;
tumawid = testVector. umuulit ( ) ;
habang ( tumawid. maySusunod ( ) )
{
Sistema . palabas . print ( ' \n nag-aalis' + tumawid. susunod ( ) ) ;
tumawid. tanggalin ( ) ;
}
Sistema . palabas . println ( ' \n Ngayon, ang testVector ay naglalaman ng ' + testVector. laki ( ) + ' mga elemento' ) ;
}
}
Paglalarawan ng code:
- Una, ipahayag at simulan ang ' Vector ” na may mga dummy integer type na halaga gamit ang “ idagdag ()” paraan.
- Susunod, lumikha ng isang iterator method na gumagamit ng ' maySusunod ()' at ' susunod ()' paraan. Ipinapakita nito ang mga naninirahan na elemento ng data at ang kanilang kaukulang laki.
- Pagkatapos, gamitin ang ' maySusunod ()' property kasama ang iterator object sa loob ng ' habang ” loop.
- Pagkatapos nito, gamitin ang ' susunod ()” para piliin ang paparating na elemento, at pagkatapos, ang tanggalin () na pamamaraan ay tinatawag upang tanggalin ang bawat elemento ng pagtanggap.
- Sa ganitong paraan, ang lahat ng elemento ng Vector ay aalisin at ang laki ng Vector ay ipinapakita sa console.
Paglalarawan ng code:
Kinukumpirma ng code sa itaas na ang lahat ng elemento mula sa koleksyon ay naalis na.
Halimbawa 3: Pag-alis ng Elemento Gamit ang ListIterator
Ang ListIterator ay gumagana nang katulad sa pamamaraan ng iterator. Ang ListIterator ay nagsasagawa ng pagtawid sa magkabilang panig sa pasulong at paatras na direksyon. Upang alisin ang mga partikular na elemento mula sa koleksyon gamit ang ListIterator sa Java, bisitahin ang code sa ibaba:
angkat java.util.ArrayList ;angkat java.util.ListIterator ;
pampubliko klase ListIteratorDemo {
//Initializing ang main() method
pampubliko static walang bisa pangunahing ( String [ ] args )
{ //Pagdedeklara at Pagsisimula ng ArrayList
ArrayList < String > lumaki = bago ArrayList < String > ( ) ;
lumaki idagdag ( 'Hoodie' ) ;
lumaki idagdag ( 'Pole' ) ;
lumaki idagdag ( 'Henleys' ) ;
lumaki idagdag ( 'Pawis' ) ;
lumaki idagdag ( 'Kaswal' ) ;
lumaki idagdag ( 'Luho' ) ;
lumaki idagdag ( 'Dryfit' ) ;
ListIterator < String > litro = lumaki listIterator ( ) ;
Sistema . palabas . println ( 'Listahan bago alisin' ) ;
para sa ( int i = 0 ; i < lumaki laki ( ) ; i ++ )
Sistema . palabas . print ( lumaki makuha ( i ) + '' ) ;
habang ( litro. maySusunod ( ) ) {
kung ( litro. susunod ( ) . katumbas ( 'Pawis' ) ) {
litro. tanggalin ( ) ;
}
}
Sistema . palabas . println ( ' \n Listahan pagkatapos alisin' ) ;
para sa ( int i = 0 ; i < lumaki laki ( ) ; i ++ )
Sistema . palabas . print ( lumaki makuha ( i ) + '' ) ;
}
}
Paglalarawan ng code sa itaas:
- Una, ideklara at simulan ang ArrayList gamit ang mga dummy String type value at ipakita ang lahat ng elemento sa console gamit ang “ para sa ” loop.
- Susunod, lumikha ng isang bagay na tinatawag na ' maySusunod ()' na pamamaraan sa loob ng ' habang ” loop. Ito ay tumatawid sa lahat ng naninirahan na elemento.
- Pagkatapos, ang ' kung Ang ” statement ay ginagamit na sumusuri sa bawat elemento na may partikular na teksto, kapag ang elementong iyon ay tumutugma sa “ tanggalin ()” ang tinatawag na pamamaraan. Tinatanggal nito ang partikular na elemento mula sa ' aSining ” pinangalanang ArrayList.
- Sa huli, ipakita ang binagong ArrayList sa console.
Pagkatapos ng compilation:
Kinukumpirma ng snapshot na ang tinukoy na elemento ng data ay tinanggal mula sa koleksyon gamit ang ListIterator.
Konklusyon
Upang alisin ang elemento mula sa isang koleksyon, ang ' tanggalin ()' paraan ng iterator ay ginagamit. Ang iterator ay dumadaan sa ArrayList upang mahanap ang naka-target na data. Kapag nahanap na ang ' tanggalin ()' na paraan ay ginagamit upang alisin ang partikular na elemento ng data na iyon. Nag-aalok ito ng isang standardized na pamamaraan sa iba't ibang mga koleksyon at pinipigilan ang mga isyu at ang paglitaw ng ilang mga pagbubukod tulad ng ' ConcurrentModificationException ”. Kasama nito, ang ' ListIterator ” ay maaari ding makatulong.