Libreria per lavorare con gli array java. Array multidimensionali e asimmetrici

Giava,

Algoritmi

• Tutorial

Penso che poche persone che si preparano per il loro primo colloquio, quando assumono per il loro primo lavoro come programmatore (pre)junior, risponderanno a questa domanda in modo negativo. O almeno dubitare della risposta positiva. Naturalmente, una struttura dati così semplice con accesso diretto all'indice - nessun problema! No, in alcuni linguaggi come JavaScript o PHP gli array sono, ovviamente, implementati in modo molto interessante e in effetti sono molto più di un semplice array. Ma non stiamo parlando di questo, ma dell'implementazione "tradizionale" di array sotto forma di un "pezzo di memoria continuo". In questo caso, in base agli indici e alla dimensione di un elemento, si calcola semplicemente l'indirizzo e si accede al valore corrispondente. Cosa c'è di così difficile?
Scopriamolo. Ad esempio, in Java. Chiedere a un richiedente ignaro di creare una matrice di numeri interi n X n... La persona scrive con sicurezza qualcosa nello spirito:
int g = nuovo int [n] [n];
Bene. Ora ti chiediamo di inizializzare gli elementi dell'array con qualcosa. Almeno in unità, almeno nella somma degli indici. Noi abbiamo:
per (int i = 0; i< n; i++) { for(int j = 0; j < n; j++) { g[i][j] = i + j; } }
Ancora più spesso scrivono
per (int i = 0; i< g.length; i++) { for(int j = 0; j < g[i].length; j++) { g[i][j] = i + j; } }
che è anche motivo di conversazione, ma ora si parla d'altro. Stiamo cercando di capire cosa sa una persona e vedere come la pensa. Pertanto, attiriamo la sua attenzione sul fatto che i valori sono disposti simmetricamente e gli chiediamo di risparmiare sulle iterazioni dei loop. Certo, perché passare attraverso tutti gli indici quando puoi passare solo attraverso il triangolo in basso? Il soggetto di solito concorda facilmente e identifica saggiamente la diagonale principale e scrive faticosamente qualcosa del genere:
per (int i = 0; i< n; i++) { g[i][i] = 2* i; for(int j = 0; j < i; j++) { g[j][i] = g[i][j] = i + j; } }
Invece di g [i] [i] = 2 * i; spesso scrivono g [i] [i] = i + i; oppure g [i] [i] = i<< 1; и это тоже повод поговорить. Но мы идем дальше и задаем ключевой вопрос: Quanto più veloce verrà eseguito il programma?... Il solito ragionamento è il seguente: quasi 2 volte meno calcoli dell'indice; quasi 2 volte meno calcoli di valore (somma); lo stesso numero di incarichi. Questo significa il 30 percento più veloce.Se una persona ha alle spalle una buona scuola di matematica, allora puoi persino vedere il numero esatto di operazioni salvate e una stima più ragionata dell'efficienza dell'ottimizzazione.
Ora è il momento del colpo principale. Esegui entrambe le versioni del codice con un valore abbastanza grande n(dell'ordine di diverse migliaia), per esempio, così.

Codice a tempo

class A (public static void main (String args) (int n = 8000; int g = new int [n] [n]; long st, en; // one st = System.nanoTime (); for (int i = 0; io< n; i++) { for(int j = 0; j < n; j++) { g[i][j] = i + j; } } en = System.nanoTime(); System.out.println("\nOne time " + (en - st)/1000000.d + " msc"); // two st = System.nanoTime(); for(int i = 0; i < n; i++) { g[i][i] = i + i; for(int j = 0; j < i; j++) { g[j][i] = g[i][j] = i + j; } } en = System.nanoTime(); System.out.println("\nTwo time " + (en - st)/1000000.d + " msc"); } }

Cosa vediamo? La versione ottimizzata funziona 10-100 volte più lentamente! Ora è il momento di osservare la reazione del candidato al lavoro. Quale sarà la reazione a una situazione stressante insolita (più precisamente, la consueta nella pratica dello sviluppatore). Se il viso del cliente ha mostrato eccitazione e ha iniziato a premere i pulsanti, dimenticando temporaneamente la tua esistenza, allora questo è un buon segno. In una certa misura. Non vorrai assumere un ricercatore a cui non interessa l'esito del progetto, vero? Allora non fargli la domanda "Perché?" Chiedi che la seconda opzione venga ridisegnata in modo che funzioni effettivamente più velocemente della prima.
Ora puoi tranquillamente fare i tuoi affari per un po'. In mezz'ora avrai materiale sufficiente per valutare le principali qualità personali e professionali del candidato.
A proposito, quando ho descritto brevemente questo problema sul mio sito di lavoro, il commento più popolare è stato "Questa è la tua curva Java". Soprattutto per loro posto il codice su Great and Free. E i felici possessori di Free Pascal per Windows possono guardare

sotto lo spoiler

programma Ora; usa Windows; var inizio, fine, res: int64; n, i, j: numero intero; g: array di array di interi; inizio n: = 10000; Imposta lunghezza (g, n, n); QueryPerformanceFrequency (res); QueryPerformanceCounter (inizio); for i: = da 1 a n-1 do for j: = da 1 a n-1 do g: = i + j; QueryPerformanceCounter (fine); writeln ("Tempo per righe:", (fine - inizio) / res, "sec"); QueryPerformanceCounter (inizio); for i: = da 1 a n-1 do for j: = da 1 a n-1 do g: = i + j; QueryPerformanceCounter (fine); writeln ("Time by cols:", (fine - start) / res, "sec"); fine.

Nel codice sopra in Pascal, ho rimosso i momenti "confusi" e ho lasciato solo l'essenza del problema. Se può essere chiamato un problema.
Quali domande riceviamo di conseguenza per il nostro cliente?
1. Perché è diventato più lento? E maggiori dettagli...
2. Come velocizzare l'inizializzazione?

Se è necessario approfondire l'implementazione di Java, chiediamo al richiedente di osservare il tempo di esecuzione per i valori piccoli. n... Ad esempio, su ideone.com per n = 117, la versione "ottimizzata" funziona due volte più lentamente. Ma per il prossimo valore n = 118 risulta essere 100 (cento) volte più veloce di quello non ottimizzato! Suggerisci di sperimentare sul tuo computer locale. Lascialo giocare con le impostazioni.
A proposito, tutti capiscono cosa sta succedendo?

Qualche parola di scusa

Voglio dire alcune parole per giustificare questo modo di assumere interviste. Sì, non verifico la conoscenza della sintassi del linguaggio e la conoscenza delle strutture dati. Forse, con un mercato del lavoro civile, tutto questo funziona. Ma nelle nostre condizioni di totale carenza di personale qualificato, è necessario valutare piuttosto l'adeguatezza prospettica del candidato al lavoro che dovrà affrontare. Quelli. la capacità di imparare, sfondare, capire, fare.
Nello spirito è simile al "colloquio" per il reclutamento dei legionari nell'antica Roma. Il futuro soldato era molto spaventato e guardò se arrossì o impallidì. Se diventa pallido, in una situazione stressante il sangue del richiedente defluisce dalla testa ed è incline a una reazione passiva. Ad esempio, debole. Se il richiedente arrossisce, il sangue gli scorre alla testa. Quelli. è incline all'azione, gettandosi in una rissa. Questo è stato ritenuto idoneo.
E l'ultima cosa. Perché ho parlato a tutti di questo problema e non ho continuato a usarlo nelle interviste? Semplicemente, questo compito è già stato "imparato" dai potenziali candidati e altri devono usarlo.
In realtà, ho prestato attenzione a questo effetto proprio in relazione al vero compito dell'elaborazione delle immagini. La situazione era un po' confusa e non ho capito subito perché i miei fps sono scesi così tanto dopo il refactoring. In generale, tutti hanno probabilmente accumulato molti di questi momenti meravigliosi.

Finora, la versione in cui la cache del processore è "da biasimare" è in testa. Quelli. l'accesso sequenziale nella prima versione funziona all'interno dell'hash, che viene aggiornato quando si attraversa un determinato confine. Quando si accede per colonne, l'hash deve essere costantemente aggiornato e richiede molto tempo. Diamo un'occhiata a questa versione nella sua forma più pura. Creiamo un array e confrontiamo quale è più veloce: elaborare tutti gli elementi in una riga o elaborare gli elementi dell'array con un numero casuale lo stesso numero di volte? Questo programma è ideone.com/tMaR2S. Per 100.000 elementi dell'array, l'accesso casuale è in genere notevolmente più veloce. Cosa significa questo?
Qui mi è stato giustamente fatto notare (Big_Lebowski) che la permutazione dei loop cambia i risultati a favore della versione sequenziale. Per la purezza dell'esperimento, ho dovuto mettere un ciclo per il riscaldamento. Ho fatto alcune ripetizioni contemporaneamente per ottenere il tempo medio di esecuzione come consigliato da leventov. Si è scoperto così ideone.com/yN1H4g. Quelli. l'accesso casuale agli elementi di un array di grandi dimensioni è circa il 10% più lento dell'accesso sequenziale. Forse, in verità, il denaro può svolgere un ruolo. Tuttavia, nella situazione iniziale, le prestazioni sono diminuite in modo significativo. Quindi c'è qualcos'altro.

A poco a poco, la versione sulle azioni aggiuntive quando ci si sposta da una riga di un array all'altra sta venendo alla ribalta. Ed è giusto. Resta da capire cosa sta succedendo esattamente lì.

tag:

• Programmazione
• array
• memoria

Aggiungi i tag

matrici(array) sono insiemi ordinati di elementi dello stesso tipo. Gli elementi di un array possono essere oggetti di tipo semplice e di riferimento, inclusi i riferimenti ad altri array. Gli array sono essi stessi oggetti e

eredita la classe Object. Annuncio

int ia = nuovo int;

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

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

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

Il primo elemento dell'array ha indice zero (0) e l'ultimo è length - 1. Si accede all'elemento dell'array specificando il nome dell'array e il valore dell'indice, racchiusi tra parentesi quadre, [e]. nell'esempio precedente, ia sarà il primo elemento dell'array e ia sarà l'ultimo. Ogni volta che si accede a un elemento dell'array tramite indice, il sistema runtime Java verifica se il valore dell'indice rientra nei limiti accettabili e genera un'eccezione ArraylndexOutOfBoundsException se il test è falso. 6 L'espressione indice deve essere di tipo int - questa è l'unica cosa che limita il numero massimo di elementi dell'array.

La lunghezza di un array è facile da determinare utilizzando il campo length dell'oggetto array (che è implicitamente public e final). Quello che segue è il codice aumentato dell'esempio precedente, in cui viene eseguito un Loop per visualizzare il contenuto di ciascun elemento nell'array ia:

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

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

Di solito viene chiamato un array di lunghezza zero (cioè uno senza elementi) vuoto. Nota che un riferimento null a un array e un riferimento a un array vuoto sono cose completamente diverse. Un array vuoto è un array reale senza elementi al suo interno. Un array vuoto fornisce 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 chiamato il metodo deve confrontare il valore restituito con null prima di procedere con le operazioni rimanenti. Se il metodo restituisce un array (possibilmente vuoto), non sono necessari ulteriori controlli, ovviamente a parte quelli che riguardano la lunghezza dell'array e vanno comunque eseguiti.

È consentita un'altra forma di dichiarazione di 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 sintassi più vecchia, tuttavia, è considerata preferibile perché la dichiarazione del tipo è quindi 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 oa variabili locali. C'è una cosa che è importante ricordare: i modificatori vengono applicati all'array in quanto tale, ma non ai suoi singoli elementi. Se nella dichiarazione dell'array è specificato il flag finale, ciò significa solo che il riferimento all'array non può essere modificato dopo la sua creazione, 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 yolatile) 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 per dichiarare una matrice bidimensionale e visualizzare 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] + "");

sistema.out.println ();

Quando si crea un array, è necessario specificare almeno la sua prima dimensione "più a sinistra". È consentito non specificare altre dimensioni: in questo caso, dovranno essere determinate in seguito. Specificare tutte le dimensioni contemporaneamente nel nuovo operatore è il modo più conciso per creare un array, evitando la necessità di utilizzare nuovi operatori aggiuntivi. L'espressione sopra per dichiarare e creare un array mat è equivalente 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 a ottenere array con le stesse dimensioni (diciamo 4 x 4), di costruire array di array di dimensioni diverse necessarie per memorizzare determinate sequenze di dati.

Inizializzazione degli array

Quando viene creato un array, a ciascun elemento viene assegnato un valore predefinito a seconda del tipo di array: zero (0) per i tipi numerici, '\ u0000 ′ _ per char, false per boolean e null per i tipi di riferimento. Dichiarando un array di un tipo di riferimento, in realtà stiamo definendo un array n variabile di questo tipo. Considera il seguente pezzo di codice:

Attr attr = nuovo Attr;

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

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

Dopo aver eseguito la prima espressione contenente l'operatore new, la variabile attrs riceverà un riferimento a un array di 12 variabili inizializzate a null, gli oggetti Attr in quanto tali verranno creati solo durante il ciclo.

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

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

Il seguente frammento di codice darà lo stesso risultato:

Pericoli delle stringhe = nuova stringa; pericoli = "Leoni";

pericoli = "Tigri";

pericoli = "Orsi";

La prima forma, che implica la specifica di un elenco di inizializzatori tra parentesi graffe, non richiede l'uso esplicito dell'operatore new: viene chiamato indirettamente dal sistema di runtime. La lunghezza della matrice in questo caso è determinata dal Numero di valori dell'inizializzatore. È consentita anche la possibilità di specificare esplicitamente il nuovo operatore, ma la dimensione dovrebbe comunque essere omessa, come prima, è determinata dal sistema runtime:

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

Questa forma di dichiarazione e inizializzazione di un array può essere utilizzata ovunque nel codice, ad esempio in un'espressione di chiamata al 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 originali. Di seguito è riportato un esempio di dichiarazione di un array contenente le prime righe del cosiddetto triangolo di Pascal, dove ogni riga è descritta dal proprio array di valori.

int pascalsTriangolo = (

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

Gli indici di array multidimensionali sono ordinati da esterno a interno. Quindi, ad esempio, pascalsTriangle);

// Un esempio per illustrare la creazione di un array
// interi, inserisce alcuni valori in un array,
// e stampa ogni valore.

classe GFG
{

{

int arr;

// allocazione della memoria per 5 interi.
arr = nuovo int;

arr = 10;

arr = 20;

// presto ...
arr = 30;
arr = 40;
arr = 50;

// accedere agli elementi dell'array specificato
per (int i = 0; i< arr.length; i++)
System.out.println ("Elemento all'indice" + i +
":" + arr [i]);
}
}
Di conseguenza, otteniamo:

Elemento all'indice 0: 10 Elemento all'indice 1: 20 Elemento all'indice 2: 30 Elemento all'indice 3: 40 Elemento all'indice 4: 50

Matrici di oggetti

Un array di oggetti viene creato allo stesso modo degli elementi di dati, come segue:

Arr studente = nuovo Studente;

StudentArray contiene sette elementi di memoria ciascuno della classe Studente, in cui possono essere memorizzati gli indirizzi dei sette oggetti Studente. Gli oggetti studente devono essere creati utilizzando il costruttore della classe studente e i loro riferimenti devono essere assegnati agli elementi dell'array come segue:

Arr studente = nuovo Studente;

// Programma Java per illustrare la creazione di un array di
// oggetti

classe studente
{
public int roll_no;
nome stringa pubblico;
Studente (int roll_no, nome stringa)
{
this.roll_no = roll_no;
this.name = nome;
}
}

// Gli elementi dell'array sono oggetti di una classe Student.
classe pubblica GFG
{
public static void main (Stringa args)
{
// dichiara un array di interi.
Arr studente;

// allocazione della memoria per 5 oggetti di tipo Student.
arr = nuovo Studente;

// inizializza i primi elementi dell'array
arr = nuovo Studente (1, "aman");

// inizializza i secondi elementi dell'array
arr = nuovo Studente (2, "vaibhav");

// presto ...
arr = nuovo Studente (3, "shikar");
arr = nuovo Studente (4, "dharmes");
arr = nuovo Studente (5, "mohit");

// accedere agli elementi dell'array specificato
per (int i = 0; i< arr.length; i++)
System.out.println ("Elemento in" + i + ":" +
arr [i] .roll_no + "" + arr [i] .name);
}
}

Noi abbiamo:

Elemento a 0: 1 aman Elemento a 1: 2 vaibhav Elemento a 2: 3 shikar Elemento a 3: 4 dharmesh Elemento a 4: 5 mohit

Cosa succede se proviamo ad accedere a un elemento esterno all'array?
Il compilatore genera un'eccezione ArrayIndexOutOfBoundsException, che indica che è stato eseguito l'accesso all'array in corrispondenza di un indice non valido. L'indice è negativo o maggiore o uguale alla dimensione dell'array.

Multidimensionale

Gli array multidimensionali sono array di array, ogni elemento dei quali contiene un riferimento a un altro array. Creato aggiungendo un set di parentesi quadre () per ogni dimensione. Consideriamo un esempio:

Int intArray = nuovo int; // un array o una matrice 2D int intArray = new int; // un array 3D

classe multidimensionale
{
public static void main (Stringa args)
{
// dichiarazione e inizializzazione dell'array 2D
int arr = ((2,7,9), (3,6,1), (7,4,2));

// stampa array 2D
per (int i = 0; i< 3 ; i++)
{
per (int j = 0; j< 3 ; j++)
System.out.print (arr [i] [j] + "");

System.out.println ();
}
}
}

Uscita: 2 7 9 3 6 1 7 4 2

Passaggio di array a un metodo

Come le variabili, possiamo passare gli array ai metodi.

// Programma Java per dimostrare // passaggio dell'array alla classe del metodo Test (// Metodo driver public static void main (String args) (int arr = (3, 1, 2, 5, 4); // passaggio dell'array al metodo m1 sum (arr);) public static void sum (int arr) (// ottenendo la somma dei valori dell'array int sum = 0; for (int i = 0; i< arr.length; i++) sum+=arr[i]; System.out.println("sum of array values: " + sum); } }

In uscita otteniamo:

somma dei valori dell'array: 15

Restituzione di array dai metodi

Come al solito, il metodo può anche restituire un array. Ad esempio, il programma seguente restituisce un array dal metodo m1.

// Programma Java per dimostrare // ritorno dell'array dalla classe del metodo Test (// Metodo driver public static void main (String args) (int arr = m1 (); for (int i = 0; i< arr.length; i++) System.out.print(arr[i]+" "); } public static int m1() { // returning array return new int{1,2,3}; } }

Oggetti di classe

Ogni array ha un oggetto classe associato che è condiviso con tutti gli altri array con lo stesso tipo di componente.

// Programma Java per dimostrare // Class Objects for Arrays class Test (public static void main (String args) (int intArray = new int; byte byteArray = new byte; short shortsArray = new short; // array di stringhe String strArray = new String; System.out.println (intArray.getClass ()); System.out.println (intArray.getClass (). getSuperclass ()); System.out.println (byteArray.getClass ()); System.out. println (shortsArray.getClass ()); System.out.println (strArray.getClass ());))

classe + ""); )))

Un clone di un array multidimensionale (come Object) è una copia, il che significa che crea solo un nuovo array con ogni elemento e un riferimento all'array originale di elementi, ma gli array nidificati sono comuni.

// Programma Java per dimostrare // clonazione di array multidimensionali class Test (public static void main (String args) (int intArray = ((1,2,3), (4,5)); int cloneArray = intArray. clone (); // stamperà false System.out.println (intArray == cloneArray); // stamperà true quando viene creata una copia superficiale // cioè i sotto-array sono condivisi System.out.println (intArray == cloneArray) ; System.out.println (intArray == cloneArray);))

Array è un potente strumento per gestire grandi quantità di dati. Ovviamente, se devi salvare, ad esempio, 100 valori da qualche parte nel processo del tuo codice, allora è almeno irragionevole creare lo stesso numero di variabili per questo. Un array ti consente di memorizzare un gran numero di valori sotto un nome e di accedervi nell'indice appropriato. Gli array sono la pietra angolare dell'apprendimento di Java per i principianti. Dopotutto, sono la base per molte strutture di dati.

Poiché Java è principalmente OOP, rispetto agli array in altri linguaggi di programmazione, ha una caratteristica distintiva: sono rappresentati come oggetti. Tra gli altri vantaggi, questo elimina la necessità di tenere traccia della pulizia della memoria, poiché viene liberata automaticamente.

Creazione e manipolazione di array unidimensionali

Un array unidimensionale è classico ed è una raccolta di elementi correlati da un nome comune, ognuno dei quali ha un indice specifico. Il modo per dichiarare un array è mostrato nella figura seguente.

Innanzitutto, viene dichiarato il tipo di array Java, che definisce il tipo di valori in esso memorizzati. Può essere qualsiasi valido.Segue il nome dell'array e le parentesi quadre per dire al compilatore che la variabile è un array. Presta attenzione a un fatto importante. può essere posizionato sia dopo il tipo base dell'array, sia dopo il nome dell'array. Dopo il segno di uguale viene indicato l'operatore new, che avvia l'allocazione della memoria per l'array (come nel caso degli oggetti), il tipo di elementi che verranno memorizzati in esso (deve essere compatibile con il tipo base dichiarato in precedenza) , e, infine, il loro numero indicato tra parentesi quadre.

La numerazione degli elementi nell'array Java inizia da 0. Quindi, l'indice del primo elemento in questo array sarà uguale a 0 e il sesto - 5. Per fare riferimento a un elemento specifico dell'array, ad esempio il quinto, è sufficiente specificare il nome dell'array e l'indice dell'elemento tra parentesi quadre accanto al nome... Pertanto, puoi sia assegnare un valore a un elemento che recuperarlo. Tuttavia, dovresti stare attento, perché se passi l'indice in cui l'elemento non esiste, si verificherà un errore.

Array multidimensionali in Java Baeldung

Gli array multidimensionali sono una serie di array unidimensionali a cui fanno riferimento gli elementi di altri array. In altre parole, i più semplici tra loro sono bidimensionali. Usando il loro esempio, cercheremo di capire il concetto. Per chiarezza, la figura seguente mostra la sintassi e il diagramma che descrivono la struttura di un array bidimensionale.

Come puoi vedere, la sintassi non è molto diversa dagli array unidimensionali. Diamo un'occhiata alla struttura. Nelle prime parentesi abbiamo assegnato lo spazio per 5 elementi. Questi elementi non sono altro che riferimenti a singoli array. Inoltre, la dimensione di ciascuno di essi è determinata dal numero nelle seconde parentesi. In effetti, le matrici sono analoghe agli array bidimensionali in matematica. Si noti che oltre agli elementi, viene allocata una posizione separata in memoria in cui è memorizzato il valore della lunghezza dell'array. Di norma, il lavoro con array multidimensionali viene eseguito tramite cicli for annidati.

Array irregolari

Un array bidimensionale è un array di array. Lo abbiamo già scoperto. Ma gli array che contiene possono avere lunghezze diverse? La risposta è sì, possono. Per fare ciò, Java offre la possibilità di dichiarare un array bidimensionale in un modo speciale. Ad esempio, vogliamo creare un array bidimensionale che contenga tre array unidimensionali di lunghezze 2, 3 e 4, rispettivamente. Si dichiara quanto segue:

intarr = newint;

Si prega di notare che non abbiamo incluso il numero nella seconda parentesi. La determinazione della dimensione degli array in arr viene eseguita in questo modo:

Facendo riferimento all'elemento con indice 0, che punta al primo array, lo dichiariamo con dimensione 2. Un array con dimensione 3 verrà memorizzato sotto l'elemento con indice 1 e così via. È piuttosto semplice.

Sintassi alternativa per la dichiarazione dell'array Java

Gli array possono essere inizializzati direttamente al momento della creazione. È abbastanza semplice.

Notare la dichiarazione degli array jerseyNumber e playerName.

Nel caso di array bidimensionali, questa dichiarazione ha il seguente aspetto:

Per fare ciò, al posto dell'operatore new, vengono aperte le parentesi graffe, in cui tutti gli elementi sono enumerati separati da virgole. Java in questo caso allocherà automaticamente la memoria per loro e li indicizzerà di conseguenza.

Classe di supporto per gli array

Per lavorare con entità come gli array in Java, il pacchetto java.util fornisce una classe speciale chiamata Arrays che fornisce molti metodi statici che rendono molto più semplice la loro manipolazione. L'elenco dei metodi di base è mostrato nella figura seguente.

Diamo un'occhiata ad alcuni dei metodi di array Java più utili:

CopyOf (array, length) - restituisce una copia dell'array passato della lunghezza corrispondente. Se la lunghezza passata è maggiore dell'array originale, tutti gli elementi "extra" vengono riempiti con un valore predefinito (0, se un tipo semplice e null, se un tipo di riferimento).

CopyOfRange (array, primo indice, ultimo indice) - Non mostrato nell'immagine, ma metodo utile. Copia la porzione dell'array passato specificata dagli indici corrispondenti, iniziando dal primo e finendo con l'ultimo.

Ordina (array) - Ordina gli elementi di un array in ordine crescente.

Fill (array, value) - riempie l'array passato con il valore corrispondente.

BinarySearch (array, value) - Restituisce l'indice in corrispondenza del quale l'elemento con il valore corrispondente si trova nell'array ordinato passato. Se non esiste tale elemento, viene restituito un numero negativo.

Poiché i metodi sono statici, non è necessario creare un'istanza della classe Arrays per chiamarli. Vengono chiamati direttamente da esso: Arrays.sort (arr).

Conclusione

Abbiamo coperto gli aspetti più importanti degli array e, per coloro che stanno appena iniziando a imparare Java per principianti, questo è sufficiente per una comprensione di base di un'entità come un array e le tecniche di base per lavorarci. Naturalmente, la pratica ti darà una maggiore comprensione di come funziona questo strumento. Quindi non essere pigro per fare alcuni esercizi, manipolando gli array in modi diversi.

La classe helper Array Java è già utilizzata in condizioni di "combattimento", quindi si consiglia di iniziare imparando a eseguire manualmente tutte le operazioni di base con gli array.

Abbiamo imparato a creare array unidimensionali. Allo stesso modo, in Java, puoi creare 2D, 3D, 4D ... in altre parole, array multidimensionali. Un array multidimensionale in Java è essenzialmente un array di array.

Un esempio popolare dell'utilizzo di questo tipo di array sono le matrici, che sono rappresentate utilizzando array bidimensionali. Quindi cos'è esattamente una matrice e come rappresentarla con un array bidimensionale in Java.

Matrici e array 2D in Java Baeldung

Una matrice è una tabella rettangolare composta da righe e colonne all'intersezione della quale si trovano i suoi elementi. Il numero di righe e colonne della matrice determina la sua dimensione.

Vista generale della dimensione della matrice m X n(m - numero di righe, n - numero di colonne) , come segue:

Ogni elemento della matrice ha il proprio indice, dove la prima cifra indica il numero di riga su cui si trova l'elemento e la seconda indica il numero di colonna.

Diamo un'occhiata a esempi di matrici specifiche e creiamole usando Java.

Matrice UN ha una dimensione di 2 per 3 (2 righe, 3 colonne). Creiamo un array bidimensionale di questa dimensione:

Int matriceA; matriceA = nuovo int;

Abbiamo dichiarato un array bidimensionale di interi (poiché la matrice in questo caso contiene interi) e la memoria riservata per esso. Per questo abbiamo utilizzato 2 indici: il primo indice definisce la riga e la sua dimensione, il secondo indice definisce la colonna e la sua dimensione.

Per accedere agli elementi di un array bidimensionale è necessario utilizzare 2 indici: il primo per la riga, il secondo per la colonna. Come con gli array unidimensionali, anche gli indici iniziano da zero. Pertanto, la numerazione di righe e colonne nella tabella inizia da 0.

MatriceA = 1; matriceA = -2; matriceA = 3; matriceA = 4; matriceA = 1; matriceA = 7;

Per inviare la matrice alla console, è necessario passare attraverso tutti gli elementi utilizzando due loop. Il numero di cicli, quando passa attraverso gli elementi dell'array, è uguale alla sua dimensione. Nel nostro caso, il primo ciclo viene eseguito per righe, il secondo per colonne.

Per (int i = 0; i< 2; i++) { for (int j = 0; j < 3; j++) { System.out.print(matrixA[i][j] + "\t"); } System.out.println(); }

Cioè, prima mostriamo tutti gli elementi della prima riga, separandoli con il carattere di tabulazione "\ t", avvolgiamo la riga e visualizziamo tutti gli elementi della seconda riga.

Completamente il codice per la matrice UN come segue:

Classe pubblica Matrix (public static void main (String args) (int matriceA; matriceA = new int; matriceA = 1; matriceA = -2; matriceA = 3; matriceA = 4; matriceA = 1; matriceA = 7; for (int i = 0; i< 2; i++) { for (int j = 0; j < 3; j++) { System.out.print(matrixA[i][j] + "\t"); } System.out.println(); } } }

Per matrice B uso modo semplificato di inizializzazione- al momento dell'annuncio. Per analogia con gli array unidimensionali.

Int matriceB = ((-9,1,0), (4,1,1), (-2,2, -1));

Ogni riga dell'array deve essere racchiusa tra parentesi graffe e separata l'una dall'altra da una virgola.

Completamente il codice per la matrice B:

Classe pubblica Matrix (public static void main (String args) (int matrixB = ((-9,1,0), (4,1,1), (-2,2, -1)); for (int i = 0; io< 3; i++) { for (int j = 0; j < 3; j++) { System.out.print(matrixB[i][j] + "\t"); } System.out.println(); } } }

Tenere conto inizializzazione in un ciclo per una matrice bidimensionale utilizzando la tabella di moltiplicazione come esempio.

Classe pubblica Mult (public static void main (String args) (// crea un array bidimensionale 10 per 10 int multiplyTab = new int; // loop nella prima dimensione for (int i = 0; i< 10; i++) { // цикл по второй размерности for (int j = 0; j < 10; j++) { //инициализация элементов массива multiplyTab[i][j] = (i+1)*(j+1); //вывод элементов массива System.out.print(multiplyTab[i][j] + "\t"); } System.out.println(); } } }

Qui, l'inizializzazione degli elementi con i valori della tabella di moltiplicazione è combinata con il loro output sulla console in un ciclo.

Matrici multidimensionali e asimmetriche.

Gli array multidimensionali vengono creati in Java in modo simile. Il numero di parentesi quadre indica la dimensione.
Esempi di creazione di array di lunghezza fissa:

Int a = new int; // array bidimensionale int b = new int; // array tridimensionale int c = new int; // array quadridimensionale // ecc.

Tuttavia, non è necessario indicare inizialmente la dimensione a tutti i livelli, è possibile indicare solo la dimensione al primo livello.

Int a1 = new int; // array bidimensionale con 5 righe

In questo caso, mentre non si sa quanti elementi ci saranno in ogni riga, questo può essere determinato in seguito, inoltre, l'array può contenere in ogni riga un numero diverso di elementi, cioè può essere asimmetrico... Determina il numero di elementi in ogni riga per l'array a1

A1 = nuovo int; a1 = nuovo int; a1 = nuovo int; a1 = nuovo int; a1 = nuovo int;

Di conseguenza, quando viene visualizzato sullo schermo,

Per (int i = 0; i

l'array sarà simile a questo:

0
0 0
0 0 0
0 0 0 0
0 0 0 0 0

Quando viene creato un array, i suoi elementi vengono inizializzati automaticamente su zeri, quindi questo esempio mostra degli zeri.

Esercizi su array multidimensionali in Java:

1. Crea un array 5 per 6 e riempilo con numeri casuali (che vanno da 0 a 99). Stampa la terza riga sulla console
2. Date le matrici C e D con dimensione 3 per 3 e riempite con numeri casuali nell'intervallo da 0 a 99. Eseguire l'addizione, quindi la moltiplicazione delle matrici l'una per l'altra separatamente. Invia le matrici iniziali e il risultato dei calcoli alla console.
3. Somma tutti gli elementi di un array bidimensionale.
4. Ti viene dato un array bidimensionale contenente numeri negativi e positivi. Visualizza i numeri di quelle celle nell'array che contengono numeri negativi.
5. Ordina gli elementi nelle righe di un array bidimensionale in ordine crescente