ஜாவாவில் உள்ள ஒரு தொகுப்பிலிருந்து ஒரு உறுப்பை அகற்ற இட்டரேட்டர் முறையை எவ்வாறு பயன்படுத்துவது?

Javavil Ulla Oru Tokuppiliruntu Oru Uruppai Akarra Ittarettar Muraiyai Evvaru Payanpatuttuvatu



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

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







ஜாவாவில் உள்ள ஒரு தொகுப்பிலிருந்து ஒரு உறுப்பை அகற்ற இட்டரேட்டர் முறையை எவ்வாறு பயன்படுத்துவது?

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



இட்டேட்டர் முறையை நன்கு புரிந்துகொள்ள சில எடுத்துக்காட்டுகளைப் பார்ப்போம்:



எடுத்துக்காட்டு 1: இட்டரேட்டர் முறையைப் பயன்படுத்தி சேகரிப்பில் இருந்து குறிப்பிட்ட கூறுகளை நீக்குதல்

இடிரேட்டர் முறையைப் பயன்படுத்தலாம் ' என்றால் 'குறிப்பிட்ட கூறுகளைத் தேர்ந்தெடுக்க அறிக்கைகள் அல்லது சுழல்கள். பின்னர் ' அகற்று கீழே காட்டப்பட்டுள்ளபடி நீக்குதல் செயல்பாட்டைச் செய்ய ()” முறை பயன்படுத்தப்படுகிறது:





இறக்குமதி java.util.* ;
வர்க்கம் IterExam
{
பொது நிலையான வெற்றிடமானது முக்கிய ( லேசான கயிறு [ ] args )
{
வரிசைப்பட்டியல் < முழு > demoArrList = புதிய வரிசைப்பட்டியல் < முழு > ( ) ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் <= இருபது ; நான் = நான் + 2 )
{
demoArrList. கூட்டு ( நான் ) ;
}
மறு செய்கை < முழு > itr = demoArrList. மீண்டும் செய்பவர் ( ) ;
அமைப்பு . வெளியே . println ( 'வழங்கப்பட்ட வரிசை பட்டியல்:' ) ;

க்கான ( முழு எண்ணாக நான் = 0 ; நான் < demoArrList. அளவு ( ) ; நான் ++ )
{
அமைப்பு . வெளியே . அச்சு ( demoArrList. பெறு ( நான் ) + '' ) ;
}
போது ( itr. அடுத்து உள்ளது ( ) )
{
என்றால் ( itr. அடுத்தது ( ) % 3 == 0 )
itr. அகற்று ( ) ;
}
அமைப்பு . வெளியே . println ( ' \n ஒற்றைப்படை வரிசைப்பட்டியல் கூறுகளை அகற்றிய பிறகு' ) ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < demoArrList. அளவு ( ) ; நான் ++ )
{
அமைப்பு . வெளியே . அச்சு ( demoArrList. பெறு ( நான் ) + '' ) ;
}
}
}

மேலே உள்ள குறியீட்டின் விளக்கம்:

  • முதலில், வரிசைப்பட்டியல் உருவாக்கப்பட்டது, அதன் பிறகு ' 2 '' வரம்பு வரை செருகப்பட்டது இருபது '' உதவியுடன் க்கான ” வளையம்.
  • அடுத்து, அறிவிக்கவும் மீண்டும் செய்பவர் கன்சோலில் ArrayList இன் கூறுகளைக் காண்பிக்கும் முறை பொருள்.
  • பின்னர், '' பயன்படுத்தவும் அடுத்து உள்ளது ()” இட்டேட்டர் ஆப்ஜெக்டுடன் இருக்கும் அனைத்து வரிசைப்பட்டியல் உறுப்புகள் வழியாக பயணிக்கும் முறை.
  • அதன் பிறகு, ' என்றால் 'அறிக்கை' மூலம் முழுமையாக வகுபடும் கூறுகளைச் சரிபார்க்கப் பயன்படுத்தப்படுகிறது 3 ” அதன் உள்ளே.
  • பின்னர், ' அகற்று ()' முறையானது ' மூலம் திருப்பியளிக்கப்படும் உறுப்புகளை நீக்க பயன்படுகிறது என்றால் ” அறிக்கை.
  • இறுதியில், புதுப்பிக்கப்பட்ட வரிசைப்பட்டியல் '' ஐப் பயன்படுத்தி காட்டப்பட்டது. க்கான ” வளையம்.

தொகுத்த பிறகு:



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

எடுத்துக்காட்டு 2: சேகரிப்பில் இருந்து அனைத்து கூறுகளையும் நீக்குதல்

சேகரிப்பில் உள்ள அனைத்து கூறுகளையும் அகற்ற, மறு செய்கை முறையை அதன் ' அகற்று ()” முறை கீழே காட்டப்பட்டுள்ளது:

இறக்குமதி java.util.* ;
வர்க்கம் வெறுமை
{
பொது நிலையான வெற்றிடமானது முக்கிய ( லேசான கயிறு arg [ ] )
{
திசையன் < முழு > சோதனை திசையன் = புதிய திசையன் < முழு > ( ) ;
சோதனை திசையன். கூட்டு ( 18 ) ;
சோதனை திசையன். கூட்டு ( இருபத்து ஒன்று ) ;
சோதனை திசையன். கூட்டு ( 25 ) ;
சோதனை திசையன். கூட்டு ( 27 ) ;
சோதனை திசையன். கூட்டு ( 30 ) ;

மறு செய்கை < முழு > தொடரவேண்டும் = சோதனை திசையன். மீண்டும் செய்பவர் ( ) ;
அமைப்பு . வெளியே . அச்சு ( 'இருக்கும் கூறுகள்:' ) ;
போது ( தொடரவேண்டும். அடுத்து உள்ளது ( ) )
அமைப்பு . வெளியே . அச்சு ( தொடரவேண்டும். அடுத்தது ( ) + '' ) ;
அமைப்பு . வெளியே . அச்சு ( ' \n testVector கொண்டுள்ளது ' + சோதனை திசையன். அளவு ( ) + 'உறுப்புகள்' ) ;
தொடரவேண்டும் = சோதனை திசையன். மீண்டும் செய்பவர் ( ) ;
போது ( தொடரவேண்டும். அடுத்து உள்ளது ( ) )
{
அமைப்பு . வெளியே . அச்சு ( ' \n அகற்று' + தொடரவேண்டும். அடுத்தது ( ) ) ;
தொடரவேண்டும். அகற்று ( ) ;
}
அமைப்பு . வெளியே . println ( ' \n இப்போது, ​​testVector கொண்டுள்ளது ' + சோதனை திசையன். அளவு ( ) + 'உறுப்புகள்' ) ;
}
}

குறியீட்டின் விளக்கம்:

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

குறியீட்டின் விளக்கம்:

சேகரிப்பிலிருந்து அனைத்து கூறுகளும் அகற்றப்பட்டதை மேலே உள்ள குறியீடு உறுதிப்படுத்துகிறது.

எடுத்துக்காட்டு 3: ListIterator ஐப் பயன்படுத்தி உறுப்புகளை அகற்றுதல்

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

இறக்குமதி java.util.ArrayList ;
இறக்குமதி java.util.ListIterator ;
பொது வர்க்கம் ListIteratorDemo {

//முக்கிய() முறையை துவக்குதல்
பொது நிலையான வெற்றிடமானது முக்கிய ( லேசான கயிறு [ ] args )
{ //வரிசைப்பட்டியலை அறிவித்தல் மற்றும் துவக்குதல்
வரிசைப்பட்டியல் < லேசான கயிறு > வளர்ந்த = புதிய வரிசைப்பட்டியல் < லேசான கயிறு > ( ) ;
வளர்ந்த கூட்டு ( 'தொப்பி சட்டை' ) ;
வளர்ந்த கூட்டு ( 'துருவம்' ) ;
வளர்ந்த கூட்டு ( 'ஹென்லிஸ்' ) ;
வளர்ந்த கூட்டு ( 'வியர்வை' ) ;
வளர்ந்த கூட்டு ( 'சாதாரண' ) ;
வளர்ந்த கூட்டு ( 'ஆடம்பர' ) ;
வளர்ந்த கூட்டு ( 'Dryfit' ) ;


ListIterator < லேசான கயிறு > லிட்டர் = வளர்ந்த பட்டியல்இடரேட்டர் ( ) ;
அமைப்பு . வெளியே . println ( 'அகற்றுவதற்கு முன் பட்டியல்' ) ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < வளர்ந்த அளவு ( ) ; நான் ++ )
அமைப்பு . வெளியே . அச்சு ( வளர்ந்த பெறு ( நான் ) + '' ) ;
போது ( லிட்டர். அடுத்து உள்ளது ( ) ) {
என்றால் ( லிட்டர். அடுத்தது ( ) . சமம் ( 'வியர்வை' ) ) {
லிட்டர். அகற்று ( ) ;
}
}
அமைப்பு . வெளியே . println ( ' \n நீக்கிய பின் பட்டியல்' ) ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < வளர்ந்த அளவு ( ) ; நான் ++ )
அமைப்பு . வெளியே . அச்சு ( வளர்ந்த பெறு ( நான் ) + '' ) ;
}
}

மேலே உள்ள குறியீட்டின் விளக்கம்:

  • முதலில், வரிசைப்பட்டியலை டம்மி ஸ்ட்ரிங் வகை மதிப்புகளுடன் அறிவித்து துவக்கவும் மற்றும் '' ஐப் பயன்படுத்தி கன்சோலில் உள்ள அனைத்து கூறுகளையும் காட்டவும் க்கான ” வளையம்.
  • அடுத்து, 'என்று அழைக்கும் ஒரு பொருளை உருவாக்கவும். அடுத்து உள்ளது ()” முறை உள்ளே “ போது ” வளையம். இது அனைத்து வாழும் உறுப்புகள் வழியாக செல்கிறது.
  • பின்னர், ' என்றால் 'குறிப்பிட்ட உரையுடன் ஒவ்வொரு உறுப்பையும் சரிபார்க்கிறது, அந்த உறுப்பு ' உடன் பொருந்தும்போது அகற்று ()” முறை அழைக்கப்படுகிறது. இது '' இலிருந்து குறிப்பிட்ட உறுப்பை நீக்குகிறது கலை ” என்ற பெயர் ArrayList.
  • முடிவில், மாற்றியமைக்கப்பட்ட வரிசைப்பட்டியலை கன்சோலில் காண்பிக்கவும்.

தொகுத்த பின்:

ListIterator ஐப் பயன்படுத்தி சேகரிப்பில் இருந்து குறிப்பிட்ட தரவு உறுப்பு அகற்றப்பட்டதை ஸ்னாப்ஷாட் உறுதிப்படுத்துகிறது.

முடிவுரை

தொகுப்பிலிருந்து உறுப்பை அகற்ற, ' அகற்று ()” இட்ரேட்டரின் முறை பயன்படுத்தப்படுகிறது. இலக்கிடப்பட்ட தரவைக் கண்டறிய, வரிசைப்பட்டியலின் வழியாகத் தொடர்கிறது. அது கண்டுபிடிக்கப்பட்டவுடன் ' அகற்று குறிப்பிட்ட தரவு உறுப்பை அகற்ற ()” முறை பயன்படுத்தப்படுகிறது. இது பல்வேறு சேகரிப்புகளில் தரப்படுத்தப்பட்ட நுட்பத்தை வழங்குகிறது மற்றும் சிக்கல்கள் மற்றும் பல விதிவிலக்குகள் ஏற்படுவதைத் தடுக்கிறது ' ConcurrentModificationException ”. அதனுடன், ' ListIterator ” உதவியாகவும் இருக்கலாம்.