అన్ని సేకరణల జాబితా

"హాయ్, అమిగో."

"హే, రిషీ."

"మీకు సేకరణలకు మరిన్ని ఉదాహరణలు కావాలని ఎల్లీ నాకు చెప్పారు. నేను మీకు కొన్ని ఇస్తాను. ఇక్కడ సేకరణలు మరియు ఇంటర్‌ఫేస్‌ల జాబితా ఉంది:"

"హ్మ్. అది చాలా ఎక్కువ. నాలుగు జాబితాలు, మూడు సెట్లు మరియు నాలుగు మ్యాప్‌లు."

"అవును, అవన్నీ జాబితా, సెట్ మరియు మ్యాప్ ఇంటర్‌ఫేస్‌ల యొక్క విభిన్న అమలులు."

"ఈ అమలుల మధ్య తేడా ఏమిటి?"

"ఈ రోజు మనం మాట్లాడబోయేది సరిగ్గా అదే. ఓపిక పట్టండి."

"మీకు ఇంకా ఏవైనా ప్రశ్నలు ఉన్నాయా?"

"స్క్రీన్‌పై జాబితాను ఎలా ప్రదర్శించాలో నాకు తెలుసు. నేను సెట్ లేదా మ్యాప్‌ను ఎలా ప్రదర్శించాలి?"

"జాబితాలోని మూలకాలు సెట్ క్రమాన్ని కలిగి ఉంటాయి, కాబట్టి మీరు వాటిని ప్రదర్శించడానికి సూచికను ఉపయోగించవచ్చు. సెట్ లేదా మ్యాప్ కోసం, నిర్దిష్ట క్రమం లేదు. వాస్తవానికి, అంశాలు తొలగించబడినా లేదా కొత్తవి అయినప్పుడు వాటి మూలకాల క్రమం మారవచ్చు. అంశాలు జోడించబడ్డాయి."

"అద్భుతం."

"అందుకే ఇటరేటర్లు అని పిలువబడే ప్రత్యేక వస్తువులు, సేకరణ మూలకాలతో పని చేయడానికి కనుగొనబడ్డాయి. అవి సూచికలకు (మ్యాప్) బదులుగా పేర్లను కలిగి ఉన్నప్పటికీ, లేదా పేర్లు లేదా సూచికలు లేకపోయినా, సేకరణలోని అన్ని మూలకాల ద్వారా వెళ్ళడానికి మిమ్మల్ని అనుమతిస్తాయి. సెట్)."

"ఇవి కొన్ని ఉదాహరణలు:"

 public static void main(String[] args)
{
    Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

     // Get an iterator for the set
     Iterator&ltString> iterator = set.iterator();

    while (iterator.hasNext())        // Check if there is another element
    {
       // Get the current element and move to the next one
       String text = iterator.next();

        System.out.println(text);
    }
}
 

public static void main(String[] args)
{
    List&ltString> list = new ArrayList&ltString>();
    list.add("Rain");
    list.add("In");
    list.add("Spain");

    Iterator&ltString> iterator = list.iterator();// Get an iterator for the list

    while (iterator.hasNext())      // Check if there is another element   
    {
        // Get the current element and move to the next one
        String text = iterator.next();

        System.out.println(text);
    }
}

public static void main(String[] args)
{
    // All elements are stored in pairs
    Map<String, String> map = new HashMap<String, String>();
    map.put("first", "Rain");
    map.put("second", "In");
    map.put("third", "Spain");

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

   while (iterator.hasNext())
    {
        // Get a key-value pair
        Map.Entry<String, String> pair = iterator.next();
        String key = pair.getKey();            // Key
        String value = pair.getValue();        // Value
        System.out.println(key + ":" + value);
    }
}

"వావ్. దాని అర్థం ఏమిటో నేను ఆశ్చర్యపోతున్నాను."

"ఇది నిజానికి చాలా సులభం. ముందుగా, మేము సేకరణ నుండి ఒక ప్రత్యేక వస్తువు, ఒక ఇటరేటర్‌ను పొందుతాము. ఇటరేటర్‌లో కేవలం రెండు పద్ధతులు మాత్రమే ఉన్నాయి.

1. తదుపరి() పద్ధతి సేకరణలోని తదుపరి మూలకాన్ని అందిస్తుంది.

2. hasNext() మెథడ్ నెక్స్ట్() ద్వారా రిటర్న్ చేయని ఎలిమెంట్స్ ఇంకా ఉన్నాయో లేదో తనిఖీ చేస్తుంది."

"సరే. ఇప్పుడు స్పష్టమవుతోందని అనుకుంటున్నాను. నేను అర్థం చేసుకున్న దానిని మీకు మళ్లీ చెప్పడానికి ప్రయత్నిస్తాను."

"కాబట్టి... ముందుగా, ఈ మేజిక్ ఇటరేటర్ ఆబ్జెక్ట్‌ని పొందడానికి మేము సేకరణలో ఇటరేటర్() పద్ధతిని కాల్ చేయాలి."

"తర్వాత మేము పొందేందుకు ఏవైనా మిగిలి ఉన్నంత వరకు ఎలిమెంట్‌లను ఒక్కొక్కటిగా పొందుతాము. నెక్స్ట్()కి కాల్ చేయడం ద్వారా మేము సేకరణలో తదుపరి ఎలిమెంట్‌ని పొందుతాము మరియు సేకరణలో ఇంకా ఎలిమెంట్‌లు ఉన్నాయో లేదో తనిఖీ చేయడానికి hasNext()ని కాల్ చేయండి ఇటరేటర్. అది సరైనదేనా?"

"అవును, ఎక్కువ లేదా తక్కువ. అయితే మంచి భాగం కోసం వేచి ఉండండి."

"ఇటరేటర్‌లతో పనిచేయడానికి జావా షార్ట్‌హ్యాండ్ సంజ్ఞామానాన్ని కలిగి ఉంది. అయితే మరియు కోసం యొక్క నమూనాను అనుసరించి , మరొక ప్రత్యేక ప్రకటన జోడించబడింది: ప్రతిదానికి . ఇది కీవర్డ్‌ని ఉపయోగించి కూడా సూచించబడుతుంది . "

"ప్రతి ప్రకటన సేకరణలు మరియు కంటైనర్‌లతో పని చేయడానికి మాత్రమే ఉపయోగించబడుతుంది. ఇది పరోక్షంగా ఇటరేటర్‌ను ఉపయోగిస్తుంది, కానీ మేము తిరిగి వచ్చిన మూలకాన్ని మాత్రమే చూస్తాము."

"ఇటరేటర్‌తో పని చేయడానికి లాంగ్‌హ్యాండ్ మరియు షార్ట్‌హ్యాండ్ మార్గాలను నేను మీకు చూపుతాను:"

public static void main(String[] args)
{
  Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

    Iterator&ltString> iterator = set.iterator();
  while (iterator.hasNext())
  {
    String text = iterator.next();
    System.out.println(text);
  }
}

public static void main(String[] args)
{
    Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

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

"ఎరుపు లేదా ఆకుపచ్చ రంగులో హైలైట్ చేయబడిన పదాలు కుడి భాగంలో లేవని గమనించండి. వాస్తవానికి, మూడు పంక్తులు ఒకదానితో భర్తీ చేయబడతాయి:"

Iterator&ltString> iterator = set.iterator();
while (iterator.hasNext())
{
    String text = iterator.next();

for (String text : set)

"ఇది చాలా అందంగా ఉంది. నాకు ఈ మార్గం బాగా నచ్చింది."

"పై ఉదాహరణల షార్ట్‌హ్యాండ్ వెర్షన్‌ను చూద్దాం:"

public static void main(String[] args)
{
    Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

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

public static void main(String[] args)
{
    List&ltString> list = new ArrayList&ltString>();
    list.add("Rain");
    list.add("In");
    list.add("Spain");

     for (String text : list)        
    {
        System.out.println(text);
    }
}

public static void main(String[] args)
{
    Map<String, String> map = new HashMap<String, String>(); 
    map.put("first", "Rain");
    map.put("second", "In");
    map.put("third", "Spain");

    for (Map.Entry<String, String> pair : map.entrySet())
    {
        String key = pair.getKey();                      // Key
        String value = pair.getValue();                  // Value
        System.out.println(key + ":" + value);
    }
}

"ఇప్పుడు మీరు మాట్లాడుతున్నారు!"

"నీకు నచ్చినందుకు నాకు సంతోషంగా ఉంది."