చిత్రాలలో శ్రేణి జాబితా

హాయ్! ఈరోజు పాఠం ArrayListమునుపటి పాఠాల కంటే సులభంగా మరియు కష్టంగా ఉంటుంది. ఇది మరింత కష్టమవుతుంది ఎందుకంటే ఈ రోజు మనం హుడ్ కింద చూడబోతున్నాము ArrayListమరియు వివిధ కార్యకలాపాల సమయంలో ఏమి జరుగుతుందో అధ్యయనం చేస్తాము. మరోవైపు, ఈ పాఠానికి దాదాపు కోడ్ ఉండదు. ఇది ఎక్కువగా చిత్రాలు మరియు వివరణలు. సరే, వెళ్దాం :) మీకు ఇప్పటికే తెలిసినట్లుగా, ArrayListలోపల ఒక సాధారణ శ్రేణి ఉంది, ఇది డేటా స్టోర్‌గా పనిచేస్తుంది. చాలా సందర్భాలలో, మేము జాబితా యొక్క ఖచ్చితమైన పరిమాణాన్ని పేర్కొనము. కానీ అంతర్గత శ్రేణికి కొంత పరిమాణం ఉండాలి! అందువలన అది చేస్తుంది. దీని డిఫాల్ట్ పరిమాణం 10 .

public static void main(String[] args) {
   ArrayList<Car> cars = new ArrayList<>();
}

ముందుగా, కొత్త మూలకాలను జోడించడం ఎలా ఉంటుందో చూద్దాం. అంతర్గత శ్రేణిలో అంతర్గత శ్రేణికి తగినంత స్థలం ఉందో లేదో మరియు మరొక మూలకం సరిపోతుందో లేదో తనిఖీ చేయడం వ్యాపారం యొక్క మొదటి ఆర్డర్ . ఖాళీ ఉంటే, కొత్త మూలకం జాబితా చివరకి జోడించబడుతుంది. మేము "చివరి వరకు" అని చెప్పినప్పుడు, శ్రేణిలో చివరి స్థానం (అది విచిత్రంగా ఉంటుంది) అని అర్థం కాదు. మేము గత ప్రస్తుత మూలకం క్రింది స్థానం అర్థం. దీని సూచిక ఉంటుంది cars.size(). మా జాబితా ప్రస్తుతం ఖాళీగా ఉంది ( cars.size() == 0). దీని ప్రకారం, కొత్త మూలకం స్థానం 0 వద్ద జోడించబడుతుంది.

ArrayList<Car> cars = new ArrayList<>();
Car ferrari = new Car("Ferrari 360 Spider");
cars.add(ferrari);

అది తగినంత స్పష్టంగా ఉంది. మనం మధ్యలో అంటే ఇతర మూలకాల మధ్య చొప్పించినట్లయితే ఏమి జరుగుతుంది?

public static void main(String[] args) {
   ArrayList<Car> cars = new ArrayList<>();
   Car ferrari = new Car("Ferrari 360 Spider");
   Car bugatti = new Car("Bugatti Veyron");
   Car lambo = new Car("Lamborghini Diablo");
   Car ford = new Car("Ford Modneo");
  
   cars.add(ferrari);
   cars.add(bugatti);
   cars.add(lambo);
  
   cars.add(1, ford);// add ford to cell 1, which is already occupied
}

మళ్లీ, ముందుగా శ్రేణిలో తగినంత స్థలం ఉందో లేదో తనిఖీ చేయాలి. తగినంత స్థలం ఉంటే, మూలకాలు కుడివైపుకి మార్చబడతాయి , మేము కొత్త మూలకాన్ని చొప్పించే స్థానం నుండి ప్రారంభించండి. మేము స్థానం 1 వద్ద ఇన్‌సర్ట్ చేస్తున్నాము. మరో మాటలో చెప్పాలంటే, స్థానం 3 నుండి మూలకం స్థానం 4కి, మూలకం 2 నుండి స్థానం 3కి మరియు మూలకం 1 నుండి స్థానం 2కి కాపీ చేయబడుతుంది. తర్వాత మా కొత్త మూలకం దాని స్థానంలో చేర్చబడుతుంది. మునుపటి మూలకం (బుగట్టి) ఇప్పటికే అక్కడ నుండి కొత్త స్థానానికి కాపీ చేయబడింది. శ్రేణిలో కొత్త మూలకాలను చొప్పించడానికి స్థలాలు లేకుంటే ఈ ప్రక్రియ ఎలా జరుగుతుందో ఇప్పుడు చూద్దాం. సహజంగానే, తగినంత స్థలం ఉందో లేదో చూడడానికి మొదట తనిఖీ చేయాలి. తగినంత స్థలం లేకుంటే, లోపల కొత్త శ్రేణి సృష్టించబడుతుందిArrayListదీని పరిమాణం పాత శ్రేణి సమయాల పరిమాణం 1.5 ప్లస్ 1 మా విషయంలో, కొత్త శ్రేణి పరిమాణం 16 అవుతుంది. ప్రస్తుతం ఉన్న అన్ని మూలకాలు వెంటనే అక్కడకు కాపీ చేయబడతాయి. పాత శ్రేణి చెత్త కలెక్టర్ ద్వారా తొలగించబడుతుంది మరియు కొత్త, విస్తరించిన శ్రేణి మాత్రమే మిగిలి ఉంటుంది. ఇప్పుడు కొత్త మూలకం కోసం స్థలం ఉంది. మేము దానిని ఆక్రమించబడిన స్థానం 3 వద్ద చొప్పిస్తున్నాము. ఇప్పుడు తెలిసిన విధానం ప్రారంభమవుతుంది. అన్ని మూలకాలు, సూచిక 3తో మొదలై, ఒక స్థానం కుడివైపుకి మార్చబడతాయి మరియు కొత్త మూలకం నిశ్శబ్దంగా జోడించబడుతుంది. మరియు చొప్పించడం పూర్తయింది! మరియు మేము చొప్పించడం పూర్తి చేసాము. ఇప్పుడు అంశాలను తీసివేయడం గురించి మాట్లాడుదాం . శ్రేణులతో పని చేస్తున్నప్పుడు మేము సమస్యను ఎదుర్కొన్నామని మీరు గుర్తుంచుకోవాలి: ఎలిమెంట్‌లను తీసివేయడం వలన శ్రేణిలో "రంధ్రాలు" ఏర్పడతాయి.ప్రతి తీసివేతతో, మరియు ఈ షిఫ్ట్‌ని నిర్వహించడానికి మేము ప్రతిసారీ మా స్వంత కోడ్‌ని వ్రాయవలసి ఉంటుంది. ArrayList అదే సూత్రాన్ని అనుసరిస్తుంది, కానీ ఇది ఇప్పటికే ఈ విధానాన్ని అమలు చేస్తుంది. ఇది ఇలా కనిపిస్తుంది: మరియు చివరికి మనకు కావలసినది మనకు లభిస్తుంది: మూలకం lamboతీసివేయబడింది. ఇక్కడ మేము మధ్య నుండి ఒక మూలకాన్ని తీసివేసాము. స్పష్టంగా, జాబితా చివర నుండి ఒక మూలకాన్ని తీసివేయడం వేగవంతమవుతుంది, ఎందుకంటే మిగిలినవన్నీ మార్చాల్సిన అవసరం లేకుండా మూలకం తీసివేయబడుతుంది. అంతర్గత శ్రేణి యొక్క కొలతలు మరియు అది మెమరీలో ఎలా అమర్చబడిందో గురించి ఒక క్షణం మళ్ళీ మాట్లాడుకుందాం. శ్రేణిని విస్తరించడానికి కొంత వనరులు అవసరం. దీని ప్రకారం, ఒక సృష్టించవద్దుArrayListడిఫాల్ట్ పరిమాణంతో అది కనీసం 100 మూలకాలను కలిగి ఉంటుందని మీకు ఖచ్చితంగా తెలిస్తే. మీరు 100వ మూలకాన్ని చొప్పించే సమయానికి అంతర్గత శ్రేణిని 6 సార్లు విస్తరించవలసి ఉంటుంది మరియు ప్రతిసారీ అన్ని మూలకాలను మార్చవలసి ఉంటుంది.

• 10 మూలకాల నుండి 16 వరకు
• 16 మూలకాల నుండి 25 వరకు
• 25 నుండి 38 వరకు
• 38 నుండి 58 వరకు
• 58 నుండి 88 వరకు
• 88 నుండి 133 వరకు (అంటే పాత శ్రేణి పరిమాణం 1.5 ప్లస్ 1)

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

ArrayList<Car> cars = new ArrayList<>(100);

ఇప్పుడు 100 మూలకాల శ్రేణి కోసం మెమరీ ఒకేసారి కేటాయించబడుతుంది, ఇది శ్రేణిని మరింత సమర్థవంతంగా చేస్తుంది (దీనిని విస్తరించాల్సిన అవసరం లేదు). ఈ వ్యూహానికి ఒక ఫ్లిప్ సైడ్ కూడా ఉంది. మీరు ఒక నుండి వస్తువులను తీసివేసినప్పుడు ArrayList, అంతర్గత శ్రేణి పరిమాణం స్వయంచాలకంగా తగ్గదు. మేము ArrayList88 మూలకాల యొక్క పూర్తి అంతర్గత శ్రేణిని కలిగి ఉన్నామని అనుకుందాం: ప్రోగ్రామ్ నడుస్తున్నప్పుడు, మేము 77 మూలకాలను తీసివేస్తాము, కాబట్టి 11 మాత్రమే మిగిలి ఉన్నాయి: సమస్య ఏమిటో మీరు ఇప్పటికే ఊహించారా? మీకు అర్థమైంది, మెమరీని అసమర్థంగా ఉపయోగించడం! మేము ఇక్కడ 11 స్థానాలను మాత్రమే ఉపయోగిస్తున్నాము, కానీ మేము 88 మూలకాల కోసం మెమరీని కేటాయించాము. అది మనకు అవసరమైన దానికంటే 8 రెట్లు ఎక్కువ! ArrayListఈ సందర్భంలో, మేము తరగతి యొక్క ప్రత్యేక పద్ధతుల్లో ఒకదానితో మా మెమరీ వినియోగాన్ని ఆప్టిమైజ్ చేయవచ్చు :trimToSize(). ఈ పద్ధతి అంతర్గత శ్రేణి యొక్క పొడవును దానిలో ప్రస్తుతం నిల్వ చేయబడిన మూలకాల సంఖ్యకు "ట్రిమ్" చేస్తుంది. ఇప్పుడు మనకు అవసరమైనంత మెమరీని మాత్రమే కేటాయించాము! :)