అర్రేలిస్ట్

"నేను ఇక్కడ ఉన్నాను."

"హాయ్, ఎల్లీ!"

"ఈ రోజు మనం ఒక ఆసక్తికరమైన అంశం గురించి మాట్లాడుతాము. నేను మీకు అర్రేలిస్ట్ క్లాస్ గురించి చెప్పబోతున్నాను ."

"కొత్త క్లాస్? కూల్! అది ఏమి చేయగలదు?"

"నేను బ్యాక్ స్టోరీతో ప్రారంభిస్తాను. ప్రోగ్రామర్లు శ్రేణుల గురించి ఇష్టపడని ఏకైక విషయం ఏమిటంటే, మీరు వాటి పరిమాణాన్ని మార్చలేరు. మీరు ఒక ఉచిత స్లాట్ ఉన్న శ్రేణికి మరో మూడు మూలకాలను జోడించాలనుకుంటే మీరు ఏమి చేయాలి? "

"ఈ సమస్యకు ఏకైక పరిష్కారం చాలా పెద్ద శ్రేణులను సృష్టించడం, మీరు అన్ని మూలకాలకు తగినంత గదిని కలిగి ఉన్నారని హామీ ఇవ్వడానికి. అయితే, ఇది తరచుగా మెమరీని వృధా చేస్తుంది. ఒక శ్రేణి సాధారణంగా మూడు మూలకాలను కలిగి ఉంటే, కానీ అతి చిన్న అవకాశం కూడా ఉంటుంది. ఇది 100 ఎలిమెంట్స్‌ను కలిగి ఉండవలసి ఉంటుంది, మీరు 100-మూలకాల శ్రేణిని సృష్టించాలి."

"కాబట్టి, ప్రోగ్రామర్లు ఏమి కనుగొన్నారు?"

"వారు అర్రేలిస్ట్ క్లాస్‌ని వ్రాసారు, ఇది అర్రే వలె అదే పనిని చేస్తుంది, కానీ అది దాని పరిమాణాన్ని మార్చగలదు."

"ఆసక్తికరమైన కదలిక. వారు ఎలా చేసారు?"

"ప్రతి అర్రేలిస్ట్ ఆబ్జెక్ట్ మూలకాల యొక్క సాధారణ శ్రేణిని నిల్వ చేస్తుంది. మీరు అర్రేలిస్ట్ నుండి ఎలిమెంట్‌లను చదివినప్పుడు , అది దాని అంతర్గత శ్రేణి నుండి వాటిని చదువుతుంది. మీరు వాటిని అర్రేలిస్ట్‌కి వ్రాసినప్పుడు , అది వాటిని దాని అంతర్గత శ్రేణికి వ్రాస్తుంది. ఇక్కడ, ఈ నిలువు వరుసలను సరిపోల్చండి:"

String[] list = new String[10];

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

int n = list.length;

int n = list.size();

String s = list[3];

String s = list.get(3);

list[3] = s;

list.set(3, s);

"కాబట్టి, అర్రేలిస్ట్ ఎందుకు మంచిది? నేను చెప్పగలిగినంతవరకు, కోడ్ ఇప్పుడు పొడవుగా ఉంది."

"మొదట, ప్రోగ్రామర్లు అన్ని సమయాలలో నిర్వహించాల్సిన అనేక అదనపు కార్యకలాపాలకు ArrayList మద్దతు ఇస్తుంది. ఒక సాధారణ శ్రేణి ఈ కార్యకలాపాలకు మద్దతు ఇవ్వదు. ఉదాహరణకు, రంధ్రాలను వదలకుండా శ్రేణి మధ్యలో నుండి మూలకాలను చొప్పించడం లేదా తొలగించడం .

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

ఎ) ప్రస్తుత అంతర్గత శ్రేణి కంటే 50% పెద్దదిగా ఉన్న మరొక శ్రేణి సృష్టించబడింది, అదనంగా ఒక మూలకం.

బి) పాత శ్రేణిలోని అన్ని అంశాలు కొత్తదానికి కాపీ చేయబడతాయి.

c) కొత్త శ్రేణి అర్రేలిస్ట్ ఆబ్జెక్ట్ యొక్క అంతర్గత శ్రేణిగా సేవ్ చేయబడింది. పాత శ్రేణి చెత్తగా ప్రకటించబడింది (మేము దాని సూచనను నిల్వ చేయడం మానేస్తాము)."

list.add(s);

list.add(15, s);

list.add(0, s);

list.remove(3);

"మేము ఈ అర్రేలిస్ట్‌తో ఎలా పని చేస్తాము?"

"వాస్తవానికి, మనం సాధారణ శ్రేణితో చేసినట్లే. చూడండి. అర్రేలిస్ట్‌తో పని చేయడాన్ని శ్రేణితో పని చేయడంతో పోల్చండి. మనం '10 స్ట్రింగ్‌లలో చదివి, వాటిని రివర్స్డ్ ఆర్డర్‌లో స్క్రీన్‌పై ప్రదర్శించాలి ' అనుకుందాం ."

"దీని వైపు చూడు:

public static void main(String[] args)
{
Reader r = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(r);

// Read strings from the keyboard
String[] list = new String[10];
for (int i = 0; i < list.length; i++)
{
  String s = reader.readLine();
  list[i] = s;
}

// Display the contents of the array
for (int i = 0; i < list.length; i++)
{
  int j = list.length - i - 1;
  System.out.println( list[j] );
}
}

public static void main(String[] args)
{
Reader r = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(r);

// Read strings from the keyboard
ArrayList&ltString> list = new ArrayList&ltString>();
for (int i = 0; i < 10; i++)
{
  String s = reader.readLine();
  list.add(s);
}

// Display the contents of the collection
for (int i = 0; i < list.size(); i++)
{
  int j = list.size() - i - 1;
  System.out.println( list.get(j) );
}
}

ప్రతి నిలువు వరుసలో ఒకే విధమైన చర్యలను హైలైట్ చేయడానికి నేను అదే రంగును ఉపయోగించాను."

"ఒక వైపు, ప్రతిదీ భిన్నంగా ఉంటుంది, మరోవైపు, ఇది ఇప్పటికీ అలాగే ఉంది."

"కుడి. మేము అర్రేలిస్ట్‌తో పని చేస్తున్నప్పుడు స్క్వేర్ బ్రాకెట్‌లను ఉపయోగించము . బదులుగా, మేము పొందడం , సెట్ చేయడం మరియు జోడించే పద్ధతులను ఉపయోగిస్తాము."

"అవును, నేను ఇంత సేకరించాను. ఇప్పటికీ, అది చాలా అదే విధంగా కనిపిస్తుంది."