జావాలో జాగ్డ్ శ్రేణులు

1. జాగ్డ్ శ్రేణులు

జావా ప్రోగ్రామర్‌గా మీరు ద్విమితీయ శ్రేణి యొక్క అడ్డు వరుసలను మార్చుకోవడమే కాకుండా, మీకు కావలసిన విధంగా శ్రేణిని కూడా నిర్మించవచ్చు.

మీరు ద్విమితీయ శ్రేణి యొక్క మొదటి అడ్డు వరుస పొడవును కలిగి ఉండాలని 10మరియు రెండవ అడ్డు వరుస యొక్క పొడవును కలిగి ఉండాలని మీరు కోరుకుంటున్నారని అనుకుందాం 50. మనం అలా చేయగలమా? అవును మనం చేయగలం.

ముందుగా, మనం 'కంటైనర్‌ల కంటైనర్‌'ని సృష్టించాలి - ఇది మొదటి శ్రేణి, ఇది వరుసల శ్రేణులకు సూచనలను నిల్వ చేస్తుంది. ఇది ఎలా జరుగుతుంది:

int[][] name = new int[height][];

మీరు రెండవ కోణాన్ని వదిలివేస్తారు మరియు జావా యంత్రం కంటైనర్ల కంటైనర్‌ను సృష్టిస్తుంది. ఈ కోడ్‌ని అమలు చేసిన తర్వాత ఇది మెమరీలో ఉంటుంది:

అలాగే, ఒక డైమెన్షనల్ శ్రేణులను ఎలా సృష్టించాలో మీకు ఇప్పటికే తెలుసు 🙂

ఫలితంగా కోడ్ ఇలా కనిపిస్తుంది:

// Matrix of important data
int[][] matrix = new int[2][];
matrix[0] = new int[10];
matrix[1] = new int[50]

మేము ఇప్పుడే " జాగ్డ్ అర్రే " అని పిలవబడేదాన్ని సృష్టించాము .

మరియు మనం ఇప్పుడు ఈ శ్రేణిలోని అన్ని అంశాలను స్క్రీన్‌పై ప్రదర్శించాలనుకుంటే, శ్రేణి యొక్క lengthఆస్తి ఉపయోగపడుతుంది: అన్నింటికంటే, శ్రేణి వరుసల పొడవు భిన్నంగా ఉంటాయి.

మార్గం ద్వారా, మీరు మా ఉదాహరణలో 'కంటైనర్‌ల కంటైనర్' పొడవును ఎలా కనుగొంటారు? ఇది కూడా ఒక శ్రేణి వస్తువు, అంటే ఇది పొడవును కలిగి ఉంటుంది. సరైన సమాధానం matrix.length.

మా అడ్డు వరుసలను కలిగి ఉన్న శ్రేణుల గురించి ఎలా?matrix[0].length

2. ద్విమితీయ శ్రేణితో పని చేయడం

మీరు ద్విమితీయ శ్రేణిని ప్రదర్శించాలనుకుంటున్నారని అనుకుందాం. మీరు అది ఎలా చేశారు?

మా కోడ్ ఇలా కనిపిస్తుంది:

int[][] matrix = new int[3][];
matrix[0] = new int[]{1, 2, 3, 4, 5, 6};
matrix[1] = new int[]{1, 2, 3};
matrix[2] = new int[]{1};
for (int i = 0; i < matrix.length; i++) {
   for (int j = 0; j < matrix[i].length; j++)
      System.out.print( matrix[i][j] + " " );
   System.out.println();
}

మీకు రెండు సమూహ లూప్‌లు అవసరం. మొదటిది మేము బయటి అని పిలుస్తాము మరియు రెండవది - లోపలి .

బాహ్య లూప్‌లో ( iవేరియబుల్), మన ద్విమితీయ శ్రేణిని రూపొందించే అన్ని అడ్డు వరుసల (శ్రేణులు) ద్వారా మేము వరుసగా వెళ్తాము. యొక్క ప్రతి విలువ iఆ సూచికతో వరుసకు అనుగుణంగా ఉంటుంది.

లోపలి లూప్‌లో ( jవేరియబుల్), మేము వరుసలలోని అన్ని కణాలపై మళ్ళిస్తాము. ఇన్నర్ లూప్‌కు ధన్యవాదాలు, ఒక డైమెన్షనల్ శ్రేణి యొక్క విలువలను కలిగి ఉన్న అడ్డు వరుస స్క్రీన్‌పై ప్రదర్శించబడుతుంది.

ఇది ప్రదర్శించబడుతుంది:

1 2 3 4 5 6

1 2 3 4 5 6
1 2 3

1 2 3 4 5 6
1 2 3
1

3. బహుమితీయ శ్రేణులు

శ్రేణుల గురించి మరొక ఆసక్తికరమైన విషయం, మీరు బహుశా ఇప్పటికే ఊహించినది. మీరు ద్విమితీయ శ్రేణిని తయారు చేయగలిగితే, మీరు త్రిమితీయ శ్రేణిని తయారు చేయగలరా?

అవును, మీరు ఏదైనా పరిమాణం యొక్క శ్రేణిని సృష్టించవచ్చు. ఇటువంటి శ్రేణులను 'మల్టీ డైమెన్షనల్' అంటారు.

కేవలం వినోదం కోసం, 4 కొలతలు కలిగిన బహుమితీయ శ్రేణిని సృష్టిద్దాం.

 int[][][][] matrix = new int[2][3][4][5];

ఈ కోడ్ చాలా సులభం, కాదా?

మీరు దీన్ని మాన్యువల్‌గా సృష్టిస్తే?

int[][][][] matrix;
matrix = new int[2][][][];                // Create a 2-element array of references to references to references
for (int i = 0; i < matrix.length; i++)
{
  matrix[i] = new int[3][][];                // Create a 3-element array of references to references
  for (j = 0; j < matrix[i].length; j++)
  {
    matrix[i][j] = new int[4][];             // Create a 4-element array of references
    for (k = 0; k < matrix[i][j].length; k++)
      matrix[i][j][k] = new int[5];          // Create 5-element arrays of integers
  }
}

మరియు అది శ్రేణిని సృష్టిస్తోంది! అప్పుడు మీరు కూడా ఏదో ఒకవిధంగా దానితో పని చేయాలి.

బోనస్ టాస్క్: త్రిమితీయ శ్రేణిలో అన్ని విలువలను ప్రదర్శించే కోడ్ వ్రాయండి.