శ్రేణుల గురించి కొంత

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

public class Main {

   public static void main(String[] args) {

       String [] birthdays = new String[10];
      
   }
}

ఇక్కడ మేము 10 మూలకాలను కలిగి ఉన్న శ్రేణిని సృష్టిస్తాము. మీరు శ్రేణి యొక్క కొన్ని లక్షణాలను వెంటనే గమనించవచ్చు:

1. ఇది బాగా నిర్వచించబడిన డేటా రకం మూలకాలను నిల్వ చేస్తుంది . మేము స్ట్రింగ్ శ్రేణిని సృష్టించినట్లయితే, మనం దానిలో మరేదైనా నిల్వ చేయలేము. శ్రేణి సృష్టించబడినప్పుడు డేటా రకం పేర్కొనబడుతుంది . ఇక్కడే ఇది సేఫ్టీ డిపాజిట్ బాక్స్‌కి భిన్నంగా ఉంటుంది (ఇందులో కస్టమర్ తనకు కావలసిన వాటిని నిల్వ చేసుకోవచ్చు).


2. శ్రేణిని సృష్టించినప్పుడు దాని పరిమాణం తప్పనిసరిగా పేర్కొనబడాలి . మీరు దానిని తర్వాత సూచించలేరు లేదా శ్రేణిని సృష్టించిన తర్వాత దాని పరిమాణాన్ని మార్చలేరు .

మేము శ్రేణిని సృష్టిస్తున్నామనే వాస్తవం వ్యక్తీకరణకు రెండు వైపులా ఉన్న స్క్వేర్ బ్రాకెట్‌ల ద్వారా సూచించబడుతుంది. వాటిని రిఫరెన్స్ వేరియబుల్ పేరుకు ముందు లేదా తర్వాత పేర్కొనవచ్చు. ఎలాగైనా పని చేస్తుంది:

String [] birthdays = new String[10];
String birthdays [] = new String[10];

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

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
   }
}

ఇప్పుడు జానా పుట్టినరోజు మా ఉద్యోగి పుట్టినరోజుల మొదటి సెల్‌లో నిల్వ చేయబడింది: మీరు ఇదే పద్ధతిలో ఇతర విలువలను జోడించవచ్చు:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";
   }
}

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

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";

       String rosieBirthday = birthdays[7];
       System.out.println(rosieBirthday);
   }
}

కన్సోల్ అవుట్‌పుట్: రోసీ మిల్స్, జనవరి 3 మేము ఒక Stringవేరియబుల్‌ని సృష్టించాము మరియు కంపైలర్‌కి ఇలా చెప్పాము: " పుట్టినరోజుల శ్రేణిలో ఇండెక్స్ 7 ఉన్న పెట్టెను కనుగొని, అక్కడ ఉన్న విలువను రోసీ బర్త్‌డేString వేరియబుల్‌కు కేటాయించండి ". మరియు అది సరిగ్గా అదే చేసింది. శ్రేణులతో పని చేస్తున్నప్పుడు, ప్రత్యేక ఆస్తిని ఉపయోగించి వాటి పొడవును సులభంగా కనుగొనవచ్చు: పొడవు .

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";

       int birthdaysLength = birthdays.length;
       System.out.println(birthdaysLength);
   }
}

కన్సోల్ అవుట్‌పుట్: 10 గమనిక: lengthప్రాపర్టీ శ్రేణి పరిమాణాన్ని నిల్వ చేస్తుంది, నిండిన పెట్టెల సంఖ్యను కాదు. మా శ్రేణి 3 విలువలను మాత్రమే నిల్వ చేస్తుంది, కానీ మేము దానిని సృష్టించినప్పుడు దాని పరిమాణాన్ని 10గా సూచించాము. మరియు ఇది ఖచ్చితంగా ఫీల్డ్ తిరిగి ఇచ్చే విలువ length. ఇది ఎందుకు ఉపయోగపడుతుంది? సరే, మీరు అన్ని పుట్టినరోజుల జాబితాను ప్రదర్శించాలనుకుంటున్నారని అనుకుందాం (ఎవరూ మరచిపోలేదని ధృవీకరించడానికి). మీరు దీన్ని ఒక సాధారణ లూప్‌లో చేయవచ్చు:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[2] = "Jeremiah Leonard, July 12";
       birthdays [3] = "Kenny Russo, September 7";
       birthdays[4] = "Tommie Barnes, November 9";
       birthdays [5] = "Roman Baranov, August 14";
       birthdays [6] = "Chanice Andersen, April 1";
       birthdays[7] = "Rosie Mills, January 3";
       birthdays [8] = "Keenan West, October 19";
       birthdays [9] = "Abraham McArthur, May 3";

       for (int i = 0; i < birthdays.length; i++) {
           System.out.println(birthdays[i]);
       }
   }
}

లూప్‌లో, మేము వేరియబుల్‌ను ప్రకటిస్తాము i, ఇది సున్నాకి ప్రారంభించబడింది. ప్రతి పాస్ వద్ద, మేము మా శ్రేణి నుండి ఇండెక్స్ iతో మూలకాన్ని పొందుతాము మరియు దాని విలువను ప్రదర్శిస్తాము. లూప్ 10 పునరావృత్తులు చేస్తుంది మరియు నేను 0 నుండి 9కి పెంచుతాను-మరియు సంఖ్యలు మా శ్రేణి యొక్క మూలకాల సూచికలుగా ఉంటాయి! ఫలితంగా, మేము పుట్టినరోజు[0] నుండి పుట్టినరోజు[9] వరకు అన్ని విలువలను ప్రదర్శిస్తాము , వాస్తవానికి, మీరు శ్రేణిని సృష్టించడానికి మరొక మార్గం ఉంది. intఉదాహరణకు, మీరు ఇలా s యొక్క శ్రేణిని సృష్టించవచ్చు :

public class Main {

   public static void main(String[] args) {
       int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
   }
}

ఈ పద్ధతిని "షార్ట్‌కట్ ఇనిషియలైజేషన్" అంటారు. ఇది చాలా సౌకర్యవంతంగా ఉంటుంది, ఎందుకంటే మేము ఏకకాలంలో శ్రేణిని సృష్టించి, దానిని విలువలతో నింపుతాము. మేము శ్రేణి పరిమాణాన్ని స్పష్టంగా పేర్కొనవలసిన అవసరం లేదు: సత్వరమార్గం ప్రారంభించడంతో, lengthఫీల్డ్ స్వయంచాలకంగా సెట్ చేయబడుతుంది.

public class Main {

   public static void main(String[] args) {
       int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
       System.out.println(numbers.length);
   }
}

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

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");
   }
}

మీరు ఇక్కడ కొన్ని విషయాలను అర్థం చేసుకోవాలి:

1. ఆదిమాంశాల విషయంలో, ఒక శ్రేణి నిర్దిష్ట విలువల సమితిని నిల్వ చేస్తుంది (ఉదా. ints). వస్తువుల విషయంలో, శ్రేణి సూచనల సమితిని నిల్వ చేస్తుంది .
   శ్రేణి catsమూడు మూలకాలను కలిగి ఉంటుంది, వీటిలో ప్రతి ఒక్కటి వస్తువుకు సూచనCat . ప్రతి సూచనలు సంబంధిత వస్తువు నిల్వ చేయబడిన మెమరీ చిరునామాను సూచిస్తాయి.

2. శ్రేణి మూలకాలు మెమరీలో ఒకే బ్లాక్‌లో అమర్చబడి ఉంటాయి. వాటిని త్వరగా మరియు సమర్ధవంతంగా యాక్సెస్ చేయడానికి ఇది జరుగుతుంది.

అందువలన, catsఅన్ని వస్తువులు (శ్రేణి మూలకాలు) నిల్వ చేయబడిన మెమరీ బ్లాక్‌ను సూచిస్తుంది. Cats[0]ఈ బ్లాక్‌లోని నిర్దిష్ట చిరునామాను సూచిస్తుంది. శ్రేణి కేవలం వస్తువులను మాత్రమే నిల్వ చేయదని అర్థం చేసుకోవడం ముఖ్యం: ఇది ఒక వస్తువు. ఇది తీగలు లేదా సంఖ్యల శ్రేణిని మాత్రమే కాకుండా, శ్రేణుల శ్రేణులను కూడా సృష్టించగలమా అనే ప్రశ్నకు దారి తీస్తుంది . మరియు సమాధానం అవును, మనం చేయగలం! ఒక శ్రేణి ఇతర శ్రేణులతో సహా ఏదైనా వస్తువులను నిల్వ చేయగలదు. అటువంటి శ్రేణిని రెండు డైమెన్షనల్ అంటారు . మేము దానిని దృశ్యమానంగా సూచించినట్లయితే, అది సాధారణ పట్టిక వలె ఉంటుంది. ప్రతి ఒక్కటి 10 సె నిల్వ చేయగల 3 శ్రేణుల శ్రేణిని సృష్టించాలని అనుకుందాం int. ఇది ఇలా కనిపిస్తుంది: ప్రతి పంక్తి ఒక శ్రేణిని సూచిస్తుంది int. మొదటి శ్రేణి 1 నుండి 10 వరకు సంఖ్యలను కలిగి ఉంటుంది, రెండవ శ్రేణి - -1 నుండి -10 వరకు మరియు మూడవది - యాదృచ్ఛిక సంఖ్యల సమితి. ఈ శ్రేణులలో ప్రతి ఒక్కటి మా ద్విమితీయ శ్రేణి యొక్క పెట్టెల్లో నిల్వ చేయబడుతుంది. కోడ్‌లో, ద్విమితీయ శ్రేణిని ప్రారంభించడం ఇలా కనిపిస్తుంది:

public static void main(String[] args) {
   Cat[][] cats = new Cat[3][5];
}

మా ద్విమితీయ శ్రేణి పిల్లులు ప్రతి శ్రేణిలో 5 పెట్టెలతో 3 శ్రేణులను నిల్వ చేస్తాయి . మేము రెండవ శ్రేణి యొక్క మూడవ పెట్టెలో ఒక వస్తువును ఉంచాలనుకుంటే , మేము ఇలా చేస్తాము:

public static void main(String[] args) {
   Cat[][] cats = new Cat[3][5];
   cats[1][2] = new Cat("Fluffy");
}

[1]రెండవ శ్రేణిని సూచిస్తుంది మరియు [2]ఆ శ్రేణి యొక్క మూడవ పెట్టెను సూచిస్తుంది. ద్విమితీయ శ్రేణి అనేక శ్రేణులను కలిగి ఉన్నందున, దాని ద్వారా పునరావృతం చేయడానికి మరియు దాని అన్ని విలువలను ప్రదర్శించడానికి (లేదా దాని అన్ని మూలకాలను నింపడానికి), మనకు సమూహ లూప్ అవసరం:

for (int i = 0; i < cats.length; i++) {
   for (int j = 0; j < cats[i].length; j++) {
       System.out.println(cats[i][j]);
   }
}

బయటి లూప్‌లో (వేరియబుల్ i), మేము మా ద్విమితీయ శ్రేణిలోని అన్ని శ్రేణులపై పునరావృతం చేస్తాము. లోపలి లూప్‌లో (వేరియబుల్ j), మేము ప్రతి శ్రేణిలోని అన్ని మూలకాల గుండా వెళతాము. ఫలితంగా, పిల్లులు[0][0] (మొదటి శ్రేణి, మొదటి మూలకం) ముందుగా ప్రదర్శించబడతాయి, తర్వాత పిల్లులు[0][1] (మొదటి శ్రేణి, రెండవ మూలకం) ప్రదర్శించబడతాయి. మేము మొదటి శ్రేణిని దాటిన తర్వాత, మేము పిల్లులు[1][0] , పిల్లులు[1][1] , పిల్లులు[1][2] మొదలైన వాటిని ప్రదర్శిస్తాము . అలాగే, రెండు డైమెన్షనల్ శ్రేణులు కూడా మద్దతు ఇస్తాయి సంక్షిప్తలిపి ప్రారంభించడం:

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

సాధారణంగా, మేము రెండు డైమెన్షనల్ శ్రేణిని numbersఒక గా ప్రకటిస్తాము int[3][3], కానీ ఈ సంక్షిప్తలిపి విలువలను వెంటనే పేర్కొనడానికి అనుమతిస్తుంది. మీకు రెండు డైమెన్షనల్ అర్రే ఎందుకు అవసరం? బాగా, ప్రసిద్ధ "యుద్ధనౌక" గేమ్‌ను సులభంగా పునఃసృష్టి చేయడానికి మీరు ఒకదాన్ని ఉపయోగించవచ్చు: "యుద్ధనౌక"లో, మైదానం యొక్క నిర్మాణాన్ని సులభంగా వివరించవచ్చు: ఒక్కొక్కటి 10 మూలకాలతో 10 శ్రేణుల ద్విమితీయ శ్రేణి. మీరు ఈ రెండు శ్రేణులను (ఒకటి మీ కోసం మరియు మీ ప్రత్యర్థికి ఒకటి) సృష్టించారు

int[][] battleshipBoard1 = new int[10][10];
int[][] battleshipBoard2 = new int[10][10];

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

• యుద్ధనౌక బోర్డ్1[0][2]!
• మిస్! యుద్ధనౌక బోర్డ్2[2][4]!
• కొట్టుట!
• యుద్ధనౌక బోర్డ్2[2][5]!
• కొట్టుట!
• యుద్ధనౌక బోర్డ్2[2][6]!,
• మునిగిపోయింది!

ఇది శ్రేణుల యొక్క మా మొదటి పరిచయాన్ని ముగించింది, అయితే ఇది వాటితో మా పరస్పర చర్య యొక్క ప్రారంభం మాత్రమే. కింది పాఠాలలో, మేము వాటిని ఉపయోగించగల ఆసక్తికరమైన మార్గాలను చూస్తాము మరియు ఈ డేటా నిర్మాణంతో మరింత సౌకర్యవంతంగా పని చేయడానికి జావాలో అంతర్నిర్మిత విధులు ఏమిటో కూడా తెలుసుకుందాం :)