జావా అర్రేలిస్ట్

హాయ్! మునుపటి పాఠాలలో, మేము శ్రేణులలోకి లోతుగా డైవ్ చేసాము మరియు శ్రేణులతో పని చేసే సాధారణ ఉదాహరణలను సమీక్షించాము. ఈ పాఠంలో, మేము జావా అర్రేలిస్ట్‌లో దగ్గరి సమీక్షను తీసుకుంటాము. సాధారణంగా, శ్రేణులు చాలా ఉపయోగకరంగా ఉంటాయి. మరియు, మీరు ఇప్పటికే గమనించినట్లుగా, మీరు వారితో చాలా చేయవచ్చు :) కానీ శ్రేణులు అనేక లోపాలను కలిగి ఉంటాయి.

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


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


• ఒక అంశాన్ని తొలగించడానికి పద్ధతులు లేవు. విలువను "సున్నా" మాత్రమే చేయవచ్చు.

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Behemoth");
       cats[2] = new Cat("Lionel Messi");

       cats[1] = null;

      
      
       System.out.println(Arrays.toString(cats));
   }

   @Override
   public String toString() {
       return "Cat{" +
               "name='" + name + '\'' +
               '}';
   }
}

అవుట్‌పుట్: [Cat{name='Thomas'}, null, Cat{name='Lionel Messi'}] అదృష్టవశాత్తూ, జావా సృష్టికర్తలకు శ్రేణుల ప్రయోజనాలు మరియు అప్రయోజనాలు గురించి బాగా తెలుసు, అందుచేత Java ArrayList అనే ఆసక్తికరమైన డేటా నిర్మాణాన్ని రూపొందించారు . వీలైనంత సరళంగా మాట్లాడుతూ, జావా అర్రేలిస్ట్ అనేది చాలా కొత్త ఫీచర్లతో కూడిన "సూప్డ్ అప్" శ్రేణి.

అర్రేలిస్ట్‌ను ఎలా సృష్టించాలి

దీన్ని సృష్టించడం చాలా సులభం:

ArrayList<Cat> cats = new ArrayList<Cat>();

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

• అంతర్గత శ్రేణి నిండినప్పుడు, అర్రేలిస్ట్ అంతర్గతంగా కొత్త శ్రేణిని సృష్టిస్తుంది. కొత్త శ్రేణి పరిమాణం పాత శ్రేణి యొక్క పరిమాణం 1.5 ప్లస్ 1.


• మొత్తం డేటా పాత శ్రేణి నుండి కొత్తదానికి కాపీ చేయబడింది


• పాత శ్రేణిని చెత్త కలెక్టర్ ద్వారా శుభ్రం చేస్తారు.

ఈ మెకానిజం Java ArrayList (సాధారణ శ్రేణి వలె కాకుండా) కొత్త మూలకాలను జోడించడానికి ఒక పద్ధతిని అమలు చేయడానికి అనుమతిస్తుంది. అది add()పద్ధతి

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<Cat>();
   cats.add(new Cat("Behemoth"));
}

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

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   int thomasIndex = cats.indexOf(thomas);
   System.out.println(thomasIndex);
}

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

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   Cat secondCat = cats.get(1);

   System.out.println(secondCat);
}

అవుట్‌పుట్: క్యాట్{పేరు='బెహెమోత్'} అదనంగా, అర్రేలిస్ట్ నిర్దిష్ట వస్తువును కలిగి ఉందో లేదో మీరు సులభంగా కనుగొనవచ్చు. ఇది అర్రేలిస్ట్ కలిగి() పద్ధతిని ఉపయోగించి చేయబడుతుంది:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   cats.remove(fluffy);
   System.out.println(cats.contains(fluffy));
}

ArrayList యొక్క అంతర్గత శ్రేణి మూలకాన్ని కలిగి ఉందో లేదో ఈ పద్ధతి తనిఖీ చేస్తుంది మరియు బూలియన్ (నిజం లేదా తప్పు)ని అందిస్తుంది. అవుట్‌పుట్: తప్పు మరియు చొప్పించడం గురించి మరొక ముఖ్యమైన విషయం. శ్రేణి చివరిలో మాత్రమే కాకుండా ఎక్కడైనా మూలకాలను చొప్పించడానికి సూచికను ఉపయోగించడానికి అర్రేలిస్ట్ మిమ్మల్ని అనుమతిస్తుంది. దీనికి రెండు పద్ధతులు ఉన్నాయి:

• అర్రేలిస్ట్ యాడ్ (ఇంట్ ఇండెక్స్, క్యాట్ ఎలిమెంట్)
• అర్రేలిస్ట్ సెట్ (పూర్ణాంక సూచిక, పిల్లి మూలకం)

వాదనల వలె, ఈ రెండు పద్ధతులు మీరు చొప్పించాలనుకుంటున్న స్థానం యొక్క సూచికను మరియు ఆబ్జెక్ట్‌కు సూచనను తీసుకుంటాయి. తేడా ఏమిటంటే set()ని ఉపయోగించి చొప్పించడం పాత విలువను ఓవర్‌రైట్ చేస్తుంది. add() ని ఉపయోగించి చొప్పించడం మొదట అన్ని మూలకాలను [ఇండెక్స్] నుండి శ్రేణి చివరకి మారుస్తుంది, ఆపై పేర్కొన్న ఆబ్జెక్ట్‌ను ఫలితంగా ఖాళీ స్థానంలో జోడిస్తుంది.

ఇక్కడ ఒక ఉదాహరణ:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.set(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using set

   System.out.println(cats.toString());
}

అవుట్‌పుట్: [[Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Behemoth'}] మా వద్ద 2 పిల్లుల జాబితా ఉంది . అప్పుడు మేము సెట్() పద్ధతిని ఉపయోగించి మూలకం 0గా మరొకదాన్ని చొప్పించాము . ఫలితంగా, పాత మూలకం కొత్తది ద్వారా భర్తీ చేయబడింది.

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.add(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using add

   System.out.println(cats.toString());
}

మరియు ఇక్కడ మనం add() భిన్నంగా పనిచేస్తుందని చూస్తాము . ఇది అన్ని మూలకాలను కుడివైపుకి తరలించి, ఆపై కొత్త విలువను మూలకం 0గా వ్రాస్తుంది. అవుట్‌పుట్: [Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Thomas'}, Cat{name='Behemoth'}] జాబితాను పూర్తిగా క్లియర్ చేయడానికి, మేము clear() పద్ధతిని ఉపయోగిస్తాము:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   cats.clear();

   System.out.println(cats.toString());
}

అవుట్‌పుట్: [] జాబితా నుండి ప్రతిదీ తీసివేయబడింది. మార్గం ద్వారా, దయచేసి గమనించండి: శ్రేణుల వలె కాకుండా, ArrayList toString() పద్ధతిని భర్తీ చేస్తుంది మరియు ఇప్పటికే జాబితాను తగిన విధంగా స్ట్రింగ్‌లుగా ప్రదర్శిస్తుంది. సాధారణ శ్రేణులతో, మేము దీని కోసం శ్రేణుల తరగతిని ఉపయోగించాల్సి వచ్చింది. మరియు నేను శ్రేణులను పేర్కొన్నందున : జావా మిమ్మల్ని శ్రేణి మరియు అర్రేలిస్ట్ మధ్య సులభంగా "మారడానికి" అనుమతిస్తుంది , అనగా ఒకదానికొకటి మార్చండి. అర్రేస్ క్లాస్ దీని కోసం Arrays.asList() పద్ధతిని కలిగి ఉంది . మేము కంటెంట్‌లను శ్రేణిగా పొందడానికి మరియు వాటిని మా అర్రేలిస్ట్ కన్‌స్ట్రక్టర్‌కు పంపడానికి దీన్ని ఉపయోగిస్తాము:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   Cat[] catsArray = {thomas, behemoth, lionel, fluffy};

   ArrayList<Cat> catsList = new ArrayList<>(Arrays.asList(catsArray));
   System.out.println(catsList);
}

అవుట్‌పుట్: [పిల్లి{పేరు='థామస్'}, పిల్లి{పేరు='బెహెమోత్'}, పిల్లి{పేరు='లియోనెల్ మెస్సీ'}, పిల్లి{పేరు='మెత్తటి'}] మీరు వ్యతిరేక దిశలో కూడా వెళ్లవచ్చు: పొందండి అర్రేలిస్ట్ ఆబ్జెక్ట్ నుండి ఒక శ్రేణి . మేము దీన్ని toArray() పద్ధతిని ఉపయోగించి చేస్తాము:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();

   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   Cat[] catsArray = cats.toArray(new Cat[0]);

   System.out.println(Arrays.toString(catsArray));
}

గమనిక: మేము toArray() పద్ధతికి ఖాళీ శ్రేణిని పంపాము . ఇది లోపం కాదు. ArrayList తరగతి లోపల , ఈ పద్ధతి ఒక ఖాళీ శ్రేణిని పాస్ చేయడం దాని పనితీరును పెంచే విధంగా అమలు చేయబడుతుంది. భవిష్యత్తు కోసం దీన్ని గుర్తుంచుకోండి (వాస్తవానికి, మీరు నిర్దిష్ట పరిమాణంలోని శ్రేణిని పాస్ చేయవచ్చు; అది కూడా పని చేస్తుంది). ఓహ్, పరిమాణం గురించి. జాబితా యొక్క ప్రస్తుత పరిమాణాన్ని పరిమాణం() పద్ధతిని ఉపయోగించి కనుగొనవచ్చు :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   System.out.println(cats.size());
}

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

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>(2);// create an ArrayList with an initial capacity of 2


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   System.out.println(cats.size());
}

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