![Java Tutorial Deutsch (German) [15/24] - Mehrdimensionale Arrays](https://i.ytimg.com/vi/AvE1ohSKVCo/hqdefault.jpg)
Inhalt
- 1. Deklarieren eines Ragged Arrays
- Listing 1:
- 2. Festlegen der Array-Referenzen
- Listing 2:
- 3. Auffüllen des Ragged-Arrays
- Listing 3:
- 4. Auswahl eines zerlumpten Array-Elements
- Listing 4:
- 5. Dynamisches Iterieren aller Elemente eines zerlumpten Arrays
- Listing 5:
Ich bin ein Softwareentwickler. Ich arbeite seit 15 Jahren mit C ++ -, MFC- und .net-Technologien. Ich mag Videospiele und lese Bücher.
In Java ist "zerlumptes Array" ein "Array von Array". Dies bedeutet, dass ein Array so erstellt werden kann, dass jedes Element des Arrays eine Referenz auf ein anderes Array desselben Typs ist. Beispielsweise bezieht sich ein zweidimensionales Array von 3 × 2 auf drei Zeilen und zwei Spalten (d. H. Jede Zeile hat zwei Spalten). Wir nennen dies "rechteckiges Array". Im Fall eines unregelmäßigen Arrays kann die Anzahl der Spalten möglicherweise nicht festgelegt werden.
Beachten Sie, dass "gezacktes Array" und "zerlumptes Array" und "unregelmäßig dimensioniertes Array" alle gleich sind.
1. Deklarieren eines Ragged Arrays
Der folgende Code (Listing 1) deklariert ein unregelmäßiges Array:
Listing 1:
// Snippet 01: Deklariere ein unregelmäßiges 2D-Array double [] [] ir_array = new double [3] [];
Hier, ir_array ist ein zerlumptes Array und die Dimension auf der rechten Seite [3] [] gibt eine Dimension als fest und eine andere als unbekannt an. Hier können wir im obigen Code ir_array als eindimensionales Array eines doppelten Arrays aufrufen. Auf diese Weise kann man ein "mehrdimensionales, zerlumptes Array" erstellen.
2. Festlegen der Array-Referenzen
Jetzt ist es an der Zeit, Platz für drei Arrays vom Typ double zuzuweisen und ihre Referenz in der ersten Dimension festzulegen. Der folgende Code (Listing 2) zeigt das Einrichten der unregelmäßigen Dimension:
Listing 2:
// Snippet 02: Deklariere jetzt drei Arrays ir_array [0] = new double [5]; ir_array [1] = neues Doppel [3]; ir_array [2] = neues Doppel [2];
Hier haben wir drei Arrays zum Speichern von Double erstellt und die Arraygröße beträgt 5,3,2. Jedes Array ist im Array ir_array gestapelt. Beispielsweise wird das erste Doppelarray der Größe 5 im ersten Steckplatz von ir_array gespeichert, und auf die gleiche Weise wird das zweite Array der Größe 3 im zweiten Steckplatz des ir_array usw. gespeichert.
Im obigen Code hatten wir unser zerlumptes Array eingerichtet. Die drei Slots (sagen wir dies als Zeile) bilden eine dreizeilige und jede Zeile repräsentiert ein Array. Beispielsweise ist ir_array [2] die dritte Zeile und repräsentiert ein Array der Größe 2, das die Spalten dafür darstellt. OK, lassen Sie uns dieses Array jetzt füllen.
3. Auffüllen des Ragged-Arrays
Schauen Sie sich den folgenden Code an, der das zerlumpte Array auffüllt:
Listing 3:
// Snippet 03: Initialisiere die Arrays für (int i = 0; i 5; i ++) {ir_array [0] [i] = (i + 1) * 10; } für (int i = 0; i 3; i ++) {ir_array [1] [i] = (i + 1) * 5; } für (int i = 0; i 2; i ++) {ir_array [2] [i] = (i + 1) * 2; }}
Im obigen Code wird das erste Array von double mit dem Wert gefüllt, der ein Vielfaches von 10 ist, und die fünf Elementwerte sind 10,20,30,40,50. Das zweite Array von double wird mit den Werten gefüllt, die ein Vielfaches von 5 sind. Das dritte Array wird mit dem Wert gefüllt, der ein Vielfaches von 2 ist. Nach dem Auffüllen des Arrays sieht das Array wie folgt aus:
4. Auswahl eines zerlumpten Array-Elements
Sobald das zerlumpte Array fertig ist, kann der Elementwert wie bei einem normalen Array ausgewählt werden. In unserem Beispiel haben wir ein unregelmäßiges Array mit zwei Dimensionen eingerichtet. Um also ein Element aus diesem Array auszuwählen, müssen wir die Zelle durch ihre Zeile und Spalte lokalisieren. Betrachten wir zum Beispiel ir_array [0] [4] und hier sagt ir_array [0] das erste Array von double mit der Länge 5 und die zweite Dimension [4] sagt, dass das fünfte Element lokalisiert werden soll. Betrachten Sie nun den folgenden Code (Listing 4):
Listing 4:
// Snippet 04: Nun nehmen wir zufällig einen Wert // und drucken ihn aus. System.out.println ("ir_array [0] [4] =" + ir_array [0] [4]); System.out.println ("ir_array [1] [2] =" + ir_array [1] [2]); System.out.println ("ir_array [2] [1] =" + ir_array [2] [1]);
Im obigen Codebeispiel haben wir drei Elemente aus dem gezackten Array ausgewählt und diese im Konsolenausgabefenster angezeigt. Die ausgewählten Elemente sind im folgenden Bild dargestellt:
5. Dynamisches Iterieren aller Elemente eines zerlumpten Arrays
Die Länge-Eigenschaft des Arrays ist nützlich, um das gezackte Array dynamisch zu iterieren. Hier im folgenden Code bezeichnet ir_array das "Array of Double Array" und seine Länge wird zuerst genommen und iteriert. Wenn wir ir-array einen Index geben, stellt er das doppelte Array dar, da in diesem Index die Referenz des doppelten Arrays gespeichert wird. Wenn wir die Eigenschaft length lesen (z. B. ir_array [0] .length), gibt dies die Länge des Doppelarrays an, das als verschachtelte Schleife iteriert wird.
Im folgenden Codeausschnitt haben wir alle Array-Elemente durchlaufen und das Ergebnis in das Konsolenausgabefenster gedruckt:
Listing 5:
// Snippet 05: Durchlaufen Sie das Jagged Array System.out.println (""); System.out.println ("Iterieren durch das gezackte Array"); for (int arrayofArrayIndex = 0; arrayofArrayIndex ir_array.length; arrayofArrayIndex ++) {for (int ArrayOfDoubleIndex = 0; ArrayOfDoubleIndex ir_array [arrayofArrayIndex] .length; ArrayOfDoubleIndex ++) ;; } System.out.println (""); }}
Das vollständige Beispiel und seine Ausgabe sind unten angegeben:
Paket com.JavaHub; public class Main {public statisch void main (String [] args) {// Snippet 01: Deklariere ein unregelmäßiges 2D-Array double [] [] ir_array = new double [3] []; // Snippet 02: Deklariere jetzt drei Arrays ir_array [0] = new double [5]; ir_array [1] = neues Doppel [3]; ir_array [2] = neues Doppel [2]; // Snippet 03: Initialisiere die Arrays für (int i = 0; i 5; i ++) {ir_array [0] [i] = (i + 1) * 10; } für (int i = 0; i 3; i ++) {ir_array [1] [i] = (i + 1) * 5; } für (int i = 0; i 2; i ++) {ir_array [2] [i] = (i + 1) * 2; } // Snippet 04: Nehmen wir nun zufällig einen Wert // und drucken ihn aus. System.out.println ("ir_array [0] [4] =" + ir_array [0] [4]); System.out.println ("ir_array [1] [2] =" + ir_array [1] [2]); System.out.println ("ir_array [2] [1] =" + ir_array [2] [1]); // Snippet 05: Durchlaufen Sie das Jagged Array System.out.println (""); System.out.println ("Iterieren durch das gezackte Array"); for (int arrayofArrayIndex = 0; arrayofArrayIndex ir_array.length; arrayofArrayIndex ++) {for (int ArrayOfDoubleIndex = 0; ArrayOfDoubleIndex ir_array [arrayofArrayIndex] .length; ArrayOfDoubleIndex ++) ;; } System.out.println (""); }}} Dieser Artikel ist genau und nach bestem Wissen des Autors. Der Inhalt dient nur zu Informations- oder Unterhaltungszwecken und ersetzt nicht die persönliche Beratung oder professionelle Beratung in geschäftlichen, finanziellen, rechtlichen oder technischen Angelegenheiten.
