ప్రతి లూప్ కోసం

1. ఇటరేటర్లు ఎలా వచ్చాయి అనే నేపథ్యం

మీకు ఇప్పటికే పరిచయం ఉంది HashSet. మీరు ఒక పాఠాన్ని చదవడమే కాకుండా దాన్ని నిజంగా పరిశోధించి ఉంటే, మీరు ఈ ప్రశ్నను అడగాలి:

స్క్రీన్‌పై అన్ని HashSet మూలకాల జాబితాను నేను ఎలా ప్రదర్శించగలను? get()అన్ని తరువాత, ఇంటర్ఫేస్ మరియు set()పద్ధతులు లేవు !

మరియు HashSetఈ పరిమితిలో ఒంటరిగా కాదు. తో పాటుగా HashSet, ఎలిమెంట్స్‌ను ఇండెక్స్ ద్వారా తిరిగి పొందేందుకు అనుమతించని అనేక ఇతర సేకరణలు ఉన్నాయి, ఎందుకంటే మూలకాలకు నిర్వచించబడిన క్రమం లేదు.

సంవత్సరాలుగా, ప్రోగ్రామర్లు గ్రాఫ్‌లు మరియు చెట్ల వంటి చాలా క్లిష్టమైన డేటా నిర్మాణాలను కనుగొన్నారు. లేదా జాబితాల జాబితాలు.

కొత్త మూలకాలు జోడించబడినప్పుడు లేదా ఇప్పటికే ఉన్న మూలకాలు తీసివేయబడినప్పుడు చాలా కంటైనర్లు వాటి మూలకాల క్రమాన్ని మారుస్తాయి. ఉదాహరణకు, జాబితా ఒక నిర్దిష్ట క్రమంలో మూలకాలను నిల్వ చేస్తుంది మరియు కొత్త మూలకం జోడించబడినప్పుడు, ఇది దాదాపు ఎల్లప్పుడూ జాబితా మధ్యలో చొప్పించబడుతుంది.

మరియు మూలకాలను నిల్వ చేసే కంటైనర్ ఉన్న పరిస్థితులను కూడా మేము పొందుతాము కానీ ఏ స్థిరమైన క్రమంలో కాదు.

ఇప్పుడు మనం అటువంటి సేకరణ నుండి అన్ని మూలకాలను శ్రేణి లేదా జాబితాలోకి కాపీ చేయాలనుకుంటున్నాము. మేము అన్ని అంశాలను పొందాలి. మూలకాలపై మనం పునరావృతమయ్యే క్రమం గురించి మేము పట్టించుకోము — ముఖ్యమైన విషయం ఏమిటంటే ఒకే మూలకాలపై ఒకటి కంటే ఎక్కువసార్లు పునరావృతం చేయకూడదు. మేము దానిని ఎలా చేస్తాము?

2. సేకరణ కోసం ఇటరేటర్

పై సమస్యకు పరిష్కారంగా ఇటరేటర్లు ప్రతిపాదించబడ్డాయి.

ఇటరేటర్ అనేది సేకరణతో అనుబంధించబడిన ఒక ప్రత్యేక వస్తువు, ఇది సేకరణలోని అన్ని అంశాలను పునరావృతం చేయకుండా ప్రయాణించడంలో సహాయపడుతుంది.

ఏదైనా సేకరణ కోసం ఇటరేటర్‌ని పొందడానికి మీరు క్రింది కోడ్‌ని ఉపయోగించవచ్చు:

Iterator<Type> it = name.iterator();

nameసేకరణ వేరియబుల్ పేరు ఎక్కడ ఉంది, Typeసేకరణ యొక్క మూలకాల రకం, iterator()ఇది సేకరణ యొక్క పద్ధతుల్లో ఒకటి మరియు itఇటరేటర్ వేరియబుల్ పేరు.

ఇటరేటర్ ఆబ్జెక్ట్ 3 పద్ధతులను కలిగి ఉంటుంది:

Type next()

boolean hasNext()

void remove()

ఈ పద్ధతులు స్కానర్ క్లాస్ nextInt)మరియు hasNextInt()పద్ధతులకు కొంతవరకు సమానంగా ఉంటాయి.

ఈ next()పద్ధతి మనకు ఇటరేటర్‌ని పొందిన సేకరణ యొక్క తదుపరి మూలకాన్ని అందిస్తుంది.

hasNext()ఇటరేటర్ ఇంకా తిరిగి ఇవ్వని అదనపు అంశాలు సేకరణలో ఉన్నాయో లేదో ఈ పద్ధతి తనిఖీ చేస్తుంది.

ఒక యొక్క అన్ని అంశాలను ఎలా ప్రదర్శించాలో ఇక్కడ ఉంది HashSet:

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

set.add("Hallo");
set.add("Hello");
set.add("Hola");
set.add("Bonjour");
set.add("Ciao");
set.add("Namaste");

Iterator<String> it = set.iterator();
while (it.hasNext())
{
   String str = it.next();
   System.out.println(str);
}

3. For-eachలూప్

ఇటరేటర్ యొక్క ప్రధాన ప్రతికూలత ఏమిటంటే మీ కోడ్ forలూప్‌ని ఉపయోగించడం కంటే మరింత గజిబిజిగా మారుతుంది.

forపోల్చడానికి, లూప్‌ని ఉపయోగించి మరియు ఇటరేటర్‌ని ఉపయోగించి జాబితాను ప్రదర్శిస్తాము :

ArrayList<String> list = new ArrayList<String>();

Iterator<String> it = list.iterator();
while (it.hasNext())
{
   String str = it.next();
   System.out.println(str);
}

ArrayList<String> list = new ArrayList<String>();

for (int i = 0; i < list.size(); i++)
{
   String str = list.get(i);
   System.out.println(str);
}

అవును, లూప్‌ని ఉపయోగించి మూలకాలను దాటడం చాలా ఉత్తమం ArrayList- ప్రతిదీ చిన్నదిగా మారుతుంది.

కానీ జావా సృష్టికర్తలు మళ్లీ మాపై కొంత చక్కెర పోయాలని నిర్ణయించుకున్నారు. అదృష్టవశాత్తూ, ఇది సింటాక్టిక్ చక్కెర .

వారు జావాకు కొత్త రకమైన లూప్ ఇచ్చారు మరియు దానిని for-eachలూప్ అని పిలిచారు. సాధారణంగా ఇది ఇలా కనిపిస్తుంది:

for(Type name:collection)

collectionసేకరణ వేరియబుల్ పేరు ఎక్కడ ఉంది, Typeఇది సేకరణలోని మూలకాల రకం మరియు nameలూప్ యొక్క ప్రతి పునరావృతం వద్ద సేకరణ నుండి తదుపరి విలువను తీసుకునే వేరియబుల్ పేరు.

ఈ రకమైన లూప్ ఒక అవ్యక్త పునరావృత్తిని ఉపయోగించి సేకరణలోని అన్ని మూలకాల ద్వారా పునరావృతమవుతుంది. ఇది వాస్తవానికి ఈ విధంగా పనిచేస్తుంది:

ArrayList<String> list = new ArrayList<String>();

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

ArrayList<String> list = new ArrayList<String>();
Iterator<String> it = list.iterator();

while (it.hasNext())
{
   String str = it.next();
   System.out.println(str);
}

కంపైలర్ for-eachమీ కోడ్‌లో లూప్‌ను ఎదుర్కొన్నప్పుడు, అది కేవలం కుడి వైపున ఉన్న కోడ్‌తో భర్తీ చేస్తుంది: ఇది ఏదైనా ఇతర తప్పిపోయిన పద్ధతి కాల్‌లతో పాటు ఇటరేటర్‌ను పొందడానికి కాల్‌ను జోడిస్తుంది.

ప్రోగ్రామర్లు లూప్‌ను ఇష్టపడతారు for-eachమరియు వారు సేకరణలోని అన్ని అంశాలని మళ్లించాల్సిన అవసరం వచ్చినప్పుడు దాదాపు ఎల్లప్పుడూ దాన్ని ఉపయోగిస్తారు.

ArrayListలూప్‌ని ఉపయోగించి జాబితాపై మళ్లించడం కూడా for-eachచిన్నదిగా కనిపిస్తుంది:

ArrayList<String> list = new ArrayList<String>();

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

ArrayList<String> list = new ArrayList<String>();

for (int i = 0; i < list.size(); i++)
{
   String str = list.get(i);
   System.out.println(str);
}

for-each4. లూప్‌లోని మూలకాన్ని తీసివేయడం

లూప్‌కు for-eachఒక లోపం ఉంది: ఇది మూలకాలను సరిగ్గా తీసివేయదు. మీరు ఇలా కోడ్ వ్రాస్తే, మీకు ఎర్రర్ వస్తుంది.

ArrayList<String> list = new ArrayList<String>();

list.add("Hallo");
list.add("Hello");
list.add("Hola");
list.add("Bonjour");
list.add("Ciao");
list.add("Namaste");

for (String str: list)
{
   if (str.equals("Hello"))
      list.remove(str);
}

ఇది చాలా మంచి మరియు అర్థమయ్యే కోడ్, కానీ ఇది పని చేయదు.

ఈ పరిమితిని అధిగమించడానికి మూడు మార్గాలు ఉన్నాయి.

1. వేరే రకమైన లూప్‌ని ఉపయోగించండి

When traversing an ArrayList collection, మీరు కౌంటర్ వేరియబుల్‌తో సాధారణ లూప్‌ని ఉపయోగించవచ్చు i.

for (int i = 0; i < list.size(); i++)
{
   String str = list.get(i);

   if (str.equals("Hello"))
   {
      list.remove(str);
      i--; // We need to decrease i, because the remove operation shifted the elements
   }
}

HashSetఅయితే, ఈ ఎంపిక మరియు HashMapసేకరణలకు తగినది కాదు

2. స్పష్టమైన పునరావృత్తిని ఉపయోగించండి

మీరు ఇటరేటర్‌ను స్పష్టంగా ఉపయోగించవచ్చు మరియు దాని remove()పద్ధతికి కాల్ చేయవచ్చు.

Iterator<String> it = set.iterator();
while (it.hasNext())
{
   String str = it.next();
   if (str.equals("Hello"))
       it.remove();
}

for (String str: list)
{
   if (str.equals("Hello"))
      list.remove(str);
}

remove()మేము ఇటరేటర్ ఆబ్జెక్ట్‌పై పద్ధతిని పిలుస్తాము ! ఐటెమ్ తీసివేయబడిందని పునరావృతం చేసే వ్యక్తికి తెలుసు మరియు పరిస్థితిని సరిగ్గా నిర్వహించగలడు.

3. సేకరణ కాపీని ఉపయోగించండి

మీరు సేకరణ కాపీని కూడా సృష్టించి, ఆపై కాపీని లూప్‌లో ఉపయోగించవచ్చు for-eachమరియు అసలు సేకరణ నుండి మూలకాలను తొలగించవచ్చు.

ArrayList<String> listCopy = new ArrayList(list);

for (String str: listCopy)
{
   if (str.equals("Hello"))
      list.remove(str);
}

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