అర్రేలిస్ట్, పార్ట్ 2తో పని చేస్తోంది

1. జాబితా మధ్యలో (లేదా ప్రారంభంలో) ఒక మూలకాన్ని జోడించడం

మేము జాబితా మధ్యలో ఒక మూలకాన్ని చొప్పించాలనుకుంటే, జాబితా లోపల ఏమి జరుగుతుందో ఇక్కడ ఉంది.

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

మేము సూచిక 5 వద్ద జాబితాలోకి 10,000 సంఖ్యను చేర్చాలనుకుంటున్నాము. దీన్ని చేయడానికి, మేము కేవలం అమలు చేయాలి:

list.add(5, 10000);

వేరియబుల్ ఎక్కడ listఉంది ArrayList. పద్ధతి add(int index, type value)జాబితాలో 5వ స్థానంలో 10000 విలువను జోడిస్తుంది. పద్ధతిలో ఏమి జరుగుతుందో ఇక్కడ ఉంది add():

దశ 1: 5వ స్థానం నుండి ప్రారంభమయ్యే శ్రేణిలోని అన్ని ఎలిమెంట్‌లు 1 మూలకం ద్వారా శ్రేణి చివరకి మార్చబడతాయి (కాపీ చేయబడతాయి):

శ్రేణిలోని 5వ మరియు 6వ సెల్‌లోని మూలకాలు ఇప్పుడు ఒకేలా ఉన్నాయని గమనించండి.

దశ 2: 5వ సెల్‌లో 10,000 విలువను వ్రాయండి:

ఇప్పుడు జాబితా శ్రేణిలోని అన్ని అంశాలను కలిగి ఉంది మరియు ఐదవ సెల్ సంఖ్య 10,000ని కలిగి ఉంది. మనం కోరుకున్నది మాత్రమే.

2. జాబితా నుండి మూలకాన్ని తీసివేయడం

జాబితా నుండి ఒక మూలకాన్ని తీసివేయడం అనేది దానిని చొప్పించినట్లే, కానీ ప్రక్రియ రివర్స్ చేయబడింది.

జాబితా నుండి 3వ మూలకాన్ని తీసివేద్దాం. దీన్ని చేయడానికి, మేము అమలు చేయాలి:

list.remove(3);

తొలగించు() పద్ధతిలో ఏమి జరుగుతుందో ఇక్కడ ఉంది:

దశ 1: 4వ స్థానం నుండి ప్రారంభమయ్యే శ్రేణి యొక్క మూలకాలు 1 మూలకం ద్వారా శ్రేణి ప్రారంభం వైపుకు మార్చబడతాయి (కాపీ చేయబడతాయి):

దశ 2: వేరియబుల్ విలువ size1 తగ్గుతుంది.

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

దశ 3: చెత్తను శుభ్రం చేయడం

3. జావాలో జాబితాతో పని చేసే ఆచరణాత్మక ఉదాహరణలు

జాబితాలతో పని చేయడానికి కొన్ని ఉదాహరణలను వ్రాద్దాం:

మేము 1 నుండి 20 వరకు ఉన్న అన్ని సరి సంఖ్యలను జాబితా చేస్తాము:

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

for (int i = 1; i <= 20; i++)
   if (i%2 == 0)
      list.add(i);

ఇప్పుడు జాబితాలోని అన్ని అంశాలను తెరపై ప్రదర్శిస్తాము:

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

for (int i = 1; i <= 20; i++)
   if (i%2 == 0)
      list.add(i);

for (int i = 0; i < list.size(); i++)
   System.out.println(list.get(i));

ఎలిమెంట్లను తొలగించడం:

ఇప్పుడు 4 ద్వారా భాగించబడే అన్ని మూలకాలను తీసివేద్దాం. జాబితా నుండి ఒక మూలకాన్ని తీసివేసిన తర్వాత, మిగిలిన మూలకాల స్థానాలు వెంటనే మారుతాయని గమనించండి.

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

for (int i = 1; i <= 20; i++)
   if (i%2 == 0)
      list.add(i);

for (int i = 0; i < list.size(); i++)
   if (list.get(i)%4 == 0)
   {
      list.remove(i);
      i--;
   }

మీరు జాబితా నుండి చివరి 3 మూలకాలను తీసివేయాలని అనుకుందాం.

దీన్ని తప్పుగా ఎలా చేయాలో ఇక్కడ ఉంది:

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

for (int i = 1; i <= 20; i++)
   if (i%2 == 0)
      list.add(i);

int n = list.size();
list.remove(n - 3);
list.remove(n - 2);
list.remove(n - 1);

7వ మరియు 8వ మూలకాలను తీసివేసిన తర్వాత, జాబితాలో 8 అంశాలు మాత్రమే మిగిలి ఉంటాయి. అంటే 9వ మూలకాన్ని తొలగించడం సాధ్యం కాదు — ప్రోగ్రామ్‌లో లోపం ఏర్పడుతుంది.

మూలకాలను తీసివేయడానికి ఇక్కడ సరైన మార్గం:

int n = list.size();
list.remove(n - 3);
list.remove(n - 3);
list.remove(n - 3);

int n = list.size();
list.remove(n - 1);
list.remove(n - 2);
list.remove(n - 3);

మూలకాలు ముగింపు నుండి లేదా మరొక స్థిరమైన స్థానం నుండి తీసివేయబడాలి, ఎందుకంటే ప్రతి తొలగింపు ఆపరేషన్ తర్వాత మూలకాలు ఒకదానితో మార్చబడతాయి.