ஜாவா இட்ரேட்டர்

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

ஜாவாவில் இடிரேட்டர் என்றால் என்ன

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

• வரிசைப்பட்டியல்
• ஹாஷ்செட்
• LinkedHashSet
• இணைக்கப்பட்ட பட்டியல்
• முன்னுரிமை வரிசை
• திசையன்
• மற்றும் பலர்…

இது அந்த வகுப்புகளுக்கான பல்வேறு இடைமுகங்களையும் உள்ளடக்கியது, அதாவது Set , List , Queue , Dequeue , மற்றும் Sorted Set போன்ற சிலவற்றை குறிப்பிடலாம். இட்டரேட்டர்<E> என்பது இடைமுக மறு செய்கை<E> வகுப்பின் பொது இடைமுக முறையாகும் . இது ஜாவா 1.2 இல் கொண்டு வரப்பட்டது மற்றும் ஒரு தொகுப்பில் உள்ள தொடர் கூறுகளை ஆராய்வதற்கான ஒரு வழியாக எண்யூமரேஷன் மாற்றப்பட்டது.

நீங்கள் ஏன் ஜாவாவில் லூப்களை இடிரேட்டராகப் பயன்படுத்தக்கூடாது

ஜாவாவில் ஒரு சேகரிப்பு மூலம் மீண்டும் மீண்டும் செய்ய அனைவருக்கும் கற்பிக்கப்படும் முதல் வழிகளில் ஒன்று லூப் ஆகும். இது போல் தெரிகிறது:

class Main {
  public static void main(String[] args) {
    int exampleArray[] = new int[10];

    //fill array with data

    for(int x = 0; x < exampleArray.length; x++) {
      System.out.println("Content of element " + x + "is: " + exampleArray[x]);
    }
  }
}

வெளியீடு ஒரு பட்டியலாக இருக்கும்:

Content of element 0 is: 0
Content of element 1 is: 1
Content of element 2 is: 2
etc.…

இது அதன் பயன்பாடுகளைக் கொண்டுள்ளது, ஆனால் சேகரிப்பு குறியீட்டு அடிப்படையிலான அமைப்பில் கூறுகளைச் சேமிக்கவில்லை என்றால் என்ன நடக்கும்? எடுத்துக்காட்டாக, Set கள் பொதுவாக எந்த வரிசையையும் கொண்டிருக்கவில்லை. எனவே ஜாவாவில் லூப்பை ஒரு இடிரேட்டராகப் பயன்படுத்தும் நடைமுறையிலிருந்து வெளியேறி, அதற்குப் பதிலாக Iterator<E> வகுப்பைப் பயன்படுத்துவதைப் பயிற்சி செய்வது நல்லது. இங்கே சில ஜாவா ஐடிரேட்டர் உதாரணங்கள் உள்ளன.

ஜாவாவில் இட்டரேட்டரை எவ்வாறு பயன்படுத்துவது

ஜாவாவில் இடிரேட்டரை எவ்வாறு பயன்படுத்துவது என்பதற்கான சில எடுத்துக்காட்டுகள் இங்கே. இடிரேட்டர் வகுப்பைப் பயன்படுத்தும் போது, ​​ஒரு தொகுப்பில் பயணிக்க மூன்று வழிகள் உள்ளன. நீங்கள் a while() loop, a for() loop மற்றும் forEach() loop ஆகியவற்றைப் பயன்படுத்தலாம் . நாம் முன்பு பேசியதில் இருந்து இது லூப் வேறுபட்டது என்பதை நினைவில் கொள்க. இங்கே மூன்று வெவ்வேறு ஜாவா ஐடிரேட்டர் எடுத்துக்காட்டுகள் உள்ளன. முதலில், சேகரிப்பை மீண்டும் மீண்டும் செய்ய அமைப்போம் .

import java.util.*; // imports ArrayList, Collection and Iterator

class Main {
  public static void main(String[] args) {
    Collection<String> example = new ArrayList<String>();

    example.add("Item 1");
    example.add("Item 2");
    example.add("Item 3");
    example.add("Item 4");
  }
}

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

போது() வளையம்

Iterator<String> iterator = example.iterator();

while (iterator.hasNext()) {
   System.out.println("Element Value= " + iterator.next());
}

இந்த while() லூப் , எதிர்கால உறுப்பு உள்ளதா என்று பார்க்க, Iterator வகுப்பின் .hasNext() பூலியன் முறையைப் பயன்படுத்துகிறது . முன்நிபந்தனை உண்மையாக இருந்தால், அது தொடர்கிறது. அது தவறானதாகத் திரும்பினால், லூப் முடிவடைகிறது. இங்கே முக்கிய பகுதி என்னவென்றால், .hasNext() மற்றும் .next() முறைகள் இரண்டும் முதல் உறுப்பின் ஆரம்பச் சரிபார்ப்பைச் செய்கின்றன. சேகரிப்பு காலியாக இருந்தால் மற்றும் முதல் உறுப்பு இல்லை என்றால், .hasNext() க்கு முறை தவறானது மற்றும் .next() முறைக்கு NoSuchElementException ஐ வழங்கும் .

வளையத்திற்கு

for (Iterator<String> iterator = example.iterator(); iterator.hasNext();) {
  System.out.println("Element Value= " + iterator.next());
}

இது லூப்பிற்கு மிகவும் பாரம்பரியமானது போல் தெரிகிறது. இது .hasNext() முறையை நிபந்தனை சரிபார்த்து பகுதியை மாற்றுகிறது. துவக்கம் என்பது இடிரேட்டருக்கான அழைப்பு.

இதற்கு: ஒவ்வொரு வளையமும்

for (String s : example) {
  System.out.println("Element Value= " + s);
}

For :Each loop என்பது ஒரு வளையத்திற்கானது, ஆனால் அதை எப்படி படிக்க வேண்டும் என்று உங்களுக்குத் தெரியாவிட்டால், அது கொஞ்சம் குழப்பமாக இருக்கலாம். For:Each loop ன் தொடரியல் (data_type variableName : collectionName){body} . இது :ஒவ்வொரு வளையத்திற்கும் இரண்டு குறைபாடுகள் உள்ளன. முதலாவதாக, இது ஒரு திசையில் மட்டுமே சேகரிப்பைக் கடக்க முடியும். இரண்டாவதாக, நீங்கள் ஒவ்வொரு உறுப்பு மூலம் மீண்டும் மீண்டும் செய்ய வேண்டும். அவற்றில் எதையும் நீங்கள் தவிர்க்க முடியாது. ஆனால் ஜாவாவில் ஒரு வசதியான பட்டியல் இடிரேட்டராக, இது சிறந்த வழி. நன்மை என்னவென்றால், for:ஒவ்வொரு வளையத்தையும் படிக்க மிகவும் எளிதானது மற்றும் நீங்கள் அதை அறிந்தவுடன், தவறாகப் புரிந்துகொள்வது கடினம். மூன்று இடிரேட்டர் லூப்களின் வெளியீடு என்ன என்று நீங்கள் யோசிக்கிறீர்கள் என்றால், அவை அனைத்தும் ஒரே மாதிரியானவை:

Element Value= Item 1
Element Value= Item 2
Element Value= Item 3
Element Value= Item 4 

வரைபடங்களுக்கு ஜாவாவில் இட்டரேட்டரை எவ்வாறு பயன்படுத்துவது

வரைபடங்கள் தரவைச் சேமிப்பதற்கான ஒரு பிரபலமான வழியாகும், ஆனால் அவை சேகரிப்பை நீட்டிக்காததால் , வரைபடத்தை நேரடியாகப் பயணிக்க முந்தைய மறு செய்கைகளைப் பயன்படுத்த முடியாது. Map கள் மற்றும் HashMap கள் வழியாகச் செல்ல ஜாவாவில் ஒரு இடிரேட்டரை எவ்வாறு பயன்படுத்துவது ? நான்கு நல்ல ஜாவா மேப் ஐடிரேட்டர் முறைகள் உள்ளன. நாங்கள் அவற்றை தனித்தனியாக மூடுவோம். முதலில், மதிப்புகளின் வரிசையுடன் ஒரு வரைபடத்தை ஏற்றுவோம்.

import java.util.*; //imports Map and HashMap

class Main {
  public static void main(String[] args) {
    Map<String, String> example = new HashMap<String, String>();

    example.put("alpha", "one");
    example.put("beta", "two");
    example.put("gamma", "three");

  }
}

Java Hashmap ஐடிரேட்டர் முறை: ஒவ்வொரு செயலுக்கும்

example.forEach((k,v) -> System.out.println("Key: "+ k + ", Value: " + v));

இந்த முறை மீண்டும் மீண்டும் செய்ய லாம்ப்டா வெளிப்பாட்டைப் பயன்படுத்துகிறது. லாம்ப்டா ஆபரேட்டர் forEach() முறை ஆகும், மேலும் உடல் மதிப்புகளை அச்சிடுகிறது. இது பல அளவுரு ஆபரேட்டரைப் பயன்படுத்துகிறது. ஜாவா 8 இல் மேப் ஐடிரேட்டருக்கு இதுவே வேகமான மற்றும் தூய்மையான முறையாகும்.

ஜாவா ஹாஷ்மாப் இட்ரேட்டர் முறை: ஒவ்வொரு () லூப்

for (Map.Entry<String, String> iterate : example.entrySet()) {
  System.out.println("Key: " + iterate.getKey() + ", Value: " + iterate.getValue());
}

இது For:Each syntax ஐப் பயன்படுத்தி entrySet() முறையை அதன் உறுப்புகளாக விசை மற்றும் மதிப்பைக் கொண்ட ஒரு தொகுப்பை திரும்பப் பெறுகிறது. கூடுதலாக, .Entry() முறையைப் பயன்படுத்தும் போது , ​​இந்த மறு செய்கை நிகழும் போது மட்டுமே பொருள்கள் உண்மையாக இருக்கும்.

Java Hashmap ஐடிரேட்டர் முறை: Map.Entry<k, v>

Iterator<Map.Entry<String, String>> iterator = example.entrySet().iterator();

while(iterator.hasNext()){
  Map.Entry<String, String> element = iterator.next();
  System.out.println("Key: " + element.getKey() + ", Value: " + element.getValue());
)

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

Key: alpha, Value: one
Key: beta, Value: two
Key: gamma, Value: three
Java Hashmap Iterator Method: keySet() and values()
for (String key : example.keySet()) {
  System.out.println("Key: " + key);
}
for (String value : example.values()) {
  System.out.println("Value: " + value);
}

இது கூறுகளை வேறு வழியில் திருப்பித் தருகிறது. இது முதலில் அனைத்து விசைகளையும் வரிசையாகவும் பின்னர் அனைத்து மதிப்புகளையும் வழங்கும்:

Key: alpha
Key: beta
Key: gamma
Value: one
Value: two
Value: three