మాడ్యూల్ పాఠాలు (2/2)
సేకరణలు మరియు అర్రేలిస్ట్
జావాలోని సాంప్రదాయ శ్రేణులు సృష్టి సమయంలో నిర్వచించబడిన స్థిర పరిమాణాన్ని కలిగి ఉంటాయి. డైనమిక్‌గా పరిమాణం మారగల డేటా జాబితాలతో పని చేయడానికి, జావా జావా కలెక్షన్స్ ఫ్రేమ్‌వర్క్ని అందిస్తుంది. అత్యంత సాధారణంగా ఉపయోగించే తరగతి ArrayList.
ArrayList క్లాస్ మరియు జెనరిక్స్
ArrayList మెమరీలో పునర్పరిమాణ శ్రేణిని అమలు చేస్తుంది. ArrayListని ప్రకటించడానికి, < > యాంగిల్ బ్రాకెట్‌లలో చేర్చడం ద్వారా అది కలిగి ఉండే మూలకాల రకాన్ని మేము తప్పనిసరిగా పేర్కొనాలి. ఈ లక్షణాన్ని జెనరిక్స్ అంటారు.
ArrayListని ఉపయోగించడానికి, మేము దీన్ని ఫైల్ ప్రారంభంలో java.util.ArrayList నుండి దిగుమతి చేయాలి.
ప్రకటన మరియు తక్షణం:
import java.util.ArrayList;
ArrayList<String> shoppingList = new ArrayList<>();ప్రధాన పద్ధతులు
ArrayListలో ప్రాథమిక కార్యకలాపాలు ఇక్కడ ఉన్నాయి:
add(element): జాబితా చివర ఒక మూలకాన్ని జోడిస్తుంది.get(index): పేర్కొన్న సూచిక (0-సూచిక) వద్ద మూలకాన్ని అందిస్తుంది.size(): ప్రస్తుతం జాబితాలో ఉన్న మూలకాల సంఖ్యను అందిస్తుంది.remove(index): పేర్కొన్న సూచిక వద్ద మూలకాన్ని తొలగిస్తుంది.
shoppingList.add("Pane");
shoppingList.add("Latte");
System.out.println("Elementi: " + shoppingList.size()); // Prints 2
System.out.println("Primo elemento: " + shoppingList.get(0)); // Prints "Pane"జాబితాపై పునరావృతం చేయడం (ప్రతి కోసం)
ప్రతి లూప్ అనేది సేకరణలోని అన్ని అంశాల ద్వారా పునరావృతం చేయడానికి అనువైన నిర్మాణం:
for (String item : shoppingList) {
System.out.println(item);
}అర్రే vs అర్రేలిస్ట్: మెమరీ మరియు పనితీరు
స్టాటిక్ అర్రే కంటే ArrayList చాలా సరళమైనది అయినప్పటికీ, ఇది పనితీరు మరియు మెమరీ ట్రేడ్-ఆఫ్‌లతో వస్తుంది:
- స్టాటిక్ అర్రే: ఇది మెమొరీ యొక్క ప్రక్కనే ఉన్న బ్లాక్‌లో కేటాయించబడింది, స్థిర పరిమాణాన్ని కలిగి ఉంటుంది మరియు ఇండెక్స్ ద్వారా మూలకాలను యాక్సెస్ చేయడం చాలా వేగంగా ఉంటుంది. ఇది ఓవర్ హెడ్ లేకుండా నేరుగా ఆదిమ రకాలను నిల్వ చేస్తుంది.
- అరేలిస్ట్: అంతర్గతంగా, దాని ప్రారంభ సామర్థ్యం (సాధారణంగా 10) మించిపోయినప్పుడు (కొత్త పెద్ద శ్రేణిని సృష్టించడం మరియు పాత మూలకాలను కాపీ చేయడం ద్వారా) పరిమాణం మార్చబడిన శ్రేణిని ఇది నిర్వహిస్తుంది. అంతేకాకుండా, ఇది ఆబ్జెక్ట్ రిఫరెన్స్‌లను మాత్రమే నిల్వ చేస్తుంది, ప్రతి మూలకం కోసం మెమరీ ఓవర్‌హెడ్‌ను పరిచయం చేస్తుంది.
ఆటోబాక్సింగ్ మరియు అన్‌బాక్సింగ్
ArrayList ఆబ్జెక్ట్‌లను మాత్రమే ఉంచగలదు కాబట్టి, జావా స్వయంచాలకంగా ఆదిమ రకాలు మరియు వాటి సంబంధిత రేపర్ తరగతుల మధ్య మార్పిడులను నిర్వహిస్తుంది:
- ఆటోబాక్సింగ్: ఆదిమ రకం నుండి రేపర్ క్లాస్‌కి ఆటోమేటిక్ కన్వర్షన్. ఉదాహరణకు, మీరు
numbers.add(42)అని వ్రాసినప్పుడు, జావా స్వయంచాలకంగా42(int)నిInteger.valueOf(42)(పూర్ణాంకం)కి మారుస్తుంది. - అన్‌బాక్సింగ్: రేపర్ క్లాస్ నుండి ఆదిమ రకానికి ఆటోమేటిక్ కన్వర్షన్. ఉదాహరణకు, మీరు
int num = numbers.get(0)ని అమలు చేసినప్పుడు, జావా అంతర్గతంగాIntegerనిintకి మారుస్తుంది.
మీరే ప్రయత్నించండి
శ్రేణి జాబితాను దిగుమతి చేయండి, స్ట్రింగ్ పేరు గల పేర్ల శ్రేణి జాబితాను ప్రకటించండి. ఆలిస్ మరియు బాబ్‌లను జాబితాకు చేర్చండి, ఆపై పరిమాణం() పద్ధతిని ఉపయోగించి దాని పరిమాణాన్ని ప్రింట్ చేయండి.
సూచనను చూపించు
ఎగువన `దిగుమతి java.util.ArrayList;` చేర్చండి. `ArrayList<String> names = కొత్త ArrayList<>();`తో జాబితాను సృష్టించండి, మూలకాలను జోడించి, దాని పరిమాణాన్ని `names.size()`తో ముద్రించండి.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
పూర్ణాంకాల పేరుతో ఉన్న సంఖ్యల శ్రేణి జాబితాను ప్రకటించండి, సంఖ్య 42ని జోడించి, get()ని ఉపయోగించి ఇండెక్స్ 0 వద్ద దాన్ని తిరిగి పొందడం ద్వారా దాన్ని ప్రింట్ చేయండి.
సూచనను చూపించు
`ArrayList<Integer> numbers = new ArrayList<>();` (పూర్ణాంక రేపర్ క్లాస్‌తో) ఉపయోగించండి మరియు దానిని `System.out.println(numbers.get(0));`తో ప్రింట్ చేయండి.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
స్ట్రింగ్ పేరు గల రంగుల శ్రేణి జాబితాను ప్రకటించండి. జాబితాకు ఎరుపు, ఆకుపచ్చ మరియు నీలం రంగులను జోడించండి. చివరగా, జాబితా ద్వారా పునరావృతం చేయడానికి మరియు స్క్రీన్‌కు ప్రతి రంగును ప్రింట్ చేయడానికి ప్రతి లూప్‌ను ఉపయోగించండి.
సూచనను చూపించు
`ArrayList<String> colours = కొత్త ArrayList<>();`తో జాబితాను ప్రకటించండి, మూడు రంగులను జోడించి, `System.out.println(c);`ని ఉపయోగించి వాటిని ప్రింట్ చేయడానికి `for (String c : colors)` లూప్‌ని ఉపయోగించండి.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది