జావా ఇటరేటర్

హాయ్! నేటి పాఠంలో, మేము జావా ఇటరేటర్ గురించి మాట్లాడుతాము. మీరు లైబ్రరీకి వెళ్లి, మీరు ఒక నిర్దిష్ట పుస్తకాన్ని కనుగొనాలనుకుంటున్నారని ఊహించుకోండి. మీరు దీన్ని ఎలా చేస్తారు? ఇది నాన్ ఫిక్షన్ అయితే, డ్యూయీ డెసిమల్ సిస్టమ్ ఉంది. ఇది కల్పితం అయితే, అవి వారి ఇంటిపేరుతో అక్షర క్రమంలో క్రమబద్ధీకరించబడతాయి. మీరు దేని కోసం వెతుకుతున్నారో, ఏదో ఒక సమయంలో, మీరు వెతుకుతున్నది కనుగొనే వరకు మీరు ఒక సమయంలో పుస్తకాలను చదవాలి. మీరు జావాలో వస్తువుల సేకరణను కలిగి ఉన్నప్పుడల్లా, అది అర్రే , అర్రేలిస్ట్ , క్యూ లేదా లిస్ట్‌లో నిల్వ చేయబడినా , మీరు నిర్దిష్ట విలువను ఎలా కనుగొంటారు? ఏదో ఒక సమయంలో, మీరు ఒక్కో మూలకం ద్వారా ఒక్కొక్కటిగా వెళ్లాలి. జావా ఇటరేటర్ దీని కోసం.

జావాలో ఇటరేటర్ అంటే ఏమిటి

జావాలో ఇటరేటర్ అంటే ఏమిటి? ఇది సేకరణలోని ప్రతి మూలకాన్ని చూసే మార్గం. మరియు సేకరణ ద్వారా, మేము కలెక్షన్ క్లాస్‌లో ఏదైనా అర్థం చేసుకున్నాము. ఇందులో ఇవి ఉన్నాయి:

• అర్రేలిస్ట్
• HashSet
• లింక్డ్‌హాష్‌సెట్
• లింక్డ్లిస్ట్
• ప్రాధాన్యత క్యూ
• వెక్టర్
• మరియు అనేక ఇతరులు…

ఇది ఆ తరగతుల కోసం సెట్ , జాబితా , క్యూ , డిక్యూ , మరియు క్రమబద్ధీకరించబడిన సెట్ వంటి వివిధ ఇంటర్‌ఫేస్‌లను కూడా కలిగి ఉంటుంది . ఇటరేటర్<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.…

దీనికి దాని ఉపయోగాలు ఉన్నాయి, అయితే సేకరణ ఇండెక్స్-ఆధారిత సిస్టమ్‌లో మూలకాలను నిల్వ చేయకపోతే ఏమి జరుగుతుంది? ఉదాహరణకు, సెట్‌లకు సాధారణంగా ఆర్డర్ ఉండదు. కాబట్టి జావాలో ఇటరేటర్‌గా ఫర్ లూప్‌ని ఉపయోగించే అభ్యాసం నుండి బయటపడి, బదులుగా ఇటరేటర్<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() లూప్ భవిష్యత్తులో మూలకం ఉందో లేదో తనిఖీ చేయడానికి ఇటరేటర్ క్లాస్ యొక్క .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);
}

కోసం :ప్రతి లూప్ లూప్ కోసం, కానీ మీకు దీన్ని ఎలా చదవాలో తెలియకపోతే, అది కొంచెం గందరగోళంగా ఉండవచ్చు. కోసం: ప్రతి లూప్ యొక్క వాక్యనిర్మాణం (data_type variableName : collectionName){ body} . దీని కోసం: ప్రతి లూప్‌కు కొన్ని లోపాలు ఉన్నాయి. మొదట, ఇది సేకరణను ఒక దిశలో మాత్రమే దాటగలదు. రెండవది, మీరు ప్రతి మూలకం ద్వారా పునరావృతం చేయాలి. మీరు వాటిలో దేనినీ దాటవేయలేరు. కానీ జావాలో అనుకూలమైన జాబితా ఇటరేటర్‌గా, ఇది ఉత్తమ ఎంపిక. ప్లస్ వైపు, for:ప్రతి లూప్ చదవడం చాలా సులభం మరియు ఒకసారి మీకు తెలిస్తే, తప్పుగా అర్థం చేసుకోవడం కష్టం. మూడు ఇటరేటర్ లూప్‌ల అవుట్‌పుట్ ఏమిటని మీరు ఆలోచిస్తున్నట్లయితే, అవన్నీ ఒకేలా ఉంటాయి:

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

మ్యాప్స్ కోసం జావాలో ఇటరేటర్‌ను ఎలా ఉపయోగించాలి

మ్యాప్‌లు డేటాను నిల్వ చేయడానికి ఒక ప్రసిద్ధ మార్గం, కానీ అవి సేకరణను పొడిగించనందున , మీరు మ్యాప్‌ను నేరుగా ప్రయాణించడానికి మునుపటి ఇటరేటర్‌లను ఉపయోగించలేరు. కాబట్టి మీరు Map s మరియు HashMap s ద్వారా వెళ్ళడానికి జావాలో ఇటరేటర్‌ని ఎలా ఉపయోగించాలి ? నాలుగు మంచి జావా మ్యాప్ ఇటరేటర్ పద్ధతులు ఉన్నాయి. మేము వాటిని ఒక్కొక్కటిగా కవర్ చేస్తాము. ముందుగా, విలువల శ్రేణితో మ్యాప్‌ను లోడ్ చేద్దాం.

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");

  }
}

జావా హాష్‌మ్యాప్ ఇటరేటర్ పద్ధతి: ప్రతి (చర్య) కోసం

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 ని ఉపయోగిస్తుంది. అదనంగా, .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