జావాలో సేకరణలు: అర్రేలిస్ట్

1. ArrayListతరగతి

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

సేకరణలు ఎలా నిర్మాణాత్మకంగా ఉన్నాయి మరియు వాటి అన్ని సూక్ష్మ నైపుణ్యాలను పూర్తిగా అర్థం చేసుకోవడానికి, మీరు మొదట OOP, ఇంటర్‌ఫేస్‌లు, వారసత్వం, మల్టీథ్రెడింగ్ యొక్క ప్రాథమిక అంశాలు మరియు మరిన్నింటిని నేర్చుకోవాలి.

కాబట్టి ఈ రోజు మనం సరళమైన రకమైన సేకరణతో పరిచయం పొందుతాము. కానీ తగినంత లోతైన స్థాయిలో మీరు దీన్ని ఎలా ఉపయోగించాలో మరియు ఎలా పని చేస్తుందో అర్థం చేసుకోవచ్చు. ఇప్పుడు, ArrayListసేకరణను కలవండి .

వెనుక కథ

నేను కొద్దిగా నేపథ్యంతో ప్రారంభిస్తాను. ప్రోగ్రామర్లు నిజంగా శ్రేణుల యొక్క ఒక అంశాన్ని ఇష్టపడలేదు: వాటి పరిమాణాన్ని మార్చడం సాధ్యం కాదు. మీరు ఒక శ్రేణిలో మరో మూడు మూలకాలను నిల్వ చేయవలసి వస్తే, ఒక ఖాళీ సెల్ మాత్రమే ఉంటే?

శ్రేణి యొక్క స్థల పరిమితులకు ఏకైక పరిష్కారం మీరు నిల్వ చేయవలసిన అన్ని అంశాలకు అనుగుణంగా చాలా పెద్ద శ్రేణిని సృష్టించడం. కానీ ఇది సాధారణంగా జ్ఞాపకశక్తిని వృధా చేస్తుంది. ఒక శ్రేణి సాధారణంగా రెండు లేదా మూడు మూలకాలను కలిగి ఉండి, వాటిలో 100ని నిల్వ చేయడానికి ఒక చిన్న అవకాశం కూడా ఉంటే, అప్పుడు 100ని నిల్వ చేయగల సామర్థ్యంతో శ్రేణిని సృష్టించడం అవసరం.

కాబట్టి ప్రోగ్రామర్లు ఏమి వచ్చారు? వారు తరగతిని వ్రాసారు ArrayList, ఇది తరగతి వలె అదే పనిని చేసింది Array, కానీ పరిమాణం మార్చదగినది.

అర్రేలిస్ట్ క్లాస్

తరగతి పేరు ArrayListరెండు పదాల నుండి ఏర్పడింది: అర్రే + జాబితా. Arrayశ్రేణి మరియు Listజాబితా.

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

అర్రేలిస్ట్ క్లాస్‌లో శ్రేణులు కలిగి ఉన్న అన్ని ప్రతికూలతలు లేవు. ఇది ఎలా చేయాలో తెలుసు:

• ఒక నిర్దిష్ట రకం మూలకాలను నిల్వ చేయండి
• డైనమిక్‌గా జాబితా పరిమాణాన్ని మార్చండి
• జాబితా చివర మూలకాలను జోడించండి
• జాబితా ప్రారంభంలో లేదా మధ్యలో మూలకాలను చొప్పించండి
• జాబితాలో ఎక్కడి నుండైనా మూలకాలను తీసివేయండి

మరిన్ని వివరాల కోసం, క్రింద చూడండి:

2. ఒక ArrayListవస్తువును సృష్టించడం

ఆబ్జెక్ట్‌ని సృష్టించడానికి ArrayList, మీరు ఇలా కోడ్ రాయాలి:

ArrayList<TypeParameter> name = new ArrayList<TypeParameter>();

ArrayListసేకరణ రకం/తరగతి ఎక్కడ ఉంది, TypeParameterఇది సేకరణలో నిల్వ చేయబడిన మూలకాల రకం ArrayListమరియు nameఇది వేరియబుల్ పేరు ArrayList<TypeParameter>.

వేరియబుల్ nameసాధారణ రకాన్ని కలిగి ఉంటుంది. ఇది రెండు రకాలను కలిగి ఉంటుంది: సేకరణ రకం మొదట సూచించబడుతుంది, ఆపై సేకరణలో నిల్వ చేయబడిన మూలకాల రకాన్ని సూచించడానికి కోణం బ్రాకెట్లు ఉపయోగించబడతాయి.

ఉదాహరణలు:

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

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

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

శ్రేణుల వలె కాకుండా, సేకరణలు ఆదిమ రకాలను నిల్వ చేయలేవు, కేవలం రిఫరెన్స్ రకాలు . కాబట్టి మీకు s సేకరణ అవసరమైతే int, Integerబదులుగా రేపర్ క్లాస్‌ని ఉపయోగించండి.

3. ఒక తో కార్యకలాపాలుArrayList

ప్రారంభంలో, కొత్తగా సృష్టించబడిన జాబితా యొక్క పొడవు సున్నా, ఎందుకంటే ఇది 0 మూలకాలను కలిగి ఉంటుంది. మీరు జాబితాకు ఒక మూలకాన్ని జోడిస్తే, దాని పొడవు 1 పెరుగుతుంది. మీరు జోడించిన మూలకాన్ని తీసివేస్తే, పొడవు తిరిగి సున్నాకి తగ్గుతుంది.

కింది పట్టిక తరగతి పద్ధతుల గురించి మీకు మరింత బోధిస్తుంది ArrayList:

void add(Type value)

void add(int index, Type value)

Type get(int index)

void set(int index, Type value)

Type remove(int index)

Type remove(Type value)

void clear()

boolean contains(Type value)

boolean isEmpty()

int size()

Type[] toArray(Type[] array)

ఈ పద్ధతులు మీరు జాబితాతో దాదాపు ఏదైనా చేయాలనుకుంటున్నారు: ఎలిమెంట్‌లను మార్చుకోండి, ఎలిమెంట్‌లను జోడించండి మరియు ఎలిమెంట్‌లను తీసివేయండి. మీరు ఒకే ఆదేశంతో జాబితాను క్లియర్ చేయవచ్చు లేదా జాబితాను శ్రేణికి మార్చవచ్చు.

4. పోలిక ArrayListమరియుArray

ArrayListపోల్చడం మరియు శ్రేణిని మనం నివారించగలమని నేను అనుకోను .

శ్రేణులతో మీరు చేయగలిగే 4 చర్యలు మాత్రమే ఉన్నాయి:

• శ్రేణిని సృష్టించండి
• ఇండెక్స్ ద్వారా మూలకాన్ని పొందండి
• ఇండెక్స్ ద్వారా మూలకాన్ని సెట్ చేయండి
• శ్రేణి పొడవును పొందండి

శ్రేణికిArrayList వర్తించే విధంగా ఈ కార్యకలాపాలు ఇక్కడ ఉన్నాయి :

String[] array = new String[10];

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

String s = array[0];

String s = list.get(0);

array[0] = "Bye";

list.set(0, "Bye");

int count = array.length;

int count = list.size();

ఒక శ్రేణి ఎలా పని చేస్తుందో మరియు ఒక శ్రేణి ఎలా పని చేస్తుందో పోల్చి చూద్దాం ArrayList. ఉదాహరణకు, ఈ పనిని అమలు చేద్దాం: "కీబోర్డ్ నుండి 10 స్ట్రింగ్‌లను చదవండి మరియు వాటిని రివర్స్ ఆర్డర్‌లో స్క్రీన్‌పై ప్రదర్శించండి"

Scanner console = new Scanner(System.in);

// Read strings from the keyboard
String[] list = new String[10];

for (int i = 0; i < list.length; i++)
{
    String s = console.nextLine();
    list[i] = s;
}

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

Scanner console = new Scanner(System.in);

// Read strings from the keyboard
ArrayList<String> list = new ArrayList<String>();

for (int i = 0; i < 10; i++)
{
    String s = console.nextLine();
    list.add(s);
}

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

సారూప్యత స్పష్టంగా ఉంది. శ్రేణుల కోసం ప్రతిదీ ఏదో ఒకవిధంగా తక్కువగా మరియు స్పష్టంగా ఉంటుంది. కానీ ArrayListకష్టం కూడా కాదు: ఒక మూలకాన్ని పొందడానికి, మేము get()పద్ధతిని ఉపయోగిస్తాము; ఒక మూలకాన్ని మార్చడానికి, set()పద్ధతి; జాబితా పొడవు, size()పద్ధతిని పొందడానికి.

కాబట్టి ప్రోగ్రామర్లు తరగతిని ఎందుకు ఉపయోగిస్తారు ArrayList?

మొత్తం పాయింట్, వాస్తవానికి, సాధారణ శ్రేణులు లేని అన్ని ఇతర పద్ధతులు:

• జాబితాకు ఒక మూలకాన్ని జోడించండి
• జాబితా మధ్యలో ఒక మూలకాన్ని జోడించండి
• జాబితాలో ఒక మూలకాన్ని కనుగొనండి
• జాబితా నుండి మూలకాన్ని తీసివేయడం