హాయ్! చివరి పాఠంలో, మేము తరగతితో పరిచయం పొందాము ![అర్రేలిస్ట్ నుండి మూలకాన్ని తొలగిస్తోంది - 1]()
సాధారణ శ్రేణి నుండి మూలకాలను తొలగించడం చాలా సౌకర్యవంతంగా లేదని మేము ఇప్పటికే పేర్కొన్నాము. మేము మూలకాన్ని తొలగించలేము కాబట్టి, మనం దాని విలువను "సున్నా అవుట్" (శూన్యానికి సెట్) మాత్రమే చేయగలము:
ArrayListమరియు ఈ తరగతితో అత్యంత సాధారణ కార్యకలాపాలను ఎలా నిర్వహించాలో నేర్చుకున్నాము. అదనంగా, మేము ఒక ArrayListమరియు సాధారణ శ్రేణి మధ్య అనేక తేడాలను ఎత్తి చూపాము. కానీ మేము ఒక అంశాన్ని దాటవేశాము, అవి ఒక నుండి ఎలిమెంట్‌లను ఎలా తొలగించాలిArrayList . మేము ఇప్పుడు దాని గురించి చర్చిస్తాము. 
సాధారణ శ్రేణి నుండి మూలకాలను తొలగించడం చాలా సౌకర్యవంతంగా లేదని మేము ఇప్పటికే పేర్కొన్నాము. మేము మూలకాన్ని తొలగించలేము కాబట్టి, మనం దాని విలువను "సున్నా అవుట్" (శూన్యానికి సెట్) మాత్రమే చేయగలము:
public class Cat {
private String name;
public Cat(String name) {
this.name = name;
}
public static void main(String[] args) {
Cat[] cats = new Cat[3];
cats[0] = new Cat("Thomas");
cats[1] = new Cat("Behemoth");
cats[2] = new Cat("Lionel Messi");
cats[1] = null;
System.out.println(Arrays.toString(cats));
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
'}';
}
}
public static void main(String[] args) {
Cat[] cats = new Cat[4];
cats[0] = new Cat("Thomas");
cats[1] = new Cat("Behemoth");
cats[2] = new Cat("Lionel Messi");
cats[2] = new Cat("Fluffy");
cats[1] = null;
for (int i = 2; i < cats.length-1; i++) {
cats [i-1] = cats [i];// Move the elements to the front of the array, so the empty position is at the end
}
System.out.println(Arrays.toString(cats));
}
public void deleteCat(Cat[] cats, int indexToDelete) {
//...delete the cat corresponding to the index and move the elements
}
Cat, కానీ ఇతర రకాలు కాదు. మరో మాటలో చెప్పాలంటే, మేము శ్రేణులతో ఉపయోగించాలనుకునే ప్రోగ్రామ్‌లో మరో 100 తరగతులు ఉంటే, వాటిలో ప్రతిదానిలో ఒకే లాజిక్‌తో మనం అదే పద్ధతిని వ్రాయవలసి ఉంటుంది. ఇది మొత్తం విపత్తు -_- కానీ ArrayListతరగతి ఈ సమస్యను పరిష్కరిస్తుంది! మూలకాలను తొలగించడానికి ఇది ఒక ప్రత్యేక పద్ధతిని అమలు చేస్తుంది:remove()
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
System.out.println(cats.toString());
cats.remove(1);
System.out.println(cats.toString());
}
remove()రెండు ప్రత్యేక లక్షణాలను కలిగి ఉంది. మొదట, ఇది "రంధ్రాలు" వదలదు. ఒక మూలకం మధ్య నుండి తీసివేయబడినప్పుడు మూలకాలను మార్చడానికి అవసరమైన లాజిక్‌ను ఇది ఇప్పటికే అమలు చేస్తుంది, ఇది మనం ఇంతకు ముందు వ్రాసినది. మునుపటి కోడ్ నుండి అవుట్‌పుట్‌ను చూడండి:
[Cat{name='Thomas'}, Cat{name='Behemoth'}, Cat{name='Lionel Messi'}, Cat{name='Fluffy'}]
[Cat{name='Thomas'}, Cat{name='Lionel Messi'}, Cat{name='Fluffy'}]
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
System.out.println(cats.toString());
cats.remove(lionel);
System.out.println(cats.toString());
}
forదీన్ని చేయడానికి, మేము రిషి పాఠాలలో పరిచయం చేసిన ఫాస్ట్ లూప్‌ని (ప్రతి లూప్ అని కూడా పిలుస్తారు) ఉపయోగిస్తాము :
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
for (Cat cat: cats) {
if (cat.name.equals("Behemoth")) {
cats.remove(cat);
}
}
System.out.println(cats);
}
for (Cat cat: cats) {
cats.add(new Cat("Salem Saberhagen"));
}
System.out.println(cats);
Iterator. Iteratorఇది చాలా సులభం, ఎందుకంటే దీనికి 3 పద్ధతులు మాత్రమే ఉన్నాయి:
hasNext()- జాబితాలో తదుపరి అంశం ఉందా లేదా మేము ఇప్పటికే చివరి అంశానికి చేరుకున్నామా అనేదానిపై ఆధారపడి ఒప్పు లేదా తప్పును అందిస్తుంది.next()- జాబితాలోని తదుపరి అంశాన్ని తిరిగి అందిస్తుందిremove()- జాబితా నుండి ఒక అంశాన్ని తొలగిస్తుంది
Iterator<Cat> catIterator = cats.iterator();// Create an iterator
while(catIterator.hasNext()) {// As long as there are elements in the list
Cat nextCat = catIterator.next();// Get the next element
System.out.println(nextCat);// Display it
}
ArrayListప్రత్యేక పద్ధతిని రూపొందించడానికి అమలు చేసింది. పునరావృతం: iterator(). అదనంగా, మేము ఇటరేటర్‌ను సృష్టించినప్పుడు, అది ( )తో పని చేసే వస్తువుల తరగతిని పేర్కొంటాము <Cat>. బాటమ్ లైన్ ఏమిటంటే, ఇటరేటర్ మన అసలు పనిని సులభంగా నిర్వహిస్తుంది. ఉదాహరణకు, "లియోనెల్ మెస్సీ" అనే పిల్లిని తీసివేయండి:
Iterator<Cat> catIterator = cats.iterator();// Create an iterator
while(catIterator.hasNext()) {// As long as there are elements in the list
Cat nextCat = catIterator.next();// Get the next element
if (nextCat.name.equals("Lionel Messi")) {
catIterator.remove();// Delete the cat with the specified name
}
}
System.out.println(cats);
remove() సూచిక లేదా పేరును పేర్కొనలేదని మీరు గమనించి ఉండవచ్చు ! ఇటరేటర్ కనిపించే దానికంటే తెలివిగా ఉంది: remove()ఇటరేటర్ ద్వారా తిరిగి వచ్చిన చివరి మూలకాన్ని తొలగిస్తుంది. మీరు చూడగలిగినట్లుగా, ఇది మేము ఏమి చేయాలనుకుంటున్నామో అదే చేసింది :) సూత్రప్రాయంగా, ఇది ఒక నుండి మూలకాలను తీసివేయడం గురించి మీరు తెలుసుకోవలసిన ప్రతిదీ ArrayList. బాగా, దాదాపు ప్రతిదీ. తరువాతి పాఠంలో, మేము ఈ తరగతి లోపల చూస్తాము మరియు వివిధ మెథడ్ కాల్‌ల సమయంలో అక్కడ ఏమి జరుగుతుందో చూద్దాం :) అప్పటి వరకు!
GO TO FULL VERSION