Come impostare un array 2D in Java. Matrice Java

Successivamente, l'array a cui punta questo riferimento viene perso se non ci sono altri riferimenti ad esso..

La dimensione o la lunghezza di un array può essere ottenuta utilizzando una costante lunghezza , che è definito per ogni array e ne restituisce la lunghezza. L'abbiamo già usato più di una volta negli esempi quando abbiamo lavorato con argomenti passati sulla riga di comando.

È possibile creare e utilizzare array di lunghezza zero (un array vuoto). Per esempio:

È impossibile inizializzare un tale array, poiché semplicemente non ha elementi che possono essere inizializzati. Sorge immediatamente la domanda, perché diavolo hanno bisogno di questi array vuoti allora? Ma sono necessari e anche molto utili!

Un array vuoto viene solitamente utilizzato in quei punti del programma in cui non è noto in anticipo se ci saranno elementi o meno. Se sono presenti elementi, viene restituito un array non vuoto; se non sono presenti elementi, viene restituito un array vuoto. Un esempio è un array di stringhe che viene passato al metodo main() e contiene argomenti della riga di comando e, se non ce ne sono, viene restituito un array vuoto.

Un array vuoto è meglio di nullo, perché non richiede un separato if "e per l'elaborazione. Lo stesso vale per elenchi e altre raccolte. Ecco perché esistono i metodi Collections.emptyList, emptySet, emptyMap.

Inizializzazione dell'array

In questa fase, gli elementi dell'array ricevono i valori iniziali. Esistono diversi modi per inizializzare gli elementi dell'array con valori:

1. Assegna un valore specifico a ciascun elemento dell'array (questo può essere fatto, ad esempio, in un ciclo, ma prima l'array deve essere già dichiarato e creato)
2. Inizializzare un array elencando i valori dei suoi elementi tra parentesi graffe (questo può essere fatto sia in fase di dichiarazione che in fase di creazione, ma la sintassi è diversa)

Si riferisce a uno specifico elemento dell'array in base al suo indice, che parte da zero, come già accennato.

Gli indici possono essere specificati da qualsiasi espressione intera, ad eccezione del tipo lungo , ad esempio a , a , a[++i] . Il sistema di runtime Java garantisce che i valori di queste espressioni non superino la lunghezza dell'array. Se l'uscita si verifica ancora, l'interprete Java interromperà l'esecuzione del programma e visualizzerà un messaggio sulla console sull'indice dell'array che va oltre i limiti della sua definizione ( Indice della Matrice Fuori Dai Limiti d'Eccezione).

Considera un esempio del primo modo di inizializzazione:

Il secondo modo di inizializzazione può essere implementato in diversi modi.

L'inizializzazione dell'array può essere combinata con la fase di creazione, ma prima di questa operazione, l'array deve essere già dichiarato. Per esempio:

Prima della creazione e inizializzazione dell'array arè già stato annunciato.

Puoi anche inizializzare un array nella fase della sua dichiarazione con la seguente sintassi:

Attenzione! Questa sintassi di inizializzazione dell'array funziona solo quando viene dichiarato un array e combina tutte e tre le operazioni di dichiarazione, creazione e inizializzazione contemporaneamente. Se l'array è già dichiarato, questa sintassi non può essere utilizzata. Il compilatore genererà un errore. Cioè:

int ar ; // dichiarazione dell'array
ar = { 1 , 2 } ; // SBAGLIO!!! creazione e inizializzazione dell'array

Tale azione non funzionerà.

Puoi anche inizializzare in fase di dichiarazione e in modo leggermente diverso:

Sebbene questa sintassi sia più lunga. Se noti, questa sintassi è anche una combinazione di tutte e tre le operazioni: dichiarazione, creazione e inizializzazione.

Java fornisce una sintassi che supporta array anonimi (non sono assegnati a variabili e quindi non hanno nomi). A volte un array deve essere utilizzato solo una volta (ad esempio, passato a un metodo), quindi non vuoi perdere tempo ad assegnarlo a una variabile, quindi puoi utilizzare subito il risultato dell'istruzione. nuovo. Per esempio:

La sintassi per inizializzare le matrici con parentesi graffe è chiamata letterale, perché per l'inizializzazione viene utilizzata una matrice letterale.

È importante comprendere che gli array letterali vengono creati e inizializzati in fase di esecuzione, non in fase di compilazione.. Considera il seguente array letterale:

Si compila in questo bytecode Java:

Quindi, se è necessario inserire molti dati in un programma Java, è meglio non includerli direttamente in un array, perché il compilatore Java dovrà creare molti bytecode di inizializzazione dell'array, quindi l'interprete Java dovrà scrupolosamente eseguire tutto questo codice. In questi casi, è meglio archiviare i dati in un file esterno e leggerli nel programma in fase di esecuzione.

Tuttavia, il fatto che Java inizializzi un array in fase di esecuzione ha importanti implicazioni. Ciò significa che gli elementi di una matrice letterale sono espressioni arbitrarie valutate in fase di esecuzione, non espressioni costanti valutate dal compilatore.. Per esempio:

Ora facciamo un po' di pratica.

Il noto metodo main() utilizza la capacità di restituire un array di lunghezza zero se non ci sono argomenti sulla riga di comando, il che consente di evitare di utilizzare l'istruzione if per verificare la presenza di null al fine di evitare un errore durante l'esecuzione del programma .

Cioè, possiamo usare immediatamente l'array in un ciclo, seppur seguendo le regole per non andare oltre l'indice massimo.

All'inizio del programma, stampiamo il valore della lunghezza dell'array, quindi nel primo ciclo stampiamo in sequenza tutti i valori degli elementi dell'array. Il secondo ciclo fa lo stesso, ma in modo perverso.

Il secondo esempio è ciao per compiacere il tuo cervello per espandere la tua coscienza, non eri annoiato a sapere come farlo, ma come non farlo, beh, puramente per scopi educativi ed educativi. Forse a tuo piacimento scoprirai come funziona il secondo ciclo.

Questo programma genera il seguente output:

Nel primo caso, non abbiamo inserito alcun argomento, quindi abbiamo ottenuto un array di lunghezza zero, che non è stato elaborato nei loop, perché non soddisfa le condizioni dei loop.

Nel secondo caso, abbiamo passato argomenti sulla riga di comando e di conseguenza l'array è stato elaborato in cicli.

Matrici(array) _ sono insiemi ordinati di elementi dello stesso tipo. Gli elementi dell'array possono essere oggetti di tipo semplice e di riferimento, inclusi i riferimenti ad altri array. Gli array stessi sono oggetti e

ereditare la classe Object. Anno Domini

int ia = nuovo int;

Definisce una matrice denominata ia, che inizialmente punta a un insieme di tre elementi di tipo int.

Una dichiarazione di matrice non ne specifica la dimensione. Il numero di elementi dell'array viene specificato quando viene creato utilizzando l'operatore new. La lunghezza di un array è fissata al momento della creazione e non può essere modificata in seguito. Tuttavia, variabile tipo di array (nel nostro esempio - ia) in qualsiasi momento è possibile assegnare un nuovo array con una dimensione diversa.

Gli elementi dell'array sono accessibili dai valori dei loro numeri di indice.

Il primo elemento di una matrice ha indice zero (0) e l'ultimo elemento ha lunghezza - 1. È possibile accedere a un elemento della matrice specificando il nome della matrice e il valore dell'indice, racchiuso tra parentesi quadre, [ e ]. nell'esempio precedente, il primo elemento dell'array ia sarebbe ia e l'ultimo elemento sarebbe ia. Ogni volta che si accede a un elemento dell'array tramite l'indice, il sistema di runtime Java verifica se il valore dell'indice è entro i limiti e genera un'eccezione ArrayIndexOutOfBoundsException se il risultato è falso. 6 L'espressione dell'indice deve essere di tipo int - questo è l'unico limite al numero massimo di elementi dell'array.

La lunghezza di un array è facilmente determinabile utilizzando il campo della lunghezza di un oggetto array (che è implicitamente contrassegnato come public e final). Quello che segue è un codice aggiornato dell'esempio precedente, che prevede l'esecuzione del Loop, che assicura che il contenuto di ogni elemento dell'array ia venga visualizzato sullo schermo:

per (int i = o; i< ia.length; i++)

system.out.println(i + ": " + ia[i]);

Viene comunemente chiamato un array di lunghezza zero (cioè uno in cui non ci sono elementi). vuoto. Si noti che un riferimento a un array nullo e un riferimento a un array vuoto sono cose completamente diverse. Un array vuoto è un array reale che semplicemente non ha elementi. Un array vuoto è una comoda alternativa a null quando si ritorna da un metodo. Se il metodo è in grado di restituire null, il codice dell'applicazione in cui viene richiamato il metodo deve confrontare il valore restituito con null prima di procedere con il resto delle operazioni. Se il metodo restituisce un array (possibilmente vuoto), non sono necessari controlli aggiuntivi - ovviamente, a parte quelli relativi alla lunghezza dell'array e dovrebbero essere eseguiti comunque.

È consentita anche un'altra forma di dichiarazione dell'array, in cui le parentesi quadre sono specificate dopo l'identificatore dell'array e non dopo il nome del suo tipo:

int ia = nuovo int;

La prima sintassi, tuttavia, è preferita perché la dichiarazione del tipo è più compatta.

Modificatori nelle dichiarazioni di array

Regole per l'utilizzo di determinati array nelle dichiarazioni modificatori sono comuni e dipendono solo dal fatto che l'array appartenga a campi o variabili locali. C'è una cosa che è importante ricordare: i modificatori si applicano all'array in quanto tale, ma non ai suoi singoli elementi. Se la dichiarazione dell'array contiene l'attributo finale, significa solo che il riferimento all'array non può essere modificato dopo che è stato creato, ma non vieta in alcun modo la possibilità di modificare il contenuto dei singoli elementi dell'array. Il linguaggio non consente di specificare alcun modificatore (ad esempio, final o uolatile) per gli elementi dell'array.

Matrici multidimensionali

Java supporta la capacità di dichiarare array multidimensionali(array multidimensionali) (ovvero array i cui elementi sono altri array), il codice che dichiara una matrice bidimensionale e visualizza il contenuto dei suoi elementi sullo schermo potrebbe essere simile al seguente:

tappetino galleggiante = nuovo galleggiante;

setupMatrix(mat);

per (int y = o; y< mat.length; у++) {

per (int x = o; x< mat[y].length; х++)

system.out.print(mat[y][x] + " ");

system.out.println();

Quando si crea una matrice, è necessario specificare almeno la sua prima dimensione "più a sinistra". Altre dimensioni potrebbero non essere specificate - in questo caso, dovranno essere determinate in seguito. Specificare tutte le dimensioni contemporaneamente nell'operatore new è il modo più conciso per creare una matrice, evitando la necessità di nuovi operatori aggiuntivi. La dichiarazione dell'array mat e l'istruzione di creazione sopra sono equivalenti al seguente frammento di codice:

tappetino galleggiante = nuovo galleggiante;

per (int y = o; y< mat.length; у++)

mat[y] = nuovo float;

Questa forma di dichiarazione ha il vantaggio di consentire, oltre all'ottenimento di array con le stesse dimensioni (ad esempio, 4 x 4), di creare array di array di dimensioni diverse necessarie per memorizzare determinate sequenze di dati.

Inizializzazione dell'array

Quando viene creata una matrice, a ciascun elemento viene assegnato un valore predefinito a seconda del tipo di matrice: zero (0) per i tipi numerici, '\u0000′ _ per char, false per booleano e null per i tipi di riferimento. Dichiarando un array di un tipo di riferimento, stiamo effettivamente definendo un array incinta di questo tipo. Considera il seguente frammento di codice:

Attr attrs = nuovo Attr;

per (int i = o; i< attrs.length; i++)

attrs[i] = new Attr(nomi[i], valori[i]);

Dopo l'esecuzione della prima espressione contenente l'operatore new, la variabile attrs avrà un riferimento a un array di 12 variabili inizializzate su null.Gli oggetti Attr in quanto tali verranno creati solo durante il ciclo.

Un array può essere inizializzato (contemporaneamente alla dichiarazione) mediante una costruzione tra parentesi graffe, che elenca i Valori iniziali dei suoi elementi:

Pericoli di stringa = ("Leoni", "Tigri", "Orsi");

Il seguente frammento di codice darà lo stesso risultato:

Pericoli di stringa = nuova stringa; pericoli = "Leoni";

pericoli = "Tigri";

pericoli = "Orsi";

Il primo modulo, che prevede di specificare un elenco di inizializzatori tra parentesi graffe, non richiede l'uso esplicito dell'operatore new: viene chiamato indirettamente dal sistema di runtime. La lunghezza dell'array in questo caso è determinata dal numero di valori dell'inizializzatore. È anche possibile impostare in modo esplicito il nuovo operatore, ma la dimensione va comunque omessa, come prima è determinata dal sistema esecutivo:

Pericoli di stringa = new String ("Lions", "Tigers", "Bears" );

Questa forma di dichiarazione e inizializzazione dell'array può essere utilizzata ovunque nel codice, ad esempio in un'espressione di chiamata di metodo:

printStringsCnew String( "uno", "due", "tre" ));

Viene chiamato un array senza nome creato in questo modo anonimo(anonimo).

Gli array di array possono essere inizializzati con sequenze nidificate di valori iniziali. Quello che segue è un esempio di dichiarazione di un array contenente le prime righe del cosiddetto Il triangolo di Pasquale dove ogni riga è descritta dalla propria matrice di valori.

int pascalsTriangolo = (

{ 1, 4, 6, 4, 1 },

Gli indici di array multidimensionali sono in ordine da esterno a interno. Quindi ad esempio pascalsTriangle = " + arr); )

Una versione semplificata del ciclo per l'output di un array è la seguente:

For(int inn: arr) ( System.out.println("arr[" + inn + "] = " + arr); )

Come eliminare un array in Java?

Puoi eliminare un array in Java in questo modo:

Come ottenere la lunghezza di un array in Java?

Otteniamo la lunghezza di un array in Java in questo modo:

int arrLength = lunghezza arr;

Come ottenere il primo elemento di un array in Java?

int primo elemento = arr;

Come ottenere il mezzo ultimo elemento di un array in Java?

int ultimoElem = arr;

Come impostare un array di lunghezza variabile in Java?

Come impostare un array di lunghezza variabile in Java? Non c'è modo. Quando definisci un array, ne imposti la lunghezza, non puoi modificarlo in seguito. In questi casi vengono utilizzate raccolte, ad esempio: Vector, ArrayList, ecc.

Quindi, la lunghezza di un array non può essere variabile. Ma puoi usare una variabile quando definisci un array. Se è così:

int cd;
int ab = new int;//Errore.

quindi otteniamo un errore, la lunghezza di un array non può essere una variabile.

Devi impostare il valore di cd:

int cd = 10;
int ab = nuovo int;

Ora va bene. Se, dopo aver definito l'array, la variabile cd viene modificata, ciò non influirà sull'array, ad es. la sua lunghezza non cambierà. Esempio:

int cd = 10; int ab = nuovo int; cd = 12;// Questo è possibile arrLength = ab.length; System.out.println("ab array length = " + arrLength); //Uscite: ab lunghezza dell'array = 10 ab=4;// Ed ecco l'errore

Otteniamo un errore:

Eccezione nel thread "main" java.lang.ArrayIndexOutOfBoundsException: 11

L'indice massimo del nostro array è 9. La modifica del valore della variabile cd non ha effetto sull'array, perché è già definito e la sua lunghezza è una costante.

Le variabili possono essere utilizzate per accedere agli elementi dell'array:

int var = 1;
int elem = arr;
var = 2;
elem = arr;

Matrice di caratteri in Java

Un esempio di un array di caratteri in Java e il suo output:

Char charArr = ("S", "B", "P"); for(int locanda = 0; locanda< charArr.length; inn++) { System.out.println("charArr[" + inn + "] = " + charArr); }

Come popolare un array in Java?

Un array può essere riempito usando il metodo di riempimento statico.

Vettore (Matrice inglese)è un oggetto che memorizza un numero fisso di valori dello stesso tipo. In altre parole, un array è una raccolta numerata di variabili. Viene chiamata la variabile nell'array elemento dell'array, e la sua posizione nell'array è data da indice. Ad esempio, abbiamo bisogno di memorizzare 50 nomi diversi, vedi, è scomodo creare una variabile separata per ogni nome, quindi useremo un array. La numerazione degli elementi dell'array parte da 0 e la lunghezza dell'array viene impostata al momento della sua creazione ed è fissa.

Per chiarezza, la foto da cui ho scattato Il tutorial Java.

Per creare un array, è necessario dichiararlo, riservare memoria per esso e inizializzarlo.

Dichiarazione di array in Java

Quando si crea un array in Java, il primo passo è dichiararlo. Questo può essere fatto in questo modo:

Int myFirstArray;

Puoi anche dichiarare un array come questo:

int mySecondArray;

Tuttavia, questo non è accolto favorevolmente dalla convenzione di codifica Java, perché le parentesi indicano che abbiamo a che fare con un array e hanno più senso quando sono accanto alla designazione del tipo.

Sulla base di questo esempio, abbiamo dichiarato 2 array denominati myFirstArray e mioSecondArray. Entrambi gli array conterranno elementi di tipo int.

Allo stesso modo, puoi dichiarare un array di qualsiasi tipo:

Byte anArrayOfBytes; breve anArrayOfShorts; long anArrayOfLongs; float anArrayOfFloats; double anArrayOfDoubles; boolean anArrayOfBooleans; char anArrayOfChars; String anArrayOfStrings; ...

Il tipo di un array è dato dal tipo, dove type è il tipo di dati degli elementi che contiene. Le parentesi sono un'indicazione speciale che le variabili sono contenute in un array. Il nome dell'array può essere qualsiasi cosa, tuttavia deve corrispondere a .

Gli array possono essere creati non solo da variabili di tipo base, ma anche da oggetti arbitrari.

Quando un array viene dichiarato nel linguaggio Java, la sua dimensione non viene specificata e non gli viene riservata memoria. Crea solo un riferimento all'array.

Prenotazione di memoria per un array e sua inizializzazione.

Int myFirstArray; myFirstArray = nuovo int;

Nel nostro esempio, abbiamo creato una matrice di 15 elementi di tipo int e assegnato a una variabile dichiarata in precedenza myFirstArray.

Puoi anche dichiarare un nome di array e riservare memoria per esso sulla stessa riga.

int myArray = nuovo int;

Quando si crea un array utilizzando la parola chiave nuovo, tutti gli elementi dell'array vengono inizializzati automaticamente su valori zero. Per assegnare agli elementi di un array i loro valori iniziali, è necessario eseguirlo inizializzazione. L'inizializzazione può essere eseguita elemento per elemento

MyFirstArray = 10; // inizializzazione del primo elemento myFirstArray = 20; // inizializzazione del secondo elemento myFirstArray = 30; // eccetera.

e in un ciclo, usando l'indice, esaminando tutti gli elementi dell'array e assegnando loro valori.

For(int io = 0; io< 15; i++){ myFirstArray[i] = 10; }

Come puoi vedere dagli esempi precedenti, per fare riferimento ad un elemento di un array, devi specificarne il nome e, quindi, tra parentesi quadre, l'indice dell'elemento. Un elemento dell'array in corrispondenza di un indice specifico si comporta come una variabile.

Considera la creazione e l'inizializzazione di un array usando l'esempio seguente. In esso creiamo un array contenente i numeri 0-9 e stampiamo i valori sulla console.

//creazione e inizializzazione dell'array int numberArray = new int; for(int io = 0; io< 10; i++){ numberArray[i] = i; } //вывод значений на консоль for(int i = 0; i < 10; i++){ System.out.println((i+1) + "-й элемент массива = " + numberArray[i]); }

Notazione semplificata

Puoi anche usare la notazione semplificata per creare e inizializzare una matrice. Non contiene la parola nuovo e i valori iniziali dell'array sono elencati tra parentesi.

int myColor = (255, 255, 0);

Qui, la lunghezza dell'array è determinata dal numero di valori tra parentesi, separati da virgole. Questa notazione è più adatta per creare piccoli array.

Determinazione della dimensione di un array

La dimensione di un array non è sempre ovvia, quindi per scoprirlo, usa la proprietà length, che restituisce la lunghezza dell'array.

MyColor.length;

Questo codice ci aiuterà a sapere che la lunghezza dell'array myColor è 3.

Esempio: dati 4 numeri, devi trovare il minimo

numeri int = (-9, 6, 0, -59); int min = numeri; for(int io = 0; io< numbers.length; i++){ if(min>numeri[i]) min = numeri[i]; ) System.out.println(min);

Esercizi su array unidimensionali in Java:

1. Crea un array contenente i primi 10 numeri dispari. Stampa gli elementi dell'array sulla console in una riga, separati da una virgola.
2. Dato un array di dimensione N, trova l'elemento più piccolo dell'array e stampa sulla console (se sono presenti diversi elementi più piccoli, stampali tutti).
3. Nella matrice dell'attività 2. trova l'elemento più grande.
4. Scambia gli elementi più grandi e più piccoli di un array. Esempio: dato un array (4, -5, 0, 6, 8). Dopo la sostituzione apparirà come (4, 8, 0, 6, -5).
5. Trova la media aritmetica di tutti gli elementi dell'array.

Ultimo aggiornamento: 09.11.2018

Un array rappresenta un insieme di valori dello stesso tipo. Dichiarare un array è come dichiarare una variabile ordinaria che memorizza un singolo valore e ci sono due modi per dichiarare un array:

tipo_dati nome_array; // o tipo_dati nome_array;

Ad esempio, definiamo una matrice di numeri:

numeri int; int numeri2;

Dopo aver dichiarato un array, possiamo inizializzarlo:

numeri int; numeri = nuovo int; // array di 4 numeri

Viene creata una matrice utilizzando il seguente costrutto: new data_type[number_of_elements] , dove new è una parola chiave che alloca memoria per il numero di elementi specificato tra parentesi. Ad esempio, nums = new int; - questa espressione crea un array di quattro elementi int e ogni elemento avrà un valore predefinito: il numero 0.

Puoi anche inizializzare immediatamente un array quando lo dichiari:

int numeri = nuovo int; // array di 4 numeri int nums2 = new int; // array di 5 numeri

Con questa inizializzazione, tutti gli elementi dell'array hanno un valore predefinito. Per i tipi numerici (incluso il tipo char) questo è il numero 0, per il tipo booleano è false e per altri oggetti è null . Ad esempio, per il tipo int, il valore predefinito è il numero 0, quindi la matrice nums definita sopra sarà composta da quattro zeri.

Tuttavia, è anche possibile impostare valori specifici per gli elementi di un array quando viene creato:

// questi due modi sono equivalenti int nums = new int ( 1, 2, 3, 5 ); int nums2 = ( 1, 2, 3, 5 );

Vale la pena notare che in questo caso la dimensione dell'array non è indicata tra parentesi quadre, poiché è calcolata dal numero di elementi tra parentesi graffe.

Dopo aver creato un array, possiamo fare riferimento a uno qualsiasi dei suoi elementi per indice, che viene passato tra parentesi quadre dopo il nome della variabile dell'array:

int numeri = nuovo int; // imposta i valori degli elementi dell'array nums = 1; numeri = 2; numeri = 4; numeri = 100; // ottiene il valore del terzo elemento dell'array System.out.println(nums); // 4

L'indicizzazione degli elementi dell'array inizia da 0, quindi in questo caso, per fare riferimento al quarto elemento dell'array, è necessario utilizzare l'espressione nums.

E poiché il nostro array è definito solo per 4 elementi, non possiamo fare riferimento, ad esempio, al sesto elemento: nums = 5; . Se proviamo a farlo, riceveremo un errore.

Lunghezza della matrice

La proprietà più importante degli array è la proprietà length, che restituisce la lunghezza dell'array, ovvero il numero dei suoi elementi:

numeri int = (1, 2, 3, 4, 5); lunghezza int = lunghezza num; // cinque

Non è raro che l'ultimo indice sia sconosciuto e per ottenere l'ultimo elemento di un array possiamo usare questa proprietà:

int last = numeri;

Matrici multidimensionali

In precedenza, abbiamo considerato gli array unidimensionali, che possono essere rappresentati come una catena o una stringa di valori dello stesso tipo. Ma oltre agli array unidimensionali, ce ne sono anche di multidimensionali. L'array multidimensionale più noto è una tabella che rappresenta un array bidimensionale:

int nums1 = nuovo int ( 0, 1, 2, 3, 4, 5 ); int nums2 = ( ( 0, 1, 2 ), ( 3, 4, 5 ) );

Visivamente, entrambi gli array possono essere rappresentati come segue:

Matrice unidimensionale nums1

Matrice bidimensionale nums2

Poiché l'array nums2 è bidimensionale, è una semplice tabella. Potrebbe anche essere creato in questo modo: int nums2 = new int; . Il numero di parentesi quadre indica la dimensione della matrice. E i numeri tra parentesi: il numero di righe e colonne. Inoltre, usando gli indici, possiamo usare gli elementi dell'array nel programma:

// imposta l'elemento della prima colonna della seconda riga nums2=44; System.out.println(nums2);

Una dichiarazione di array tridimensionale potrebbe essere simile a questa:

int nums3 = nuovo int;

matrice frastagliata

Gli array multidimensionali possono anche essere rappresentati come "array frastagliati". Nell'esempio sopra, l'array 2D aveva 3 righe e 3 colonne, quindi abbiamo finito con una tabella piatta. Ma possiamo assegnare a ogni elemento in un array bidimensionale un array separato con un diverso numero di elementi:

int numeri = nuovo int; numeri = nuovo int; numeri = nuovo int; numeri = nuovo int;

per ciascuno

Una versione speciale del ciclo for è progettata per scorrere gli elementi in insiemi di elementi, come matrici e raccolte. È simile al ciclo foreach che si trova in altri linguaggi di programmazione. Dichiarazione formale:

Per (tipo di dati nome_variabile: contenitore)( // azioni )

Per esempio:

matrice int = new int ( 1, 2, 3, 4, 5 ); for (int i: array)( System.out.println(i); )

Il contenitore in questo caso è una matrice di dati di tipo int . Quindi viene dichiarata una variabile con tipo int

Lo stesso potrebbe essere fatto con la versione normale di for:

matrice int = new int ( 1, 2, 3, 4, 5 ); per (int i = 0; i< array.length; i++){ System.out.println(array[i]); }

Allo stesso tempo, questa versione del ciclo for è più flessibile di for (int i: array) . In particolare, in questa versione possiamo modificare elementi:

matrice int = new int ( 1, 2, 3, 4, 5 ); per (int i=0; i

Iterazione su array multidimensionali in un ciclo

Innanzitutto, viene creato un ciclo per scorrere le righe, quindi all'interno del primo ciclo viene creato un ciclo interno per scorrere le colonne di una determinata riga. Allo stesso modo, è possibile eseguire l'iterazione su matrici e insiemi tridimensionali con un numero elevato di dimensioni.