ArrayListతో పని చేస్తోంది

1. ఎలా ArrayListనిర్మించబడింది

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

యొక్క నిర్మాణం ArrayListసరళమైనది మరియు తెలివిగా ఉంటుంది. ప్రతి ArrayListవస్తువు రెండు ఫీల్డ్‌లను కలిగి ఉంటుంది:

• మూలకాల శ్రేణి
• ఒక sizeవేరియబుల్, ఇది జాబితాలోని మూలకాల సంఖ్యను నిల్వ చేస్తుంది

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

ప్రారంభంలో, జాబితా లోపల శ్రేణి పొడవు 10. మరియు sizeవేరియబుల్ 0.

మీరు జాబితాకు ఒక మూలకాన్ని జోడిస్తే, అది శ్రేణిలోని 0వ సెల్‌లో నిల్వ చేయబడుతుంది మరియు size1కి పెరుగుతుంది.

మీరు మరో మూలకాన్ని జోడిస్తే, అది 1వ సెల్‌లో నిల్వ చేయబడుతుంది మరియు sizeమళ్లీ 1 పెరుగుతుంది మరియు రెండుకి సమానం అవుతుంది.

శ్రేణిలో ఎక్కువ ఖాళీ లేనప్పుడు మీరు మరొక మూలకాన్ని జోడిస్తే, ఈ క్రింది పద్ధతిలో జరుగుతుంది add():

1. కొత్త శ్రేణి సృష్టించబడింది , ఇది మునుపటి కంటే ఒకటిన్నర రెట్లు ఎక్కువ
2. పాత శ్రేణిలోని అన్ని అంశాలు కొత్త శ్రేణిలోకి కాపీ చేయబడతాయి.
3. ఆబ్జెక్ట్‌లో ArrayList, కొత్త శ్రేణికి సంబంధించిన సూచన పాత దానికి సంబంధించిన సూచనను భర్తీ చేస్తుంది .
4. పాస్ చేసిన మూలకం కొత్త శ్రేణిలోని 10వ సెల్‌లో సేవ్ చేయబడింది .
5. పరిమాణం వేరియబుల్ 1 ద్వారా పెరుగుతుంది మరియు ఇప్పుడు 11కి సమానం అవుతుంది

జాబితా మధ్యలో ఒక మూలకాన్ని జోడించేటప్పుడు (చొప్పించడం) ఇలాంటిదే జరుగుతుంది. ఇప్పటికే ఉన్న మూలకాలు 1 ద్వారా కుడివైపుకి మార్చబడతాయి మరియు పాస్ చేయబడిన మూలకం శ్రేణి యొక్క కొత్తగా విడుదల చేయబడిన సెల్‌కు వ్రాయబడుతుంది.

ఇప్పుడు మేము జాబితాలతో కూడిన అత్యంత ప్రాథమిక దృశ్యాలను పరిశీలిస్తాము:

2. ఒక మూలకాన్ని జోడించడంArrayList

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

మనకు ArrayListరెండు ఫీల్డ్‌లు (రెండు వేరియబుల్స్) ఉన్న వస్తువు ఉంది: ఒక కంటైనర్ (అరే data) మరియు నిల్వ చేయబడిన మూలకాల సంఖ్య ( size). వేరియబుల్ data10 మూలకాలను నిల్వ చేయగల కంటైనర్ (అరే)కి సూచనను నిల్వ చేస్తుంది.

మేము శ్రేణికి 5 సంఖ్యను జోడించాలని నిర్ణయించుకుంటే, మేము ఈ క్రింది చిత్రాన్ని పొందుతాము:

శ్రేణి ఇప్పుడు మూలకం 5 మరియు size == 1.

ఎవరైనా ఇప్పుడు size()మన ArrayListఆబ్జెక్ట్‌పై పద్ధతిని కాల్ చేస్తే, జాబితాలో నిల్వ చేయబడిన మూలకాల సంఖ్య రిటర్న్ విలువ అవుతుంది: 1. జాబితాలోని మూలకాల సంఖ్య, శ్రేణి నిల్వ సామర్థ్యంతో సమానంగా ఉండదు.

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

జాబితాకు మరో 7 సంఖ్యలను జోడిద్దాం: 10, 20, 30, 40, 50, 60, 70.

ఇప్పుడు మెమరీ ఇలా కనిపిస్తుంది:

మీరు size()ఇప్పుడు పద్ధతికి కాల్ చేస్తే, అది జాబితాలోని కొత్త మూలకాల సంఖ్య అయిన 8 సంఖ్యను అందిస్తుంది. ఈ విలువకు అంతర్గత శ్రేణి పరిమాణంతో సంబంధం లేదు.

3. జాబితా పొడవును పెంచడం

జాబితా అంతర్గత శ్రేణిలో ఖాళీ సెల్‌లు లేనప్పుడు దాని లోపల ఏమి జరుగుతుందో చూద్దాం.

మనకు 10 మూలకాల జాబితా ఉందని అనుకుందాం:

మేము దానికి 100 సంఖ్యను జోడించాలని నిర్ణయించుకున్నాము . పద్ధతిలో ఇది జరుగుతుంది add():

దశ 1 — కొత్త శ్రేణిని సృష్టించండి:

దశ 2 — పాత శ్రేణి నుండి కొత్తదానికి అన్ని మూలకాలను కాపీ చేయండి:

దశ 3 — పాత శ్రేణిని భర్తీ చేయండి (ఆబ్జెక్ట్ యొక్క అంతర్గత శ్రేణికి సూచనను మార్చండి ArrayList):

స్టెప్ 4 — కొత్త నంబర్‌ను జోడించండి, ఇది మేము కష్టపడి సాధించాము: