ஜாவாவில் ListIterator “next()” முறையைப் பயன்படுத்துவதை இந்த வலைப்பதிவு விவரிக்கும்.
Java ListIterator 'next()' முறையை எவ்வாறு பயன்படுத்துவது?
பட்டியலிடுபவர் ' அடுத்தது() பட்டியலினூடாக மீண்டும் மீண்டும் வழங்குவதன் மூலம் வழங்கப்பட்ட பட்டியலில் அடுத்த உறுப்பைக் கொடுக்க ” முறை பயன்படுத்தப்படுகிறது.
தொடரியல்
பொது அடுத்தது X ( )
இந்த தொடரியல், ' எக்ஸ் ” என்பது இடைமுகம் இட்டரேட்டரைக் குறிக்கிறது.
குறிப்பு: இந்த முறை ' NoSuchElementException மறு செய்கையில் உருப்படிகள் எதுவும் இல்லை என்றால்.
'' இல் உள்ள அனைத்து வகுப்புகளையும் அணுக, பின்வரும் தொகுப்புகளை முதலில் சேர்க்கவும் java.util 'தொகுப்பு மற்றும் வேலை' மறு செய்கை ', முறையே:
இறக்குமதி java.util.* ;இறக்குமதி java.util.Iterator ;
எடுத்துக்காட்டு 1: ஜாவாவில் ListIterator “அடுத்த()” முறையைப் பயன்படுத்துதல்
இந்த எடுத்துக்காட்டில், பட்டியல் மூலம் மீண்டும் செய்ய ListIterator “next()” முறையைப் பயன்படுத்தலாம்:
பொது வர்க்கம் அடுத்தது {
பொது நிலையான வெற்றிடமானது முக்கிய ( லேசான கயிறு [ ] வாதங்கள் ) {
பட்டியல் < லேசான கயிறு > பட்டியல் = புதிய வரிசைப்பட்டியல் < லேசான கயிறு > ( ) ;
பட்டியல். கூட்டு ( 'ஜாவா' ) ;
பட்டியல். கூட்டு ( 'நிரலாக்கம்' ) ;
மறு செய்கை < லேசான கயிறு > மறு = பட்டியல். மீண்டும் செய்பவர் ( ) ;
அமைப்பு . வெளியே . println ( மீண்டும். அடுத்தது ( ) ) ;
அமைப்பு . வெளியே . println ( மீண்டும். அடுத்தது ( ) ) ;
அமைப்பு . வெளியே . println ( மீண்டும். அடுத்தது ( ) ) ;
} }
இந்த குறியீடு தொகுதியில்:
- முதலில், '' ஒன்றை உருவாக்கவும் வரிசைப்பட்டியல் 'இன்' லேசான கயிறு ” வகை.
- அதன் பிறகு, விண்ணப்பிக்கவும் ' கூட்டு() 'பட்டியலில் கூறப்பட்ட சர மதிப்புகளை சேர்க்கும் முறை.
- இப்போது, வரிசைப்பட்டியலில் இருந்து கூறுகள் '' வழியாக அணுகப்படுகின்றன. Iterator.next() ” அணுகல் முறை மூன்று முறை பயன்படுத்தப்பட்டது.
- பட்டியலில் இரண்டு கூறுகள் இருப்பதால், மூன்றாவது முறை கோரப்பட்ட உறுப்பு இல்லை, எனவே ' NoSuchElementException ” திரும்ப வழங்கப்படும்.
வெளியீடு
பட்டியல் முழுவதுமாகத் திரும்பத் திரும்பப் பெற்ற பிறகு விவாதிக்கப்பட்ட பிழையை இங்கே காணலாம். இதில் உள்ள கூறுகள் இரண்டு மற்றும் முறை அதாவது, 'அடுத்து()' மூன்று முறை பயன்படுத்தப்படும்.
எடுத்துக்காட்டு 2: ListIterator “next()” மற்றும் “hasNext()” முறைகளைப் பயன்படுத்துதல்
இந்த உதாரணம், மறு செய்கையைப் பயன்படுத்தி விவாதிக்கப்பட்ட பிழையைச் சமாளிக்கிறது ' உள்ளது அடுத்து() ”முறை. இந்த முறை முதலில் மறு செய்கையில் அதிக கூறுகள் உள்ளதா என்பதை பகுப்பாய்வு செய்து, பின்னர் அவற்றை ' அடுத்தது() ”முறை, அதன் மூலம் பிழையைக் கையாளுதல்:
பொது வர்க்கம் அடுத்தது {பொது நிலையான வெற்றிடமானது முக்கிய ( லேசான கயிறு [ ] வாதங்கள் ) {
பட்டியல் < லேசான கயிறு > பட்டியல் = புதிய வரிசைப்பட்டியல் < லேசான கயிறு > ( ) ;
பட்டியல். கூட்டு ( 'ஜாவா' ) ;
பட்டியல். கூட்டு ( 'நிரலாக்கம்' ) ;
மறு செய்கை < லேசான கயிறு > மறு = பட்டியல். மீண்டும் செய்பவர் ( ) ;
போது ( மீண்டும். அடுத்து உள்ளது ( ) ) {
அமைப்பு . வெளியே . println ( மீண்டும். அடுத்தது ( ) ) ;
}
அமைப்பு . வெளியே . println ( 'தண்டனைத் தொடரவும்!' ) ;
} }
இந்த குறியீடு தொகுதியில், கீழே கொடுக்கப்பட்டுள்ள படிகளைச் செய்யவும்:
- '' உருவாக்குவதற்கான விவாதிக்கப்பட்ட அணுகுமுறைகளை மீண்டும் செய்யவும் வரிசைப்பட்டியல் ” மற்றும் அதில் கூறுகளைச் சேர்த்தல்.
- இப்போது, ' போது 'லூப், விண்ணப்பிக்கவும்' உள்ளது அடுத்து() ”இயட்டியுடன் முறை. அடுத்த உறுப்பு ஏற்பட்டவுடன், அது (உறுப்பு) '' வழியாக செயல்படுத்தப்படுகிறது. அடுத்தது() ”முறை.
- இல்லையெனில், குறியீடு செயல்படுத்தல் தொடர்கிறது என்பதைக் குறிக்கும் பிந்தைய அறிக்கை திரும்பியது, இதன் மூலம் முன்பு எதிர்கொள்ளப்பட்ட வரம்பு/பிழை நீக்கப்படும்.
வெளியீடு
இந்த வெளியீட்டில், குறிப்பிட்ட பிழை சரியான முறையில் கையாளப்படுவதை அவதானிக்கலாம்.
முடிவுரை
' அடுத்தது() 'ListIterator' இடைமுகத்தின் முறையானது, பட்டியல் மூலம் திரும்பச் செய்வதன் மூலம் வழங்கப்பட்ட பட்டியலில் அடுத்த உறுப்பைக் கொடுத்து, ' NoSuchElementException மறு செய்கையில் உருப்படிகள் எதுவும் இல்லை என்றால். இருப்பினும், எதிர்கொண்ட விதிவிலக்கை இடிரேட்டர் மூலம் அகற்றலாம் ' உள்ளது அடுத்து() ”முறை. இந்த வலைப்பதிவு ஜாவாவில் இட்டரேட்டர் “அடுத்த()” முறையைப் பயன்படுத்துதல் மற்றும் செயல்படுத்துவது பற்றி விவாதிக்கப்பட்டது.