శ్రేణుల తరగతి

మళ్ళీ హలో! :) నేటి పాఠంలో, మేము జావాలో అర్రేస్ క్లాస్ గురించి మాట్లాడుతాము. చివరి పాఠంలో, శ్రేణి అని పిలువబడే అటువంటి డేటా నిర్మాణాన్ని మనం తెలుసుకున్నాము. మేము వాటిని ఎలా సృష్టించాలో మరియు వాటిని డేటాతో ఎలా నింపాలో నేర్చుకున్నాము. మరియు అవి మెమరీలో ఎలా నిల్వ చేయబడతాయో మేము చూశాము. ఈ రోజు మనం కొన్ని పనులు మరియు నిజమైన పనిలో మీరు తరచుగా చూసే శ్రేణులతో పని చేసే ఉదాహరణలను పరిశీలిస్తాము. ఉదాహరణకు, ఈ పరిస్థితిని ఊహించండి: మనకు 10 యాదృచ్ఛిక సంఖ్యల శ్రేణి ఉంది.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

మా పని ఈ శ్రేణిని ఆరోహణ క్రమంలో క్రమబద్ధీకరించడం: చిన్నది నుండి గొప్ప వరకు. చివరికి, ఇది ఇలా ఉండాలి: [-234, -2, 16, 26, 35, 43, 92, 99, 167] మనం దీన్ని ఎలా చేయాలి? ఈ పని సామాన్యమైనది కాదు. మేము ఇంతకు ముందెన్నడూ ఇలా చేయలేదు :/ ఏదైనా ఆలోచనలు ఉన్నాయా? ఊహించడానికి ప్రయత్నించండి. ఇక్కడ ఒక పరిష్కారం ఉంది:

• శ్రేణిలోని అన్ని అంశాల ద్వారా వెళ్ళండి. ప్రతి మూలకాన్ని తదుపరి దానితో పోల్చండి ([0] తో [1], [1] తో [2], [2] తో [3], మొదలైనవి). ప్రస్తుత మూలకం తదుపరి దాని కంటే ఎక్కువగా ఉంటే, మేము వాటిని మార్పిడి చేసి, ఆపై తదుపరి మూలకానికి వెళ్తాము. కాకపోతే, వాటిని అలాగే వదిలేసి, ముందుకు సాగండి
• అందువల్ల, మూలకాల ద్వారా మొదటి పాస్ తర్వాత, అతిపెద్ద విలువ (167) చివరి సెల్‌లో ఉంటుందని హామీ ఇవ్వబడుతుంది.
• ఇప్పుడు మేము మళ్లీ అన్ని మూలకాల ద్వారా వెళ్తాము, కానీ ఈసారి మేము ఇండెక్స్ [0]తో చివరి మూలకం (అతిపెద్ద సంఖ్య ఇప్పటికే దాని స్థానంలో ఉంది) మరియు అదే పోలికలు మరియు మార్పిడులను చేస్తాము. ఈ పాస్ తర్వాత, చివరి సెల్‌లో, మనకు రెండవ అతిపెద్ద విలువ (99) ఉంటుంది.
• మనకు శ్రేణి మూలకాలు ఉన్నన్ని సార్లు ఈ విధానాన్ని పునరావృతం చేయండి.

మాకు ఆలోచన వచ్చింది. ఇప్పుడు మనం కోడ్ మాత్రమే వ్రాయాలి. ఇది ఇలా కనిపిస్తుంది:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       for (int i = numbers.length - 1; i > 0; i--) {
           for (int j = 0; j < i; j++) {
           /* Compare the elements in pairs.
             If they are not in the right order,
             then swap them */
               if (numbers[j] > numbers[j + 1]) {
                   int tmp = numbers[j];
                   numbers[j] = numbers[j + 1];
                   numbers[j + 1] = tmp;
               }
           }
       }

   }
}

ఉహ్ ... ఇది కొంచెం క్లిష్టంగా కనిపిస్తోంది -_- సాధారణ సూత్రం అర్థమయ్యేలా ఉన్నప్పటికీ, అటువంటి సాధారణ పనిని పరిష్కరించడానికి మనం ఇంకా చాలా కోడ్‌లను వ్రాయవలసి ఉంటుంది. సరే, బహుశా మనల్ని మనం ఎక్కువగా అంచనా వేసుకున్నామా? మేము పరిష్కరించిన పని బహుశా ఇప్పటికీ మాకు చాలా క్లిష్టంగా ఉంటుంది. సరళమైనదాన్ని ప్రయత్నిద్దాం. ఉదాహరణకు, అదే సంఖ్యల శ్రేణిని తీసుకోండి.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

దాని కంటెంట్‌లను మరొక శ్రేణికి కాపీ చేయడం మా పని.

int [] numbersCopy = new int[10];

శ్రేణుల గురించి మీకు ఇప్పటికే తెలిసిన వాటిని ఉపయోగించి మీరు దీన్ని ఎలా చేస్తారో ఆలోచించండి? ఉదాహరణకు, మీరు లూప్‌లోని సంఖ్యల శ్రేణి ద్వారా వెళ్లి దాని మూలకాలను సంఖ్యల కాపీలో వరుసగా వ్రాయవచ్చు :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = new int[10];

       for (int i = 0; i < numbers.length; i++) {

           numbersCopy[i] = numbers[i];
       }

   }
}

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

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       Arrays.sort(numbers);

       System.out.println(Arrays.toString(numbers));

   }
}

Arrays.sort () పద్ధతి శ్రేణిని క్రమబద్ధీకరిస్తుంది. మరియు దాని అల్గోరిథం మేము వ్రాసిన కోడ్ కంటే చాలా సమర్థవంతమైనది. కన్సోల్ అవుట్‌పుట్: [-234, -2, 16, 26, 35, 43, 80, 92, 99, 167] గమనిక: శ్రేణిని స్ట్రింగ్‌గా మార్చడానికి, మేము శ్రేణుల తరగతికి చెందిన మరొక పద్ధతిని ఉపయోగించాము: Arrays.toString() . జావాలోని శ్రేణులు వాటి స్వంతంగా toString() పద్ధతిని భర్తీ చేయవు . కాబట్టి, మీరు కేవలం వ్రాస్తే

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

ఆబ్జెక్ట్ క్లాస్ యొక్క toString() అంటారు. శ్రేణి కోసం, అవుట్‌పుట్ ఇలా ఉంటుంది: [I@4554617c సరిగ్గా ఇది ఎందుకు అవుట్‌పుట్ అనే దాని గురించి మేము ఇప్పుడు వివరంగా చెప్పము. ప్రధాన విషయం ఏమిటంటే ఇది మనకు అవసరమైనది కాదు. కానీ Arrays.toString() ఖచ్చితంగా మనకు కావలసినది చేస్తుంది. మార్గం ద్వారా, శ్రేణుల తరగతితో కాపీ చేయడం కూడా సులభంగా సాధించబడుతుంది:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

మేము మా అసలు శ్రేణి (దీని నుండి మేము విలువలను కాపీ చేయాలనుకుంటున్నాము) మరియు మేము డేటాను కాపీ చేస్తున్న కొత్త శ్రేణి యొక్క పొడవును Arrays.copyOf() పద్ధతికి పంపుతాము . ఈ సందర్భంలో, మేము numbers.lengthని పొడవుగా సూచించాము, ఎందుకంటే మొత్తం శ్రేణిని కాపీ చేయాలనుకుంటున్నాము. మేము మొదటి కొన్ని మూలకాలను మాత్రమే కాపీ చేయాలనుకుంటే, మేము కొత్త చిన్న శ్రేణి యొక్క పొడవును పేర్కొనవచ్చు:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, 4);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

ఇక్కడ మేము కొత్త శ్రేణి యొక్క పొడవుగా 4ని పేర్కొన్నాము. దీని ప్రకారం, సంఖ్యల యొక్క మొదటి 4 మూలకాలు మాత్రమే కొత్త శ్రేణికి కాపీ చేయబడతాయి. కన్సోల్ అవుట్‌పుట్: [167, -2, 16, 99] మార్గం ద్వారా, శ్రేణి ప్రారంభంలో కాకుండా మధ్య నుండి శ్రేణిలో కొంత భాగాన్ని కాపీ చేయడానికి అర్రేలు మిమ్మల్ని అనుమతిస్తుంది:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

అవుట్‌పుట్: [16, 99, 26, 92] సంఖ్యలు కొత్త శ్రేణికి రెండవ శ్రేణి నుండి రెండవ (కలిసి) నుండి ఆరవ (కలిసి కాదు) మూలకం వరకు కాపీ చేయబడ్డాయి. మనం రెండు శ్రేణులను కూడా సరిపోల్చాల్సి రావచ్చు. toString() పద్ధతి వలె , శ్రేణులు ఈక్వల్స్() పద్ధతిని భర్తీ చేయవు. కాబట్టి మనం వాటిని ఇలా పోల్చడానికి ప్రయత్నిస్తే

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(numbers.equals(numbers2));
   }
}

అప్పుడు మనకు అబద్ధం వస్తుంది. ఎందుకంటే , సూచనలను సరిపోల్చే Object.equals() అని పిలుస్తారు. మరియు, స్పష్టంగా, అవి భిన్నంగా ఉంటాయి! కానీ మనకు కావలసింది అర్రే కంటెంట్‌లను పోల్చడం, సూచనలు కాదు. శ్రేణుల తరగతి మనకు కావలసిన దాన్ని సరిగ్గా చేయడానికి సమాన () పద్ధతిని భర్తీ చేస్తుంది :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(Arrays.equals(numbers, numbers2));
   }
}

అవుట్‌పుట్: నిజమే , శ్రేణుల తరగతి సాధారణ శ్రేణులతో మాత్రమే కాకుండా రెండు డైమెన్షనల్ వాటితో కూడా పనిచేస్తుంది:

public class Main {

   public static void main(String[] args) {

       int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

       int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);

       System.out.println("Are these two-dimensional arrays equal?");
       System.out.println(Arrays.deepEquals(numbers, numbersCopy));

       System.out.println(Arrays.deepToString(numbersCopy));
   }
}

అవుట్‌పుట్: ఈ రెండు డైమెన్షనల్ శ్రేణులు సమానంగా ఉన్నాయా? true [[1, 2, 3], [4, 5, 6], [7, 8, 9]] మీరు చూడగలిగినట్లుగా, Arrays.copyOf() పద్ధతి ద్విమితీయ శ్రేణిని కాపీ చేయగలదు. మరియు తరగతి రెండు డైమెన్షనల్ శ్రేణులను పోల్చడానికి మరియు ప్రదర్శించడానికి ప్రత్యేక పద్ధతులను కలిగి ఉంది: deepEquals మరియు deepToString() . భవిష్యత్తులో, జావా సృష్టికర్తలు ప్రోగ్రామర్లు తరచుగా ఎదుర్కొనే అనేక పరిస్థితులను ఊహించి, భాషలో వారి కోసం రెడీమేడ్ పరిష్కారాలను అమలు చేశారని మీరు పదే పదే చూస్తారు (వాస్తవానికి సంతోషిస్తారు). ఈ పరిష్కారాలను ఉపయోగించడం చక్రాన్ని తిరిగి ఆవిష్కరించడం కంటే చాలా సులభం మరియు మరింత సౌకర్యవంతంగా ఉంటుంది, సరియైనదా? :) Oracle వెబ్‌సైట్‌లో శ్రేణుల తరగతికి సంబంధించిన డాక్యుమెంటేషన్‌ను తప్పకుండా చదవండి . మీ చదువులో అదృష్టం!