జావాలో అర్రేని అర్రేలిస్ట్‌గా మార్చడం

హాయ్! నేటి పాఠంలో, జావాలో అర్రేని ఎలా ప్రారంభించాలి మరియు అర్రేని అర్రేలిస్ట్‌గా ఎలా మార్చాలి అనే దాని గురించి మాట్లాడుతాము. శ్రేణులు అనేది జావాలోని కంటైనర్ క్లాస్ యొక్క పొడిగింపు మరియు డేటా పరిమాణం ప్రత్యేకంగా తెలిసినప్పుడు ఆదిమ డేటా రకాలను తాత్కాలికంగా ఉంచడానికి ఒక మార్గంగా ఉపయోగపడుతుంది. కానీ సృష్టించినప్పుడు శ్రేణులు స్థిరంగా ఉంటాయి, అంటే మీరు ఒకదాన్ని సృష్టించినప్పుడు, అది కలిగి ఉన్న అంశాల సంఖ్యను మీరు మార్చలేరు. జావాలో శ్రేణిని ఎలా ప్రారంభించాలో మీరు గుర్తుంచుకోవాలి; ఇది ఇలా కనిపిస్తుంది:

datatype[] isArray;

డేటాటైప్ అనేది Int, float, long లేదా String వంటి ఏదైనా ఆదిమ డేటా రకం. మీరు డిక్లరేషన్ తర్వాత బ్రాకెట్లను కూడా ఇలా ఉంచవచ్చు:

datatype isArray[];

కాబట్టి మనం ఈ స్థిరమైన శ్రేణిని ఎలిమెంట్‌ల సంఖ్యతో ఎలా తీసుకుంటాము మరియు దానిని అర్రేలిస్ట్‌గా ఎలా మార్చాలి? సరే, ముందుగా, అర్రేలిస్ట్ అంటే ఏమిటో చూద్దాం.

అర్రేలిస్ట్

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

జావాలో అర్రే నుండి అర్రేలిస్ట్‌కి మరియు అర్రేలిస్ట్ అర్రేకి మారుతోంది

కాబట్టి, పిల్లి చెట్లను మరమ్మతు చేయడానికి మీ కంపెనీ చేతిలో ఎన్ని గింజలు మరియు బోల్ట్‌లు ఉన్నాయి అనే జాబితాను ఉంచడానికి మీరు ఒక ప్రోగ్రామ్‌ను వ్రాసారని అనుకుందాం. కొన్ని సంవత్సరాలుగా, మీకు 30 రకాల రకాలు మాత్రమే అవసరమవుతాయి, కాబట్టి ట్రాక్ చేయడానికి శ్రేణిని ఉపయోగించడం సులభం. కానీ ఇప్పుడు మీరు అదనపు 5 రకాలను స్టాక్ చేయాల్సిన కొత్త క్లయింట్‌ని కలిగి ఉన్నారు. మీరు మీ ప్రోగ్రామ్‌ను ఎలా మార్చవచ్చు మరియు మీ డేటా మొత్తాన్ని ఎలా ఉంచుకోవచ్చు మరియు మీరు మరొక క్లయింట్‌ని తీసుకున్నప్పుడు దీన్ని మళ్లీ చేయకుండా మిమ్మల్ని మీరు ఎలా నిరోధించుకోవచ్చు? నిజమే! శ్రేణి జాబితా! కాబట్టి మీరు జావా అర్రేని అర్రేలిస్ట్‌గా ఎలా మారుస్తారు? మూడు పద్ధతులు ఉన్నాయి. .asList() పద్ధతిని ఉపయోగించి జావా శ్రేణులు మీరు .asList() అనే APIని చూసినప్పుడు మీరు చూడగలిగే గొప్ప సాధనాన్ని కలిగి ఉంటాయి . కాబట్టి మీరు ఇందులో వ్రాయవచ్చు:

boltInventory.asList(bolts);

ఈ పద్ధతిలో సమస్య ఏమిటంటే ఇది నిజమైన అర్రేలిస్ట్‌ని సృష్టించదు. ఇది చేసేది పరిమాణంలో స్థిరంగా మరియు మార్చలేని జాబితాను సృష్టించడం. కాబట్టి మీరు ఇప్పటికీ డైనమిక్ మార్గంలో పరిమాణాన్ని మార్చలేరు. మూలకాలను జోడించడానికి లేదా తీసివేయడానికి ప్రయత్నిస్తే మినహాయింపు ఉంటుంది. ఇది దాని ఉపయోగాలు కలిగి ఉన్నప్పటికీ, ఇది నిజమైన మార్పిడి కాదు. కానీ మనం దీనిని ఉపయోగించవచ్చు. .asList()ని ఆర్గ్యుమెంట్‌గా ఉపయోగించడం జావాలో శ్రేణిని జాబితాగా మార్చడానికి ఇది రెండవ మార్గం. .asList() పద్ధతి జాబితాను సృష్టిస్తుంది కాబట్టి , మన వాస్తవ శ్రేణి జాబితాకు సూచనను అందించడానికి దాన్ని ఉపయోగించవచ్చు. అర్రేలిస్ట్‌ని ఎలా ప్రారంభించాలో ఇక్కడ ఉంది:

ArrayList<Integer> boltsInventory = new ArrayList<Integer>();

ఇది పది ఖాళీ సెల్‌లను కలిగి ఉన్న అర్రేలిస్ట్‌ని సృష్టిస్తుంది. అయినప్పటికీ, అర్రేలిస్ట్‌ను పూరించడానికి ఆర్గ్యుమెంట్‌ను పాస్ చేయడానికి చివర () ని ఉపయోగించవచ్చు. కాబట్టి .asList పద్ధతితో కలపడం , మీరు వీటిని కలిగి ఉంటారు:

ArrayList<Integer> boltsInventory = new ArrayList<Integer>(Arrays.asList(bolts));

ఇది .asList() పద్ధతి ద్వారా సృష్టించబడిన జాబితాను అర్రేలిస్ట్‌లోకి పంపుతుంది, కాబట్టి ఇప్పుడు మీరు దీన్ని మీకు అవసరమైన విధంగా డైనమిక్‌గా మార్చవచ్చు. Collections.addAll() పద్ధతిని ఉపయోగించడం జావాలో అర్రేని అర్రేలిస్ట్‌గా మార్చడానికి మరొక మార్గం ఈ పద్ధతిని ఉపయోగించడం. ఇది అర్రే యొక్క కంటెంట్‌లను అర్రేలిస్ట్‌కు పంపుతుంది. ఈ పద్ధతి యొక్క సాధారణ వాక్యనిర్మాణం:

Collections.addAll(c, T);

ఎక్కడ c అనేది గమ్యం మరియు T అనేది పాస్ చేయబడుతోంది. కాబట్టి మా ఉదాహరణ కోసం, వాక్యనిర్మాణం ఇలా ఉంటుంది:

ArrayList<Integer> boltsInventory = new ArrayList<Integer>():
Collections.addAll(boltsInventory, bolts);

ఇది అర్రే బోల్ట్‌ల యొక్క మొత్తం కంటెంట్‌లను కొత్త అర్రేలిస్ట్‌కి పంపుతుంది. అర్రేలిస్ట్‌ను అర్రేగా మార్చడం మీరు జావాలో అర్రేలిస్ట్‌ను అర్రేగా మార్చాల్సిన సమయం ఉండవచ్చు. మీరు అలా చేస్తే, ArrayList ఒక పద్ధతిని కలిగి ఉంటుంది .toArray(a) , ఇక్కడ a అనేది గమ్యస్థానం. కాబట్టి మా ఉదాహరణ కోసం, వాక్యనిర్మాణం ఇలా ఉంటుంది:

Integer boltsInventoryArray[] = new Integer{boltsInventory.size()];
// this ensures the newly created array is of the same size as the ArrayList
boltsInventoryArray = boltsInventory.toArray(boltsInventoryArray);

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

ముగింపు

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