மறுதொடக்கம் செய்பவர்கள்

"ஹாய், அமிகோ!"

"ஹாய், எல்லி!"

"இன்று நான் உங்களுக்கு இட்டேட்டர்களைப் பற்றி சொல்ல விரும்புகிறேன்."

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

"உறுப்புகளின் தொகுப்பைப் பெறுவதில் என்ன சிரமம்?"

"முதலாவதாக, தொகுப்பு போன்ற சில தொகுப்புகளில் உள்ள கூறுகள், நிறுவப்பட்ட வரிசையைக் கொண்டிருக்கவில்லை மற்றும்/அல்லது வரிசை தொடர்ந்து மாறுகிறது."

"இரண்டாவதாக, சில தரவு கட்டமைப்புகள் பொருட்களை மிகவும் சிக்கலான முறையில் சேமிக்கலாம்: வெவ்வேறு குழுக்கள், பட்டியல்கள் போன்றவற்றில். வேறு வார்த்தைகளில் கூறுவதானால், அனைத்து உறுப்புகளையும் வரிசையாக வழங்குவது அற்பமான செயல் அல்ல."

"மூன்றாவதாக, சேகரிப்புகள் மாறுகின்றன. ஒரு தொகுப்பின் முழு உள்ளடக்கத்தையும் காட்ட நீங்கள் முடிவு செய்கிறீர்கள் என்று வைத்துக்கொள்வோம், ஆனால் வெளியீட்டின் நடுவில், சேகரிப்பின் கூறுகளில் பாதியை மாற்றும் மற்றொரு நூலுக்கு JVM மாறுகிறது. எனவே வெளியீட்டிற்குப் பதிலாக, நீங்கள் பெறுவீர்கள். யாருக்கு என்ன தெரியும்."

"ம்ம்..."

"ஆனால்! இவை துல்லியமாக ஒரு இட்டேட்டர் தீர்க்கக்கூடிய சிக்கல்கள் ஆகும். ஒரு மறுபுறம், அதன் அனைத்து தனிப்பட்ட தரவுகளையும் அணுகக்கூடிய மற்றும் அதன் உள் கட்டமைப்பை அறிந்திருக்கும் ஒரு தொகுப்பில் உள்ள ஒரு சிறப்புப் பொருளாகத் திரும்பத் திரும்ப இயக்கி உள்ளது. , பொது இடிரேட்டர் இடைமுகத்தை செயல்படுத்துகிறது, இது எப்படி வேலை செய்வது என்பதை அனைவருக்கும் தெரியப்படுத்துகிறது .

"சில மறுதொடக்கம் செய்பவர்கள் உள்ளக அணிவரிசையைக் கொண்டுள்ளனர், அதில் மீண்டும் மீண்டும் உருவாக்கப்படும் போது சேகரிப்பின் அனைத்து கூறுகளும் நகலெடுக்கப்படும். சேகரிப்பில் ஏற்படும் மாற்றங்கள் உறுப்புகளின் எண்ணிக்கை அல்லது வரிசையைப் பாதிக்காது என்பதை இது உறுதி செய்கிறது."

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

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

"இட்டேட்டர் எவ்வாறு செயல்படுகிறது என்பதை நான் உங்களுக்கு நினைவூட்டுகிறேன்."

"ஜாவாவில் ஒரு சிறப்பு இட்டரேட்டர் இடைமுகம் உள்ளது. அதன் முறைகள் இங்கே:"

"ஒரு தொகுப்பின் அனைத்து கூறுகளையும் தொடர்ச்சியாகப் பெறுவதற்கு ஒரு இடிரேட்டர் உங்களை அனுமதிக்கிறது. ஒரு இன்புட்ஸ்ட்ரீம் போன்ற ஒரு செயலியை நினைப்பது மிகவும் தர்க்கரீதியானது - இது எல்லா தரவையும் கொண்டுள்ளது, ஆனால் அதன் பணி அதை வரிசையாக வெளியிடுவதாகும்."

"   அடுத்த () முறை சேகரிப்பில் அடுத்த உறுப்பை வழங்குகிறது."

" இன்னும் ஏதேனும் உறுப்புகள் உள்ளனவா என்பதைச் சரிபார்க்க hasNext () முறை பயன்படுத்தப்படுகிறது."

"மற்றும் அகற்று () தற்போதைய உறுப்பை நீக்குகிறது."

"ஏதாவது கேள்விகள்?"

"முறைகளுக்கு ஏன் இப்படி விசித்திரமான பெயர்கள் உள்ளன? ஏன் isEmpty() மற்றும் getNextElement()?"

"அது இன்னும் அர்த்தமுள்ளதாக இருக்கும் இல்லையா?"

"இது மிகவும் அர்த்தமுள்ளதாக இருக்கும், ஆனால் பெயர்கள் சி++ மொழியிலிருந்து வந்தவை, அங்கு மீண்டும் மீண்டும் தோன்றியவை."

"பார்க்கிறேன். தொடரலாம்."

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

"எந்த சேகரிப்பிலும் இந்த முறையைப் பயன்படுத்தி, இடிரேட்டர் பொருளை அதன் உறுப்புகள் வழியாகச் செல்லப் பெறலாம். ட்ரீசெட்டில் உள்ள அனைத்து உறுப்புகளின் மீதும் நடப்போம் :"

TreeSet<String> set = new TreeSet<String>();
Iterator<String> iterator = set.iterator();

while (iterator.hasNext())
{
 String item = iterator.next();
 System.out.println(item);
}

"இது போன்ற ஒரு இடிரேட்டரைப் பயன்படுத்துவது மிகவும் வசதியானது அல்ல - அதிகப்படியான மிதமிஞ்சிய மற்றும் வெளிப்படையான குறியீடு உள்ளது. ஜாவாவில் ஒவ்வொரு லூப் தோன்றும் போது நிலைமை எளிமையானது ."

"இப்போது இந்த குறியீடு மிகவும் கச்சிதமானது மற்றும் படிக்கக்கூடியது:"

TreeSet<String> set = new TreeSet<String>();
Iterator<String> iterator = set.iterator();

while (iterator.hasNext())
{
 String item = iterator.next();
 System.out.println(item);
}

TreeSet<String> set = new TreeSet<String>();

for(String item : set)
{
 System.out.println(item);
}

"இது ஒரே குறியீடுதான்! இரண்டு சந்தர்ப்பங்களிலும் இட்ரேட்டர் பயன்படுத்தப்படுகிறது."

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

" இட்டேட்டர்களை ஆதரிக்கும் எந்தவொரு பொருளுக்கும் ஒவ்வொரு லூப் பயன்படுத்தப்படும். வேறுவிதமாகக் கூறினால், நீங்கள் உங்கள் சொந்த வகுப்பை எழுதலாம், அதில் இட்டரேட்டர் () முறையைச் சேர்க்கலாம் மற்றும் ஒவ்வொரு கட்டமைப்பிலும் அதன் பொருட்களைப் பயன்படுத்தலாம்."

"ஆஹா! நிச்சயமாக, எனது சொந்த சேகரிப்புகள் மற்றும் மறுதொடக்கங்களை எழுத நான் ஆர்வமாக இல்லை, ஆனால் வாய்ப்பு இன்னும் தூண்டுகிறது. நான் அதைக் குறித்து வைக்கிறேன்."

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

"அவை செயல்படுத்தப்படுவதைப் பொருட்படுத்தாமல், பட்டியல்கள் உறுப்புகளின் வரிசையைப் பராமரிக்கின்றன, இது ஒரு இட்டேட்டர் மூலம் அவற்றுடன் வேலை செய்வதை இன்னும் கொஞ்சம் வசதியாக ஆக்குகிறது."

" ListIterator <E> இடைமுகத்தின் முறைகள் இங்கே :"

"வேறு வார்த்தைகளில் கூறுவதானால், இங்கே நாம் முன்னோக்கி மற்றும் பின்னோக்கி நகர்த்தலாம். மேலும் சில சிறிய அம்சங்கள் உள்ளன."

"சரி, இது சுவாரஸ்யமான விஷயம். இது எங்கே பயன்படுத்தப்படுகிறது?"

"இணைக்கப்பட்ட பட்டியலில் நீங்கள் முன்னும் பின்னுமாக நகர விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். பெறுதல் செயல்பாடு மெதுவாக இருக்கும், ஆனால் அடுத்த() செயல்பாடு மிக வேகமாக இருக்கும்."

"ம்ம். நீ என்னை சமாதானப்படுத்தினாய். நான் அதை மனதில் வைத்துக் கொள்கிறேன்."

"நன்றி, எல்லி!"