Verschiedene Möglichkeiten zum Deklarieren und Initialisieren von 2-D-Arrays in Java
Ein Array mit mehr als einer Dimension wird als mehrdimensionales Array bezeichnet . Die am häufigsten verwendeten mehrdimensionalen Arrays sind 2-D- und 3-D-Arrays. Wir können sagen, dass jedes höherdimensionale Array im Grunde ein Array von Arrays ist. Ein sehr häufiges Beispiel für ein 2D-Array ist Chess Board. Ein Schachbrett ist ein Raster mit 64 quadratischen 1×1-Feldern. Auf ähnliche Weise können Sie ein 2D-Array visualisieren. In einem 2D-Array ist jedem Element eine Zeilennummer und eine Spaltennummer zugeordnet. Der Zugriff auf ein beliebiges Element des 2D-Arrays ähnelt dem Zugriff auf den Datensatz einer Excel-Datei unter Verwendung sowohl der Zeilennummer als auch der Spaltennummer. 2D-Arrays sind nützlich bei der Implementierung eines Tic-Tac-Toe-Spiels, Schach oder sogar beim Speichern der Bildpixel.
Deklaration des 2-D-Arrays in Java:
Jedes zweidimensionale Array kann wie folgt deklariert werden:
Syntax:
data_type array_name[][]; (OR) data_type[][] array_name;
- data_type: Da Java eine statisch typisierte Sprache ist (dh sie erwartet, dass ihre Variablen deklariert werden, bevor ihnen Werte zugewiesen werden können). Die Angabe des Datentyps entscheidet also über die Art der akzeptierten Elemente. Um zB nur ganzzahlige Werte zu speichern, wird der Datentyp als int deklariert.
- array_name: Dies ist der Name, der dem 2-D-Array gegeben wird. B. Fächer, Studenten, Früchte, Abteilung usw.
Hinweis: Wir können [ ][ ] nach data_type schreiben oder wir können [ ][ ] nach array_name schreiben, während wir das 2D-Array deklarieren.
Java
// java program showing declaration of arrays
import java.io.*;
class GFG {
public static void main(String[] args)
{
int[][] integer2DArray; // 2D integer array
String[][] string2DArray; // 2D String array
double[][] double2DArray; // 2D double array
boolean[][] boolean2DArray; // 2D boolean array
float[][] float2DArray; // 2D float array
double[][] double2DArray; // 2D double array
}
}
Initialisierung des 2-D-Arrays in Java:
data_type[][] array_Name = new data_type[no_of_rows][no_of_columns];
Die Gesamtzahl der Elemente in jedem 2D-Array ist gleich (no_of_rows) * (no_of_columns).
- no_of_rows: Die Anzahl der Zeilen, die ein Array speichern kann. zB no_of_rows = 3, dann hat das Array drei Zeilen.
- no_of_columns: Die Anzahl der Zeilen, die ein Array speichern kann. zB no_of_columns = 4, dann hat das Array vier Spalten.
Die obige Syntax der Array-Initialisierung weist allen Array-Elementen gemäß dem angegebenen Datentyp Standardwerte zu.
Sehen wir uns verschiedene Ansätze zum Initialisieren von 2D-Arrays an:
Ansatz 1
Java
// java program to initialize a 2D array
import java.io.*;
class GFG {
public static void main(String[] args)
{
// Declaration along with initialisation
// 2D integer array with 5 rows and 3 columns
// integer arrray elements are initialised with 0
int[][] integer2DArray = new int[5][3];
System.out.println(
"Default value of int array element: "
+ integer2DArray[0][0]);
// 2D String array with 4 rows and 4 columns
// String array elements are initialised with null
String[][] string2DArray = new String[4][4];
System.out.println(
"Default value of String array element: "
+ string2DArray[0][0]);
// 2D boolean array with 3 rows and 5 columns
// boolean array elements are initialised with false
boolean[][] boolean2DArray = new boolean[4][4];
System.out.println(
"Default value of boolean array element: "
+ boolean2DArray[0][0]);
// 2D char array with 10 rows and 10 columns
// char array elements are initialised with
// '\u0000'(null character)
char[][] char2DArray = new char[10][10];
System.out.println(
"Default value of char array element: "
+ char2DArray[0][0]);
// First declaration and then initialisation
int[][] arr; // declaration
// System.out.println("arr[0][0]: "+ arr[0][0]);
// The above line will throw an error, as we have
// only declared the 2D array, but not initialised
// it.
arr = new int[5][3]; // initialisation
System.out.println("arr[0][0]: " + arr[0][0]);
}
}
Hinweis: Wenn Sie ein 2D-Array initialisieren, müssen Sie immer die erste Dimension (Anzahl der Zeilen) angeben, aber die Angabe der zweiten Dimension (Anzahl der Spalten) kann weggelassen werden.
Im folgenden Code-Snippet haben wir die Anzahl der Spalten nicht angegeben. Der Java-Compiler ist jedoch intelligent genug, um die Größe zu manipulieren, indem er die Anzahl der Elemente in den Spalten überprüft.
Java
import java.io.*;
class GFG {
public static void main(String[] args)
{
// The line below will throw an error, as the first
// dimension(no. of rows) is not specified
int[][] arr = new int[][3];
// The line below will execute without any error, as
// the first dimension(no. of rows) is specified
int[][] arr = new int[2][];
}
}
Sie können auf jedes Element eines 2D-Arrays zugreifen, indem Sie die Zeilennummer und die Spaltennummer verwenden.
Ansatz 2
Im folgenden Code-Snippet haben wir die Anzahl der Zeilen und Spalten nicht angegeben. Der Java-Compiler ist jedoch intelligent genug, um die Größe zu manipulieren, indem er die Anzahl der Elemente in den Zeilen und Spalten überprüft.
Java
import java.io.*;
class GFG {
public static void main(String[] args)
{
String[][] subjects = {
{ "Data Structures & Algorithms",
"Programming & Logic", "Software Engineering",
"Theory of Computation" }, // row 1
{ "Thermodynamics", "Metallurgy",
"Machine Drawing",
"Fluid Mechanics" }, // row2
{ "Signals and Systems", "Digital Electronics",
"Power Electronics" } // row3
};
System.out.println(
"Fundamental Subject in Computer Engineering: "
+ subjects[0][0]);
System.out.println(
"Fundamental Subject in Mechanical Engineering: "
+ subjects[1][3]);
System.out.println(
"Fundamental Subject in Electronics Engineering: "
+ subjects[2][1]);
}
}
Ansatz 3
Außerdem können wir jedes Element des Arrays separat initialisieren. Sehen Sie sich das folgende Code-Snippet an:
Java
import java.io.*;
import java.util.*;
class GFG {
public static void main(String[] args)
{
int[][] scores = new int[2][2];
// Initializing array element at position[0][0],
// i.e. 0th row and 0th column
scores[0][0] = 15;
// Initializing array element at position[0][1],
// i.e. 0th row and 1st column
scores[0][1] = 23;
// Initializing array element at position[1][0],
// i.e. 1st row and 0th column
scores[1][0] = 30;
// Initializing array element at position[1][1],
// i.e. 1st row and 1st column
scores[1][1] = 21;
// printing the array elements individually
System.out.println("scores[0][0] = "
+ scores[0][0]);
System.out.println("scores[0][1] = "
+ scores[0][1]);
System.out.println("scores[1][0] = "
+ scores[1][0]);
System.out.println("scores[1][1] = "
+ scores[1][1]);
// printing 2D array using Arrays.deepToString() method
System.out.println(
"Printing 2D array using Arrays.deepToString() method: ");
System.out.println(Arrays.deepToString(scores));
}
}
Ansatz 4
Die Verwendung des obigen Ansatzes zur Array-Initialisierung wäre eine mühsame Aufgabe, wenn die Größe des 2D-Arrays zu groß ist. Der effiziente Weg ist die Verwendung einer for-Schleife zum Initialisieren der Array-Elemente im Fall eines großen 2D-Arrays.
Java
import java.io.*;
class GFG {
public static void main(String[] args)
{
int rows = 80, columns = 5;
int[][] marks = new int[rows][columns];
// initializing the array elements using for loop
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
marks[i][j] = i + j;
}
}
// printing the first three rows of marks array
System.out.println("First three rows are: ");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < columns; j++) {
System.out.printf(marks[i][j] + " ");
}
System.out.println();
}
}
}
Wir können arr verwenden. length kann verwendet werden, um die Größe der Zeilen zu ermitteln (1. Dimension), und arr[0].length kann verwendet werden, um die Größe der Spalten zu ermitteln (2. Dimension).
Ansatz 5: (Zackige Arrays)
Es kann ein bestimmtes Szenario geben, in dem Sie möchten, dass jede Zeile eine andere Anzahl von Spalten enthält. Diese Art von Array wird als Jagged Array bezeichnet .
Java
import java.io.*;
class GFG {
public static void main(String[] args)
{
// declaring a 2D array with 2 rows
int jagged[][] = new int[2][];
// not specifying the 2nd dimension,
// and making it as jagged array
// first row has 2 columns
jagged[0] = new int[2];
// second row has 2 columns
jagged[1] = new int[4];
// Initializing the array
int count = 0;
for (int i = 0; i < jagged.length; i++) {
// remember to use jagged[i].length instead of
// jagged[0].length, since every row has
// different number of columns
for (int j = 0; j < jagged[i].length; j++) {
jagged[i][j] = count++;
}
}
// printing the values of 2D Jagged array
System.out.println("The values of 2D jagged array");
for (int i = 0; i < jagged.length; i++) {
for (int j = 0; j < jagged[i].length; j++)
System.out.printf(jagged[i][j] + " ");
System.out.println();
}
}
}
Implementierung:
Schauen wir uns ein einfaches Programm an, um zwei 2D-Arrays hinzuzufügen:
Java
import java.io.*;
import java.util.*;
class GFG {
public static void main(String[] args)
{
int[][] arr1 = { { 1, 2, 3 }, { 4, 5, 6 } };
int[][] arr2 = { { 4, 5, 6 }, { 1, 3, 2 } };
int[][] sum = new int[2][3];
// adding two 2D arrays element-wise
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[0].length; j++) {
sum[i][j] = arr1[i][j] + arr2[i][j];
}
}
System.out.println("Resultant 2D array: ");
for (int i = 0; i < sum.length; i++) {
System.out.println(Arrays.toString(sum[i]));
}
}
}