ಜಾವಾದಲ್ಲಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೇಗೆ ಪ್ರಾರಂಭಿಸುವುದು



ಅರೇ ಜಾವಾ

ಜಾವಾದಲ್ಲಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೇಗೆ ಪ್ರಾರಂಭಿಸುವುದು

ಜಾವಾದಲ್ಲಿನ ಅರೇಗಳು ಹೆಚ್ಚು ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುವ ದತ್ತಾಂಶ ರಚನೆಯಾಗಿದ್ದು, ಒಂದೇ ಡೇಟಾ ಪ್ರಕಾರದ ಅನೇಕ ಮೌಲ್ಯಗಳನ್ನು ಅನುಕ್ರಮ ಕ್ರಮದಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ರಚನೆಯು ಸ್ಥಿರ ಉದ್ದವನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಸೂಚ್ಯಂಕವು 0 ರಿಂದ n-1 ವರೆಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ಅಲ್ಲಿ n ಎಂಬುದು ಒಂದು ರಚನೆಯ ಉದ್ದವಾಗಿದೆ. ಸ್ಟ್ರಿಂಗ್, ಪೂರ್ಣಾಂಕ, ಅಕ್ಷರ, ಬೈಟ್ ಮತ್ತು ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿತ ವಸ್ತುಗಳಂತಹ ಯಾವುದೇ ರೀತಿಯ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಲು ನಾವು ಜಾವಾದಲ್ಲಿ ಅರೇ ವರ್ಗವನ್ನು ಬಳಸಬಹುದು. ಜಾವಾದಲ್ಲಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೇಗೆ ಪ್ರಾರಂಭಿಸುವುದು ಎಂದು ನಾವು ಕಲಿಯುತ್ತೇವೆ?

11 ಅಂಶಗಳನ್ನು ಹೊಂದಿರುವ ಪೂರ್ಣಾಂಕಗಳ ಏಕ-ಆಯಾಮದ ರಚನೆಯ ರೇಖಾಚಿತ್ರದ ನಿರೂಪಣೆಯನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ.

ಜಾವಾದಲ್ಲಿ ಅರೇಗಳು

ಪರಿವಿಡಿ

ಜಾವಾ ಅರೇಸ್ ವೈಶಿಷ್ಟ್ಯಗಳು

  • ರಚನೆಯು ಸ್ಥಿರ ಗಾತ್ರವನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಅದನ್ನು ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ
  • ರಚನೆಯು ಸೂಚ್ಯಂಕ ಆಧಾರಿತವಾದ್ದರಿಂದ, ಯಾದೃಚ್ om ಿಕ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸುವುದು ಸುಲಭ
  • ರಚನೆಯ ಅಂಶಗಳಿಗಾಗಿ ನಿರಂತರ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ.
  • ಎರಡನ್ನೂ ಸಂಗ್ರಹಿಸಬಹುದು ಪ್ರಾಚೀನ ಮತ್ತು ಪ್ರಾಚೀನವಲ್ಲದ ಡೇಟಾ ಮೌಲ್ಯಗಳನ್ನು

ಜಾವಾದಲ್ಲಿ ಅರೇ ಅನ್ನು ಹೇಗೆ ಘೋಷಿಸುವುದು?

ಜಾವಾ ಅರೇಸ್ ಘೋಷಣೆ

ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಕೆಳಗಿನ ವಿಧಾನಗಳಲ್ಲಿ ಘೋಷಿಸಬಹುದು. ಅರೇ ಘೋಷಣೆಯು 2 ಭಾಗಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ಮೊದಲನೆಯದು ನಾವು ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ (ಇಂಟ್, ಸ್ಟ್ರಿಂಗ್, ಇತ್ಯಾದಿ) ಸಂಗ್ರಹಿಸಬೇಕಾದ ಅಂಶಗಳ ಡೇಟಾಟೈಪ್ ಮತ್ತು ನಂತರ ರಚನೆಯ ಹೆಸರಿನೊಂದಿಗೆ. [] ಬ್ರಾಕೆಟ್ಗಳು ಇದು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಸೂಚಿಸುತ್ತದೆ. ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಿದಾಗ, ಅದು ಕಂಪೈಲರ್‌ಗೆ ವೇರಿಯೇಬಲ್ ಒಂದು ಶ್ರೇಣಿಯಾಗಿದೆ ಮತ್ತು ಅದು ನಿಜವಾಗಿಯೂ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುವುದಿಲ್ಲ ಎಂದು ಹೇಳುತ್ತದೆ.

ಡೇಟಾಟೈಪ್ [] ಅರೇನೇಮ್; (ಅಥವಾ)

ಡೇಟಾಟೈಪ್ [] ಅರೇನೇಮ್; (ಅಥವಾ)

ಡೇಟಾಟೈಪ್ ಅರೇನೇಮ್ []; -> ಸಾಮಾನ್ಯವಾಗಿ ಈ ವಿಧಾನವು ಮಾನ್ಯವಾಗಿದ್ದರೂ ಅದನ್ನು ಬಳಸಲು ನಾವು ಇಷ್ಟಪಡುವುದಿಲ್ಲ.

ರಚನೆಯ ಘೋಷಣೆಯ ಉದಾಹರಣೆ

int[] arrNumbers;
String[] arrNames;
float[] arrValues;
boolean[] arrBoolean;
char[] arrLetters;
byte[] arrBytes;
double[] arrWeight;

ಜಾವಾದಲ್ಲಿ ಅರೇ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು?

ಜಾವಾದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಅರೇ

ನಾವು ಬಳಸಿಕೊಂಡು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತೇವೆ ಹೊಸ ಆಪರೇಟರ್. ಇದರಲ್ಲಿ, ನಾವು ರಚನೆಯ ಗಾತ್ರವನ್ನು [] ನಲ್ಲಿ ಸೂಚಿಸುತ್ತೇವೆ, ಇದು ಅರೇ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಲು ಬೇಕಾದ ಮೆಮೊರಿಯ ಪ್ರಮಾಣವನ್ನು ಸೂಚಿಸುತ್ತದೆ.

arrname = ಹೊಸ ಡೇಟಾಟೈಪ್ [ಗಾತ್ರ];

ನಾವು ಘೋಷಿಸಬಹುದು ಮತ್ತು ರಚಿಸಬಹುದು ಸರಣಿ ಕೆಳಗಿನ ಒಂದು ಹೇಳಿಕೆಯಲ್ಲಿ. ಮೊದಲ ಹೇಳಿಕೆಯು ಗಾತ್ರದ ಸಂಖ್ಯೆಗಳ ಹೆಸರಿನ ಪೂರ್ಣಾಂಕ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತದೆ. ಎರಡನೆಯದು ಗಾತ್ರ 5 ರ ಹೆಸರುಗಳ ಹೆಸರಿನ ಸ್ಟ್ರಿಂಗ್ ರಚನೆಯನ್ನು ರಚಿಸುತ್ತದೆ

int[] arrNumbers = new int[5];
String[] arrNames = new String[2];

ಜಾವಾದಲ್ಲಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೇಗೆ ಪ್ರಾರಂಭಿಸುವುದು?

ಶ್ರೇಣಿಯನ್ನು ತ್ವರಿತಗೊಳಿಸುವುದು ಹೇಗೆ?

ಅರೇ ಇನಿಶಿಯಲೈಸೇಶನ್ ಅಥವಾ ಇನ್‌ಸ್ಟಾಂಟೈಸೇಶನ್ ಎಂದರೆ ಅರೇ ಗಾತ್ರವನ್ನು ಆಧರಿಸಿ ಒಂದು ಶ್ರೇಣಿಗೆ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸುವುದು. ನಾವು ಒಟ್ಟಿಗೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ಪ್ರಾರಂಭಿಸಬಹುದು (ತ್ವರಿತಗೊಳಿಸಬಹುದು) (ಕೆಳಗಿನ ವಿಧಾನ 1 ಅನ್ನು ನೋಡಿ). ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅಂಶಗಳ ಸಂಖ್ಯೆಯು ರಚನೆಯ ಉದ್ದ ಅಥವಾ ಗಾತ್ರವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ವಿಧಾನ 2 ರಲ್ಲಿ, ನಾವು ಪ್ರತಿ ಅಂಶವನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ t0 ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸುತ್ತಿದ್ದೇವೆ. ರಚನೆಯ ಸೂಚ್ಯಂಕವು 0 ರಿಂದ ಪ್ರಾರಂಭವಾಗುವುದರಿಂದ ಮತ್ತು ಇಲ್ಲಿ ರಚನೆಯ ಗಾತ್ರವು 3 ಆಗಿರುವುದರಿಂದ, 3 ನೇ ಅಂಶವು 2 ನೇ ಸ್ಥಾನವನ್ನು ಆಕ್ರಮಿಸುತ್ತದೆ, ಅದು n-1 ಆಗಿದ್ದರೆ n ಎಂಬುದು ರಚನೆಯ ಗಾತ್ರವಾಗಿರುತ್ತದೆ.

//Method 1
int[] arrNumbers = {1,2,3};

//Method 2
int[] arrNumbers = new int[3];
arrNumbers[0] = 1;
arrNumbers[1] = 2;
arrNumbers[2] = 3;

ಜಾವಾದಲ್ಲಿ ಅರೇ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಲಾಗುತ್ತಿದೆ

ನಾವು ಅದರ ಸೂಚ್ಯಂಕ ಮೌಲ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ರಚನೆಯ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸುತ್ತೇವೆ. ಸಾಮಾನ್ಯವಾಗಿ, ನಾವು ಬಳಸುತ್ತೇವೆ ಫಾರ್ ಲೂಪ್ ಅಥವಾ ಪ್ರತಿಯೊಂದಕ್ಕೂ ಎಲ್ಲಾ ಅಂಶಗಳು ಒಂದೇ ರೀತಿಯದ್ದಾಗಿರುವುದರಿಂದ ಮತ್ತು ಸ್ಥಿರ ಗಾತ್ರವನ್ನು ಹೊಂದಿರುವುದರಿಂದ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಲೂಪ್ ಮಾಡಿ.

ಉದಾಹರಣೆ: ಅರೇ ಅಂಶಗಳನ್ನು ರಚಿಸಿ, ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಪ್ರವೇಶಿಸಿ

ಇಲ್ಲಿ, ನಾವು ಒಂದೇ ಹೇಳಿಕೆಯಲ್ಲಿ ತಂತಿಗಳ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತಿದ್ದೇವೆ ಮತ್ತು ಪ್ರಾರಂಭಿಸುತ್ತಿದ್ದೇವೆ ಮತ್ತು ಲೂಪ್‌ಗಾಗಿ ಪ್ರತಿ ಅಂಶವನ್ನು ಪ್ರವೇಶಿಸುತ್ತಿದ್ದೇವೆ

public class ArrayDemo1 {

  public static void main(String[] args) {
    String[] arrMonths = {"May","June","July"};
    System.out.println("Length of array is: " + arrMonths.length);
    for(int i=0;i<arrMonths.length;i++)
    {
      System.out.println(arrMonths[i]); 
    }

  }

}
Output:
Length of array is: 3
May
June
July

ಉದಾಹರಣೆ: ರಚನೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮತ್ತು ರಚನೆಯ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸುವ ಇನ್ನೊಂದು ವಿಧಾನ

ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಮೊದಲು ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸುತ್ತೇವೆ ಮತ್ತು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಪ್ರತ್ಯೇಕ ಶ್ರೇಣಿಯ ಅಂಶಗಳಿಗೆ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ. ಇಲ್ಲಿ, ರಚನೆಯ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ನಾವು ಪ್ರತಿ ಲೂಪ್‌ಗಾಗಿ ಬಳಸುತ್ತಿದ್ದೇವೆ.

public class ArrayDemo2 {

  public static void main(String[] args) {
    int[] numbers = new int[5];
    numbers[0] = 100;
    numbers[1] = 101;
    numbers[2] = 103;
    numbers[3] = 104;
    numbers[4] = 105;
    
    for(int i: numbers)
    {
      System.out.println(i);
    }

  }

}
Output:
100
101
103
104
105

ಜಾವಾದಲ್ಲಿ ಸರಣಿಗಳ ಪ್ರಕಾರಗಳು

ಜಾವಾದಲ್ಲಿ 2 ವಿಧದ ಸರಣಿಗಳಿವೆ:

  • ಏಕ ಆಯಾಮದ ರಚನೆ - ಇದು ಕೇವಲ 1 ಸಾಲು ಮತ್ತು 1 ಕಾಲಮ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಮೇಲಿನ ಎಲ್ಲಾ ಉದಾಹರಣೆಗಳು ಒಂದೇ ಆಯಾಮದ ರಚನೆಗೆ ಸೇರಿವೆ
  • ಬಹುಆಯಾಮದ ರಚನೆ - ಇದು ಬಹು ಸಾಲುಗಳು ಮತ್ತು ಬಹು ಕಾಲಮ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಇದು ಎಲ್ಲಾ ಸಾಲುಗಳು ಒಂದೇ ಸಂಖ್ಯೆಯ ಕಾಲಮ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಸರಣಿಗಳ ಒಂದು ಶ್ರೇಣಿಯಾಗಿದೆ. ಉದಾ: 2 * 2 ಮ್ಯಾಟ್ರಿಕ್ಸ್
  • ಬೆಲ್ಲದ ರಚನೆ - ಪ್ರತಿಯೊಂದು ಸಾಲಿನಲ್ಲಿ ವಿಭಿನ್ನ ಸಂಖ್ಯೆಯ ಕಾಲಮ್‌ಗಳಿವೆ

ಜಾವಾದಲ್ಲಿ ಬಹುಆಯಾಮದ ಅರೇಗಳು

ಬಹುಆಯಾಮದ ಸರಣಿಗಳು ಬಹು ಸಾಲುಗಳು ಮತ್ತು ಕಾಲಮ್‌ಗಳನ್ನು ಹೊಂದಬಹುದು. ಮೊದಲ [] ​​ನಲ್ಲಿನ ಸೂಚ್ಯಂಕವು ಸಾಲುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಮತ್ತು ಎರಡನೆಯದು [] ಕಾಲಮ್‌ಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

ಉದಾ: ಇಂಟ್ [] [] ಎ = ಹೊಸ ಇಂಟ್ [2] [3]

ಇದರರ್ಥ ರಚನೆಯು 2 ಸಾಲುಗಳು ಮತ್ತು 3 ಕಾಲಮ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಬಹುಆಯಾಮದ ರಚನೆಯ ರೇಖಾಚಿತ್ರದ ನಿರೂಪಣೆಯನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ

ಜಾವಾದಲ್ಲಿ ಅರೇಗಳು

ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಬಹುಆಯಾಮದ ಸರಣಿಗಳನ್ನು ರಚಿಸುವ ಉದಾಹರಣೆ

ಕೆಳಗಿನ ಉದಾಹರಣೆಯು ಬಹುಆಯಾಮದ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು, ಘೋಷಿಸುವುದು ಮತ್ತು ಪ್ರವೇಶಿಸುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ. ಇಲ್ಲಿ, ನಾವು ಸಾಲು ಮತ್ತು ಕಾಲಮ್ ಸೂಚಿಯನ್ನು ಬಳಸಿಕೊಂಡು ರಚನೆಯ ಅಂಶಗಳನ್ನು ನೇರವಾಗಿ ಪ್ರವೇಶಿಸುತ್ತೇವೆ.

public class ArrayMulti {

  public static void main(String[] args) {
    String[][] arrNames = {{"John","Jacob"},{"Thomas","Martin"}};
    System.out.println(arrNames[0][0] + " " + arrNames[0][1]);
    System.out.println(arrNames[1][0] + " " + arrNames[1][1]);

  }

}
Output:
John Jacob 
Thomas Martin

2D ರಚನೆಯ ಪೂರ್ಣಾಂಕಗಳ ಉದಾಹರಣೆ

ಇಲ್ಲಿ, ನಾವು 2 ಸಾಲುಗಳು ಮತ್ತು 2 ಕಾಲಮ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಪೂರ್ಣಾಂಕಗಳ 3 ಆಯಾಮದ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತಿದ್ದೇವೆ. ಈ ಮೌಲ್ಯಗಳ ಒಳಗೆ ನಾವು ಮೌಲ್ಯಗಳನ್ನು ಲೂಪ್‌ಗಾಗಿ ನಿಯೋಜಿಸುತ್ತೇವೆ. ಲೂಪ್‌ಗಾಗಿ 1 ನೇ ಸಾಲುಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ ಮತ್ತು ಲೂಪ್‌ಗೆ 2 ನೇ ಕಾಲಮ್‌ಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ.

public class ArrayMulti {

  public static void main(String[] args) {
    //Declare and create multidimensional array
    int[][] arrnum = new int[2][3];
    for(int i=0;i<2;i++) {
      for(int j=0;j<3;j++) {
        //Assign values to array elements
        arrnum[i][j] = i+1;
        System.out.print(arrnum[i][j] + " ");
      }
      System.out.println();
    }

  }

}
Output:
1 1 1 
2 2 2 

ಜಾವಾದಲ್ಲಿ ಬೆಲ್ಲದ ಅರೇಗಳು

ಬೆಲ್ಲದ ರಚನೆಯು ವಿಭಿನ್ನ ಆಯಾಮಗಳನ್ನು ಹೊಂದಿರುವ 2 ಆಯಾಮದ ರಚನೆಯಾಗಿದೆ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಪ್ರತಿ ಸಾಲಿನಲ್ಲಿ ವಿಭಿನ್ನ ಸಂಖ್ಯೆಯ ಕಾಲಮ್‌ಗಳಿವೆ. ಬೆಲ್ಲದ ರಚನೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವುದು ಸಾಮಾನ್ಯ 2 ಡಿ ರಚನೆಗಿಂತ ಭಿನ್ನವಾಗಿರುತ್ತದೆ.

ಬೆಲ್ಲದ ರಚನೆಯ ಪ್ರಾರಂಭ

ರಚನೆಯ ರಚನೆಯ ಸಮಯದಲ್ಲಿ, ನಾವು ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತೇವೆ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಅದು 2. ಮುಂದಿನ 2 ಹೇಳಿಕೆಗಳಲ್ಲಿ, ಪ್ರತಿ ಸಾಲು ರಚನೆಗೆ, ನಾವು ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತೇವೆ. ಇಲ್ಲಿ, 1 ನೇ ಸಾಲಿನಲ್ಲಿ 3 ಕಾಲಮ್‌ಗಳಿವೆ ಮತ್ತು 2 ನೇ ಸಾಲಿನಲ್ಲಿ 4 ಕಾಲಮ್‌ಗಳಿವೆ.

int[][] arrnum = new int[2][];
arrnum[0] = new int[3];
arrnum[1] = new int[4];

ಲೂಪ್‌ಗಾಗಿ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸುವ ಮೂಲಕ ಬೆಲ್ಲದ ರಚನೆಯ ಉದಾಹರಣೆ

public class JaggedArray {

  public static void main(String[] args) {
    int[][] arrnum = new int[2][];
    arrnum[0] = new int[3];
    arrnum[1] = new int[4];

    int val=1;
    //Assign values
    for(int i=0;i<arrnum.length;i++) {
      for(int j=0;j<arrnum[i].length;j++) {
        arrnum[i][j] = val;
      }
    }
    
    //Print the values
    for(int i=0;i<arrnum.length;i++)
    {
      for(int j=0;j<arrnum[i].length;j++)
      {
        System.out.print(arrnum[i][j] + " ");
      }
      System.out.println();
    }
  }

}
Output:
1 1 1 
1 1 1 1 

ರಚನೆಯ ಸಮಯದಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೂಲಕ ಮೊನಚಾದ ರಚನೆಯ ಉದಾಹರಣೆ

public class JaggedArray {

  public static void main(String[] args) {
    int[][] arr = {{4,5,6},{1,2},{7,9,8}};
    for(int i=0;i<3;i++)
    {
      for(int j=0;j<arr[i].length;j++) {
        System.out.print(arr[i][j] + " ");
      }
      System.out.println();
    }
  }
}
Output:
4 5 6 
1 2 
7 9 8 

ಜಾವಾ ಅರೇ ವಿಧಾನಗಳು

ಜಾವಾದಲ್ಲಿ ಅರೇಸ್ ಬೆಂಬಲಿಸುವ ನೇರ ವಿಧಾನಗಳನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ

ವಿಧಾನವಿವರಣೆ
ಅನೂರ್ಜಿತ ತದ್ರೂಪಿ ()ಉಲ್ಲೇಖಗಳನ್ನು ನಕಲಿಸದಿರುವ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಅರೇ ಮೌಲ್ಯಗಳನ್ನು ಕ್ಲೋನ್ ಮಾಡುತ್ತದೆ
ಬೂಲಿಯನ್ ಸಮನಾಗಿರುತ್ತದೆ (ವಸ್ತು 0)ಬೇರೆ ಯಾವುದಾದರೂ ವಸ್ತುವು ಪ್ರಸ್ತುತ ವಸ್ತುವಿಗೆ ಸಮನಾಗಿವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ
ವರ್ಗ ಗೆಟ್‌ಕ್ಲಾಸ್ ()ವರ್ಗ ಹೆಸರನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
ಸ್ಟ್ರಿಂಗ್ ಟು ಸ್ಟ್ರಿಂಗ್ ()ವಸ್ತುವಿನ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
ಇಂಟ್ ಉದ್ದ ()ರಚನೆಯ ಉದ್ದವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ

ಜಾವಾ ಅರೇ ವಿನಾಯಿತಿಗಳು

ಒಳಗೆ ಅರೇಗಳು ಜಾವಾ ಎಸೆಯುತ್ತಾರೆ ಕೆಳಗಿನ ವಿನಾಯಿತಿ:

  • ArrayIndexOutOfBoundsException: ನಾವು ಸೂಚಿಸುವ ಸೂಚ್ಯಂಕ ಮೌಲ್ಯವು ರಚನೆಯ ಉದ್ದಕ್ಕಿಂತ ದೊಡ್ಡದಾದಾಗ ಅಥವಾ ಅದು .ಣಾತ್ಮಕವಾಗಿದ್ದಾಗ ಇದು ಸಂಭವಿಸುತ್ತದೆ. ಮೌಲ್ಯವನ್ನು ನಿಗದಿಪಡಿಸುವಾಗ ಅಥವಾ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸುವಾಗ ಇದು ಮುಖ್ಯವಾಗಿ ಸಂಭವಿಸುತ್ತದೆ.

ರಚನೆಯನ್ನು ನಕಲಿಸಿ

ವರ್ಗ ವ್ಯವಸ್ಥೆಯ ವಿಧಾನ ಅರೆಕೋಪಿ ಬಳಸಿ ನಾವು ಒಂದು ಶ್ರೇಣಿಯಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ಅಂಶಗಳನ್ನು ನಕಲಿಸಬಹುದು.

ಅರೇ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ನಕಲಿಸಿ

ಸಾರ್ವಜನಿಕ ಅನೂರ್ಜಿತ ಅರೆಕೋಪಿ (ಆಬ್ಜೆಕ್ಟ್ ಎಸ್‌ಆರ್‌ಸಿ, ಇಂಟ್ ಎಸ್‌ಆರ್‌ಸಿಪೋಸ್, ಆಬ್ಜೆಕ್ಟ್ ಡೆಸ್ಟ್, ಇಂಟ್ ಡೆಸ್ಟ್‌ಪೋಸ್, ಇಂಟ್ ಉದ್ದ);

ನಕಲಿಸಲು src- ಮೂಲ ರಚನೆಯ ವಸ್ತು

srcPos - ಮೂಲ ರಚನೆಯಲ್ಲಿ ಆರಂಭಿಕ ಸ್ಥಾನ

dest - ನಕಲಿಸಲು ಗಮ್ಯಸ್ಥಾನ ರಚನೆಯ ವಸ್ತು

destPos - ಗಮ್ಯಸ್ಥಾನ ಶ್ರೇಣಿಯಲ್ಲಿ ಆರಂಭಿಕ ಸ್ಥಾನ

ಉದ್ದ - ನಕಲಿಸಲು ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ

ರಚನೆಯನ್ನು ನಕಲಿಸುವ ಉದಾಹರಣೆ

ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಮೂಲ ರಚನೆಯಿಂದ 4 ಅಂಶಗಳನ್ನು ಗಮ್ಯಸ್ಥಾನ ರಚನೆಗೆ ನಕಲಿಸುತ್ತಿದ್ದೇವೆ. ಆದ್ದರಿಂದ output ಟ್ಪುಟ್ "ಜಾವಾ" ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ

public class ArrayCopy {

  public static void main(String[] args) {
    char[] a = {'d','l','h','y','j','a','v','a','g','r','t'};
    char[] b = new char[4];
    
    System.arraycopy(a, 4, b, 0, 4);
    System.out.println(String.valueOf(b));

  }

}
Output:
java

ಶ್ರೇಣಿಯನ್ನು ಒಂದು ವಿಧಾನಕ್ಕೆ ರವಾನಿಸಿ

ಜಾವಾದಲ್ಲಿ, ಹೆಚ್ಚಿನ ಕುಶಲತೆ ಅಥವಾ ಇತರ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ನಾವು ಒಂದು ಶ್ರೇಣಿಯ ವಸ್ತುವನ್ನು ರವಾನಿಸಬಹುದು. ಕೆಳಗಿನ ಉದಾಹರಣೆಯು ನಾವು ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯ ವಸ್ತುವನ್ನು ಒಂದು ವಿಧಾನಕ್ಕೆ ಹೇಗೆ ರವಾನಿಸಬಹುದು ಮತ್ತು ಎಲ್ಲಾ ರಚನೆಯ ಅಂಶಗಳ ಸೇರ್ಪಡೆ ಹೇಗೆ ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.

public class ArrayDemo3 {

  public static void main(String[] args) {
    int[] num = {5,7,3,2,8};
    add(num);

  }
  
  public static void add(int[] num) {
    int sum = 0;
    for(int i=0;i<num.length;i++) {
      sum = sum + num[i];
    }
    System.out.println("Sum of array elements is : " + sum);
  }

}
Output:
Sum of array elements is : 25

ಒಂದು ವಿಧಾನದಿಂದ ಅರೇ ಹಿಂತಿರುಗಿ

ನಾವು ಸಹ ಮಾಡಬಹುದು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಿಂತಿರುಗಿ ಅಗತ್ಯವಾದ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಮಾಡಿದ ನಂತರ ವಿಧಾನದಿಂದ ಮುಖ್ಯ ವಿಧಾನಕ್ಕೆ ಆಬ್ಜೆಕ್ಟ್.

public class ArrayDemo4 {

  public static void main(String[] args) {
    String[] arr = getArrayValues();
    for(String cities:arr) {
      System.out.println(cities);
    }
      

  }
  
  public static String[] getArrayValues() {
    String[] arrCities = {"Chennai","Bangalore","Delhi"};
    return arrCities;
  }

}
Output:
Chennai
Bangalore
Delhi

ಅರೇ ಕುಶಲತೆಗಳು

ಒಳಗೆ ಅರೇಗಳು ಜಾವಾ java.util ಪ್ಯಾಕೇಜ್‌ಗೆ ಸೇರಿದೆ. ಕೆಳಗೆ ಹೇಳಿದಂತೆ java.util.Array ವರ್ಗದಿಂದ ಬೆಂಬಲಿತವಾದ ಹಲವಾರು ಕಾರ್ಯಾಚರಣೆಗಳಿವೆ:

  • ಒಂದು ಶ್ರೇಣಿಯಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ಒಂದು ಶ್ರೇಣಿಯ ಅಂಶಗಳನ್ನು ನಕಲಿಸಲು ನಾವು ಅರೇ ವರ್ಗದ copyOfRange ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು
  • ಸೂಚ್ಯಂಕದ ಆಧಾರದ ಮೇಲೆ ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯಕ್ಕಾಗಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹುಡುಕಿ (ಬೈನರಿ ಹುಡುಕಾಟ)
  • ಸಮಾನ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಸಮಾನತೆಯನ್ನು ಪರೀಕ್ಷಿಸಲು ಅರೇಗಳಿಗೆ ಹೋಲಿಕೆ ಮಾಡಿ
  • ಸೂಚ್ಯಂಕದಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವನ್ನು ಇರಿಸಲು ಶ್ರೇಣಿಯನ್ನು ತುಂಬಲು ಫಿಲ್ ವಿಧಾನವನ್ನು ಬಳಸಿ
  • ವಿಂಗಡಿಸುವ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ವಿಂಗಡಿಸುವುದು

ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿತ ವಸ್ತುವನ್ನು ಬಳಸಿಕೊಂಡು ರಚನೆಯನ್ನು ರಚಿಸುವುದು

ಜಾವಾದಲ್ಲಿ, ನಾವು ತಂತಿಗಳು, ಪೂರ್ಣಾಂಕ ಇತ್ಯಾದಿಗಳ ಶ್ರೇಣಿಯನ್ನು ಹೇಗೆ ರಚಿಸುತ್ತೇವೆ ಎಂಬುದರಂತೆಯೇ ನಾವು ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿತ ವಸ್ತುವನ್ನು ಸಹ ರಚಿಸಬಹುದು. ಇದು ನಾವು ವಿದ್ಯಾರ್ಥಿ ರಚನೆಯ ವಸ್ತುವನ್ನು ಹೇಗೆ ರಚಿಸಬಹುದು ಮತ್ತು ರಚನೆಯ ವಸ್ತುವನ್ನು ಹೇಗೆ ಪ್ರಾರಂಭಿಸಬಹುದು ಎಂಬುದಕ್ಕೆ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.

public class ArrayDemo5 {

  public static void main(String[] args) {
    Student[] s = new Student[2];
    s[0] = new Student(111,"Ajit");
    s[1] = new Student(112,"Biju");
  }

}
 class Student{
  public int rollno;
  public String name;
  public Student(int rno,String n) {
    rollno = rno;
    name = n;
  }
}

ತೀರ್ಮಾನ

ಈ ಟ್ಯುಟೋರಿಯಲ್ ಜಾವಾದಲ್ಲಿನ ಅರೇಸ್ ಕ್ಲಾಸ್, ಜಾವಾದಲ್ಲಿನ ಅರೇಗಳ ಬಗೆಗಳ ವಿವರವಾದ ವಿವರಣೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ವಿವಿಧ ಚಿತ್ರಣಗಳೊಂದಿಗೆ ಅರೇಗಳನ್ನು ಘೋಷಿಸಿ, ರಚಿಸಿ ಮತ್ತು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.

ರೆಫರೆನ್ಸ್