ஜாவாவில் துண்டிக்கப்பட்ட வரிசைகள்

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
  }
}

அது வரிசையை உருவாக்குகிறது! பின்னர் நீங்களும் எப்படியாவது அதனுடன் வேலை செய்ய வேண்டும்.

போனஸ் பணி: முப்பரிமாண வரிசையில் அனைத்து மதிப்புகளையும் காண்பிக்கும் குறியீட்டை எழுதவும்.