జావాలో కలెక్షన్స్ క్లాస్

హాయ్! గత కొన్ని పాఠాలలో, మేము మా పాండిత్యంలో గొప్ప పురోగతిని సాధించాము ArrayList. అయినప్పటికీ, ఇప్పటివరకు మేము సరళమైన కార్యకలాపాలను మాత్రమే చేసాము: తీసివేయండి, చొప్పించండి మరియు ప్రదర్శించండి. వాస్తవానికి, డెవలపర్లు పని చేస్తున్నప్పుడు తప్పనిసరిగా నిర్వహించాల్సిన పనుల పూర్తి జాబితాను ఇది కవర్ చేయదు ArrayList. శ్రేణులు మరియు తరగతి గురించి పాఠం గుర్తుందా Arrays? శ్రేణులతో పనిచేసేటప్పుడు ప్రోగ్రామర్లు ఎదుర్కొనే అత్యంత సాధారణ టాస్క్‌లను నిర్వహించడానికి జావా సృష్టికర్తలు ప్రత్యేకంగా ఈ తరగతిని రూపొందించారు. మరియు ఏమి గురించిArrayList? ఖచ్చితంగా, దానితో నిర్వహించాల్సిన సాధారణ పనుల జాబితా ఉంది. అవన్నీ నిర్దిష్ట తరగతిలో అమలు చేయబడాయా లేదా ప్రతిసారీ మన స్వంత అమలును వ్రాయాలా? వాస్తవానికి, మీరు ప్రతిదీ మీరే వ్రాయవలసిన అవసరం లేదు. ప్రత్యేక స్టాటిక్ క్లాస్‌లో సేకరణలతో కూడిన అత్యంత సాధారణ కార్యకలాపాలు ఇప్పటికే అమలు చేయబడ్డాయి Collections. జావాలో, డేటా నిర్మాణాల సమూహాన్ని సాధారణంగా సేకరణగా సూచిస్తారు . డేటాను అనేక రకాలుగా నిల్వ చేయవచ్చు. ఇప్పటివరకు, మేము తరగతిని మాత్రమే అధ్యయనం చేసాము, ఇక్కడ డేటా శ్రేణిలో నిల్వ చేయబడుతుంది. మేము ఇతర సేకరణలతో తరువాత పరిచయం చేస్తాము. ప్రస్తుతానికి, క్లాస్‌తో మాత్రమే కాకుండా పని చేసేలా రూపొందించబడిందని అర్థం చేసుకుంటే సరిపోతుందిArrayListCollectionsArrayList, కానీ ఇతర రకాల సేకరణలతో కూడా (అందుకే, దాని పేరు). కాబట్టి, Collectionsక్లాస్‌తో పనిచేసేటప్పుడు ఏ పనులకు సహాయం చేస్తుంది ArrayList? మొదటి మరియు అత్యంత స్పష్టమైనది క్రమబద్ధీకరణ. శ్రేణుల గురించి పాఠంలో, మేము సంఖ్యలతో ఉదాహరణగా పరిగణించాము. ఇప్పుడు మేము తీగలతో ఒక ఉదాహరణను పరిశీలిస్తాము. సేకరణల కంటెంట్‌లను క్రమబద్ధీకరించడానికి తరగతి పద్ధతిని అమలు Collectionsచేస్తుంది :sort()

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       System.out.println(solarSystem);

   }
}

అవుట్‌పుట్: [భూమి, బృహస్పతి, అంగారక గ్రహం, బుధుడు, నెప్ట్యూన్, శని, యురేనస్, శుక్రుడు] తీగలను అక్షర క్రమంలో క్రమబద్ధీకరించారు! అయితే అక్షర క్రమంలో ఎందుకు? క్లాస్ Stringవాస్తవానికి తీగలను ఎలా పోల్చాలో నియంత్రించే లాజిక్‌ను అమలు చేస్తుంది (ఇది అక్షర క్రమంలో జరుగుతుంది). మీరు మీరే సృష్టించుకునే తరగతుల కోసం, మీరు మీ స్వంత పోలిక తర్కాన్ని అమలు చేయవచ్చు, కానీ మేము దీని గురించి ఇతర పాఠాలలో మాట్లాడుతాము. Collectionsఒక లో కనిష్ట మరియు గరిష్ట మూలకాన్ని కనుగొనడంలో కూడా తరగతి మీకు సహాయపడుతుంది ArrayList. min()ఇది మరియు పద్ధతులను ఉపయోగించి చేయబడుతుంది max():

public static void main(java.lang.String[] args) {

   ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7));
   System.out.println(Collections.max(numbers));
   System.out.println(Collections.min(numbers));

}

అవుట్‌పుట్: 7 1 సహజంగానే, అన్ని మూలకాలపై మళ్ళించడానికి మరియు అతిపెద్ద/చిన్న మూలకాన్ని కనుగొనడానికి మాన్యువల్‌గా కోడ్‌ను వ్రాయడం కంటే ఇది చాలా సౌకర్యవంతంగా ఉంటుంది :) మరొక చాలా ఉపయోగకరమైన పద్ధతి reverse(). మేము జాబితాను "ఫ్లిప్" చేయవలసి వస్తే, మూలకాలు వ్యతిరేక క్రమంలో వెళ్ళినట్లయితే, మనం దానిని ఎలా చేస్తాము? అటువంటి అల్గోరిథం మీరే వ్రాయడం బహుశా అంత సులభం కాదు :) అదృష్టవశాత్తూ, పద్ధతి reverse()ఎలా ఉంటుందో ఇప్పటికే తెలుసు. ఈ పద్ధతి మన గ్రహాలను అక్షర క్రమంలో క్రమబద్ధీకరించడం మాకు ఇష్టం లేదని అనుకుందాం sort()మరియు మేము వాటి క్రమాన్ని మార్చాలనుకుంటున్నాము: Z నుండి A వరకు:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       Collections.reverse(solarSystem);
       System.out.println(solarSystem);

   }
}

అవుట్‌పుట్: [వీనస్, యురేనస్, సాటర్న్, నెప్ట్యూన్, మెర్క్యురీ, మార్స్, జూపిటర్, ఎర్త్] మేము క్రమబద్ధీకరణ, మూలకాల క్రమం మొదలైన వాటి గురించి చాలా మాట్లాడుతున్నాము. కానీ మనకు వ్యతిరేక లక్ష్యం ఉంటే? ఉదాహరణకు, మేము బింగో గేమ్‌ని అమలు చేయడానికి ప్రయత్నిస్తున్నామని అనుకుందాం. మేము డ్రమ్‌కు 100 సంఖ్యలను జోడిస్తాము. అవి ఒక్కొక్కటిగా తెరపై కనిపించాలి. మొదటి ఆటగాడు తన టిక్కెట్‌పై అన్ని సంఖ్యలను దాటేవాడు గెలుస్తాడు. ఈ పద్ధతిని ఉపయోగించి అమలు చేయడం సులభం shuffle():

public class Main {

   public static void main(java.lang.String[] args) {

       ArrayList<Integer> bingoDrum = new ArrayList<>(100);
       for (int i = 1; i <= 100; i++) {

           bingoDrum.add(i);// add the numbers 1 to 100 to the drum
       }

       Collections.shuffle(bingoDrum);// Mix it up
       System.out.println ("Your attention, please! Here are the first 10 numbers from the drum!");
       for (int i = 0; i < 10; i++) {

           System.out.println(bingoDrum.get(i));
       }

   }
}

అవుట్‌పుట్: మీ శ్రద్ధ, దయచేసి! డ్రమ్ నుండి మొదటి 10 సంఖ్యలు ఇక్కడ ఉన్నాయి! 32 61 4 81 25 8 66 35 42 71 ఇది చాలా సులభం! సమస్య పరిష్కరించబడింది, మరియు ఆట యొక్క మా భాగం వ్రాయబడింది :) ఇప్పుడు వేరే పరిస్థితిని ఊహించుకుందాం. మునుపు, మేము solarSystemగ్రహాలను కలిగి ఉన్న జాబితాను సృష్టించాము. మరియు ఇది మాకు అన్ని విధాలుగా సరిపోతుందని అనిపిస్తుంది, కానీ ఒకటి: మీరు దాని నుండి అంశాలను తొలగించవచ్చు మరియు కొత్త వాటిని జోడించవచ్చు ! ఇది స్పష్టంగా మనం ఆశించే ప్రవర్తన కాదు: మన కార్యక్రమంలో సౌర వ్యవస్థ మారకుండా ఉండాలి. తరగతి Collectionsచాలా ఆసక్తికరమైన పద్ధతిని కలిగి ఉంది: unmodifiableList(). ఇది ఆర్గ్యుమెంట్‌గా ఆమోదించబడిన జాబితా నుండి మార్పులేని జాబితాను సృష్టిస్తుంది. మీరు ఈ జాబితా నుండి అంశాలను జోడించలేరు లేదా తొలగించలేరు. సౌర వ్యవస్థలోని గ్రహాల జాబితాతో వ్యవహరించేటప్పుడు, మనకు కావలసినది ఇదే!

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       List<String> solarSystem = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune)));
       solarSystem.add("Pluto");// Try to add a new element
   }
}

అవుట్‌పుట్: థ్రెడ్ "మెయిన్" java.langలో మినహాయింపు ఏదైనా జోడించండి solarSystem! మీరు ఇక్కడ శ్రద్ధ వహించాల్సిన ఏకైక విషయం ఏమిటంటే, ఈ పద్ధతి తిరిగి వస్తుంది List<>(కాదు ArrayList<>), ఎందుకంటే ఈ రకం అన్ని రకాల జాబితాలకు సాధారణం. ప్రోగ్రామర్ తప్పు క్రమంలో మూలకాలను జోడించడం అనేది సులభంగా జరిగే మరొక సాధారణ పరిస్థితి. ఇది జరిగితే మరియు మెర్క్యురీ మరియు నెప్ట్యూన్ మిశ్రమంగా ఉన్నట్లు మేము కనుగొంటే, మేము ఈ swap()పద్ధతిని ఉపయోగించి ఈ తప్పును సరిదిద్దవచ్చు:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(neptune, venus, earth, mars
       , jupiter, saturn, uranus, mercury));// The planets are in the wrong order
       System.out.println(solarSystem);

       Collections.swap(solarSystem, solarSystem.indexOf(mercury), solarSystem.indexOf(neptune));
       System.out.println(solarSystem);

   }
}

swap()మేము మా జాబితా పద్ధతికి మరియు మార్పిడి చేయవలసిన రెండు మూలకాల సూచికలకు వెళతాము . పద్ధతి సూచనలతో కాకుండా సూచికలతో పనిచేస్తుందని గమనించండి. కాబట్టి, ఇక్కడ మేము పద్ధతిని ఉపయోగించాల్సి వచ్చింది ArrayList.indexOf(). అవుట్‌పుట్: [నెప్ట్యూన్, వీనస్, ఎర్త్, మార్స్, జూపిటర్, సాటర్న్, యురేనస్, మెర్క్యురీ] [మెర్క్యురీ, వీనస్, ఎర్త్, మార్స్, జూపిటర్, సాటర్న్, యురేనస్, నెప్ట్యూన్] చివరగా, మేము చాలా ఆసక్తికరమైన పద్ధతిని పరిచయం చేస్తాము : disjoint(). ఇది రెండు సేకరణలు కలుస్తాయో లేదో తనిఖీ చేస్తుంది, అనగా అవి కనీసం ఒకేలా ఉండే మూలకాన్ని కలిగి ఉన్నాయో లేదో . వారు చేయకపోతే, అది నిజమని తిరిగి వస్తుంది. వారు చేస్తారు, అది తప్పుగా తిరిగి వస్తుంది

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystemPart1 = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars));
       ArrayList<String> solarSystemPart2 = new ArrayList<>(Arrays.asList(jupiter, saturn, uranus, neptune));

       System.out.println(Collections.disjoint(solarSystemPart1, solarSystemPart2));

   }
}

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