జావా అరేలిస్ట్ ఎలా ఉపయోగించాలి

జావాకు శ్రేణి జాబితా ఒక సాధారణ ప్రయోజన పున resపరిమాణ శ్రేణి. ఇది సాధారణంగా ఇతర భాషలలో శ్రేణుల నుండి ఆశించే చాలా సౌకర్యాలను అందిస్తుంది. వీటిలో ఇవి ఉన్నాయి: ఇండెక్స్ ఉపయోగించి ఎలిమెంట్‌లను యాక్సెస్ చేయడం, ఎలిమెంట్‌లను జోడించడం, తీసివేయడం మరియు అప్‌డేట్ చేయడం, డైనమిక్ రీ-సైజింగ్, ఎలిమెంట్స్‌పై ఇట్రేటింగ్, మొదలైనవి. ఈ ఆపరేషన్లలో చాలా వరకు సాధారణ ప్రయోజన వినియోగం కోసం ప్రత్యేకంగా సర్దుబాటు చేయబడ్డాయి.

క్రోమ్‌బుక్‌లో ఆడియోను ఎలా రికార్డ్ చేయాలి

మరికొన్ని రకాల 'శ్రేణులు' ఉన్నాయి (అమలు చేసే తరగతులు జాబితా ఇంటర్‌ఫేస్, సాంకేతికంగా ఉండాలి) ఇవి ప్రత్యేక ప్రయోజనాల కోసం ఉద్దేశించబడ్డాయి. వీటితొ పాటు:

---

---

• లింక్డ్లిస్ట్ ఇంటర్మీడియట్ సూచికల వద్ద వేగంగా చొప్పించడం మరియు తీసివేయడానికి మద్దతు ఇస్తుంది.
• వెక్టర్ ఒక మాదిరిగానే ఉంటుంది శ్రేణి జాబితా కానీ సమకాలీకరించబడింది మరియు ఒక స్థానంలో అనుకూలంగా ఉంటుంది శ్రేణి జాబితా బహుళ-థ్రెడ్ అనువర్తనాల కోసం.
• స్టాక్ లాస్ట్-ఇన్-ఫస్ట్-అవుట్ జాబితాను అనుకరించే కార్యకలాపాలకు మద్దతు ఇస్తుంది. ఇది విస్తరించింది వెక్టర్ మరియు అందువల్ల సమకాలీకరించబడింది.

ఈ ప్రత్యేక తరగతులు ఈ వ్యాసం పరిధికి వెలుపల ఉన్నాయి. అయితే, సాధారణ-ప్రయోజన జావా అరేలిస్ట్‌ను ఎలా సెటప్ చేయాలో మరియు ఎలా ఉపయోగించాలో మీరు నేర్చుకుంటారు.

శ్రేణి జాబితాను సృష్టిస్తోంది

ఒక సృష్టిస్తోంది శ్రేణి జాబితా సులభం. ఒక ఖాళీ శ్రేణి జాబితా వాదనలు లేని కన్స్ట్రక్టర్‌ని ఉపయోగించి సృష్టించవచ్చు. స్ట్రింగ్‌లను పట్టుకోవడం కోసం ఇక్కడ మేము ఖాళీ శ్రేణి జాబితాను సృష్టిస్తాము.

ArrayList alist = new ArrayList();


మీ శ్రేణి జాబితాలో ఎన్ని అంశాలు ఉంటాయో మీకు తెలిస్తే, మీరు ప్రారంభ సామర్థ్యాన్ని పేర్కొనవచ్చు. ఈ ప్రారంభ సామర్థ్యం మెమరీ కేటాయింపు కోసం సూచన మాత్రమే - శ్రేణి జాబితా పేర్కొన్న సంఖ్యలో వస్తువులను కలిగి ఉండటానికి పరిమితం కాదు. ప్రారంభ సామర్థ్యం మీకు తెలిస్తే మరియు పేర్కొన్నట్లయితే, మీరు ఉండవచ్చు పనితీరులో స్వల్ప మెరుగుదల పొందండి.

ArrayList alist = new ArrayList(20);


అరేలిస్ట్‌లో జనాభాను కలిగి ఉంది

ముగింపులో అంశాలను జోడిస్తోంది

శ్రేణి జాబితాను జనాదరణ చేయడం చాలా సులభం. కేవలం ఉపయోగించండి జోడించు () శ్రేణి జాబితా చివరలో ఒకే అంశాన్ని జోడించే పద్ధతి. ఇక్కడ ఒక ఉదాహరణ:

ArrayList alist = new ArrayList();
alist.add('apple');
alist.add('banana');
alist.add('cantaloupe');
alist.add('orange');
System.out.println(alist);
# prints
[apple, banana, cantaloupe, orange]


శ్రేణి జాబితాలో ఎన్ని అంశాలు ఉన్నాయో తెలుసుకోవడానికి, పద్ధతిని ఉపయోగించండి పరిమాణం () .

---

---

System.out.println('Number of elements in the arraylist: ' + alist.size());
# prints
Number of elements in the arraylist: 4

పేర్కొన్న సూచికలో అంశాలను జోడించడం

ఏకపక్ష సూచికలో ఒక అంశాన్ని జోడించాలనుకుంటున్నారా? సూచికను మొదటి వాదనగా పేర్కొనండి మరియు ఆ సూచికలో అంశం జోడించబడింది:

alist.add(3, 'grapes');
System.out.println(alist);
# prints
[apple, banana, cantaloupe, grapes, orange]


అంశాల సమూహాన్ని కలుపుతోంది

మీరు జావా కలెక్షన్స్ సోపానక్రమంలో కూడా ఏదైనా సేకరణ నుండి అంశాలను జోడించవచ్చు. ఒక శ్రేణి జాబితా అని పిలవబడే ఒక నిర్దిష్ట రకం జాబితా . A ని నిర్మించడానికి ఇక్కడ ఒక మార్గం ఉంది జాబితా వస్తువుల సమూహం నుండి (ఉపయోగించడం Arrays.asList () ) మరియు దానిని ఒక దానికి జోడించండి శ్రేణి జాబితా .

---

---

List items = Arrays.asList('pear', 'cherry');
alist.addAll(items);
System.out.println(alist);
# prints
[apple, banana, cantaloupe, grapes, orange, pear, cherry]


వాస్తవానికి, ఆ సూచికలో ప్రారంభమయ్యే అంశాలను జోడించడానికి మీరు ఇక్కడ మొదటి వాదనగా సూచికను పేర్కొనవచ్చు.

వస్తువులను యాక్సెస్ చేస్తోంది

అంశాలను జాబితా శ్రేణికి చేర్చిన తర్వాత, మేము వాటిని మళ్లీ ఎలా యాక్సెస్ చేయాలి?

ఇండెక్స్‌తో యాక్సెస్ చేస్తోంది

మీకు అంశం సూచిక తెలిస్తే, మీరు దానిని ఉపయోగించవచ్చు పొందండి () ఆ సూచికలో మూలకాన్ని తిరిగి పొందడానికి పద్ధతి.

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

String item = alist.get(2);
System.out.println('Item at index 2 is: ' + item);
# prints
Item at index 2 is: cantaloupe


అంశాలను కనుగొనడం

వస్తువు యొక్క సూచిక మీకు తెలియకపోతే ఏమి చేయాలి? మీరు ఉపయోగించవచ్చు ఇండెక్స్ ఆఫ్ () అంశం శ్రేణిలో ఉందో లేదో తనిఖీ చేయడానికి మరియు తిరిగి వచ్చిన సూచికను ఉపయోగించి అంశాన్ని తిరిగి పొందండి.

System.out.println(alist);
int index = alist.indexOf('orange');
if ( index <0 )
System.out.println('Item 'orange' not found');
else
System.out.println('Item 'orange' found at index ' + index);
# prints
[apple, banana, cantaloupe, grapes, orange, pear, cherry]
Item 'orange' found at index 4


అంశం శ్రేణి జాబితాలో లేనట్లయితే ఏమి చేయాలి? ది ఇండెక్స్ ఆఫ్ () అంశం కనుగొనబడనప్పుడు పద్ధతి -1 తిరిగి వస్తుంది.

index = alist.indexOf('grape');
if ( index <0 )
System.out.println('Item 'grape' not found');
else
System.out.println('Item 'grape' found at index ' + index);
# prints
Item 'grape' not found


శ్రేణి జాబితాపై పునరావృతం

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

శ్రేణి జాబితాపై పునరుద్ఘాటించడానికి మరియు కొన్ని రకాల ప్రాసెసింగ్ కోసం అంశాలను సంగ్రహించడానికి ఇక్కడ సరళమైన మార్గం ఉంది.

for (String fruit : alist) {
System.out.println('Found fruit '' + fruit + ''');
}
# prints
Found fruit 'apple'
Found fruit 'banana'
Found fruit 'cantaloupe'
Found fruit 'grapes'
Found fruit 'orange'
Found fruit 'pear'
Found fruit 'cherry'


ఈ కోడ్ జావా 1.5 లో ప్రవేశపెట్టిన జావా మెరుగైన ఫోర్-లూప్‌ను ఉపయోగిస్తుంది. దానికి ముందు, మీరు ఐటరేటర్‌తో ఐటెమ్‌లపై మళ్లీ చెప్పవచ్చు. మీకు అవసరమైనప్పుడు ఇటరేటర్ కూడా ఉపయోగించబడుతుంది తొలగించు దిగువ ఉదాహరణ వివరిస్తున్నట్లుగా పునరుక్తి ప్రక్రియలో మూలకాలు. (మేము శ్రేణి జాబితా యొక్క కాపీని తయారు చేసి, కాపీపై పని చేస్తామని గమనించండి.)

ArrayList blist = new ArrayList(alist);
for (Iterator iter = blist.iterator() ; iter.hasNext() ; ) {
String fruit = iter.next();
if ( fruit.startsWith('c') )
iter.remove();
else
System.out.println('Keeping '' + fruit + ''');
}
# prints
Keeping 'apple'
Keeping 'banana'
Keeping 'grapes'
Keeping 'orange'
Keeping 'pear'


అంశాలను భర్తీ చేయడం

అంశాలు జోడించబడిన తర్వాత, అవాంఛిత వస్తువులను భర్తీ చేయడానికి మాకు ఒక మార్గం అవసరం. దీనిని ఉపయోగించడం ద్వారా చేయవచ్చు సెట్ () సూచికతో పద్ధతి.

alist.set(5, 'pineapple');
System.out.println(alist);
# prints
[apple, banana, cantaloupe, grapes, orange, pineapple, cherry]


అంశాలను తొలగించడం

శ్రేణి జాబితా నుండి అంశాలను ఎలా తీసివేయవచ్చో ఇప్పుడు చూద్దాం. వస్తువు యొక్క సూచిక మీకు తెలిస్తే (బహుశా మీరు ఉపయోగించారు ఇండెక్స్ ఆఫ్ () పైన వివరించబడింది), మీరు దీనిని ఉపయోగించవచ్చు తొలగించు () సూచికతో పద్ధతి. ఇది తీసివేయబడిన మూలకాన్ని అందిస్తుంది.

String fruit = alist.remove(2);
System.out.println('Removed element at 2: ' + fruit);
# prints
Removed element at 2: cantaloupe


మీరు తొలగించడానికి మూలకాన్ని కూడా పేర్కొనవచ్చు ప్రధమ జాబితాలో మూలకం సంభవించడం. పద్ధతి తిరిగి వస్తుంది నిజం మూలకం కనుగొనబడి, తీసివేయబడితే.

మీరు మీ స్నాప్‌చాట్ ఫిల్టర్‌ను ఎలా పొందవచ్చు

fruit = 'grapes';
System.out.println('Remove ' +fruit+ ' from the list? ' + alist.remove(fruit));
# prints
Remove grapes from the list? true


మీరు దీన్ని ఎలా ఉపయోగిస్తున్నారు శ్రేణి జాబితా మీ ప్రాజెక్ట్‌లలో మరియు మీరు ఏ ప్రత్యేక సమస్యలను ఎదుర్కొన్నారు? దయచేసి దిగువ వ్యాఖ్యలలో మాకు తెలియజేయండి.

షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ Android లో Google యొక్క అంతర్నిర్మిత బబుల్ స్థాయిని ఎలా యాక్సెస్ చేయాలి

మీరు ఎప్పుడైనా చిటికెలో ఏదో స్థాయిని నిర్ధారించుకోవాల్సిన అవసరం ఉంటే, మీరు ఇప్పుడు మీ ఫోన్‌లో బబుల్ స్థాయిని సెకన్లలో పొందవచ్చు.

తదుపరి చదవండి సంబంధిత అంశాలు

• ప్రోగ్రామింగ్
• జావా

రచయిత గురుంచి జై శ్రీధర్(17 కథనాలు ప్రచురించబడ్డాయి) జే శ్రీధర్ నుండి మరిన్ని

మా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి

టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!

సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి