In Java un array è un'importante struttura di dati lineare che ci consente di memorizzare più valori dello stesso tipo.

• Gli array in Java sono oggetti come tutti gli altri oggetti negli array Java ereditano implicitamente dalla classe java.lang.Object. Ciò consente di richiamare metodi definiti in Object (come toString() equals() e hashCode()).
• Gli array hanno una proprietà length incorporata che fornisce il numero di elementi nell'array

   public     class   Geeks     {      public     static     void     main  (  String  []     args  )      {      // initializing array      int  []     arr     =     {  40       55       63       17       22  };      // size of array      int     n     =     arr  .  length  ;      // traversing array      for     (  int     i     =     0  ;     i      <     n  ;     i  ++  )      System  .  out  .  print  (  arr  [  i  ]     +     ' '  );      }   }   

40 55 63 17 22  

Caratteristiche principali degli array

• Memorizza primitive e oggetti: Gli array Java possono contenere sia tipi primitivi (come int char boolean ecc.) che oggetti (come String Integer ecc.)
• Allocazione di memoria contigua Quando utilizziamo array di tipi primitivi gli elementi vengono archiviati in posizioni contigue. Per i tipi non primitivi i riferimenti agli elementi vengono archiviati in posizioni contigue.
• Indicizzazione su base zero: Il primo elemento dell'array ha l'indice 0.
• Lunghezza fissa: Dopo aver creato un array, la sua dimensione viene fissata; non possiamo cambiarlo.

Operazioni di base sugli array in Java

1. Dichiarazione di un array

La forma generale della dichiarazione di array è 

// Metodo 1:
int arr[];

// Metodo 2:
int[] arr;

Il tipo di elemento determina il tipo di dati di ciascun elemento che comprende l'array. Come un array di numeri interi, possiamo anche creare un array di altri tipi di dati primitivi come char float double ecc. O tipi di dati definiti dall'utente (oggetti di una classe).

Nota: È proprio il modo in cui possiamo creare una variabile di array, non esiste un array reale. Dice semplicemente al compilatore che questa variabile (int Array) conterrà un array di tipo intero.

2. Inizializzazione di un array in Java

Quando viene dichiarato un array, viene creato solo un riferimento di un array. Usiamo new per allocare un array di una determinata dimensione.

int arr[] = nuovo int[dimensione];

• La dichiarazione dell'array è generalmente statica, ma se la dimensione non è definita l'array ha dimensioni dinamiche.
• La memoria per gli array viene sempre allocata dinamicamente (sul segmento heap) in Java. Questo è diverso da C/C++ in cui la memoria può essere allocata staticamente o dinamicamente.
• Gli elementi nell'array allocati da new verranno automaticamente inizializzati su zero (per i tipi numerici) false (per booleano) o null (per i tipi riferimento).

Array letterale in Java

In una situazione in cui la dimensione dell'array e le variabili dell'array sono già note, è possibile utilizzare i valori letterali dell'array. 

// Dichiara il valore letterale dell'array
int[] arr = nuovo int[]{ 12345678910 };

• La lunghezza di questo array determina la lunghezza dell'array creato.
• Non è necessario scrivere la nuova parte int[] nelle ultime versioni di Java.

3. Modificare un elemento dell'array

Per modificare un elemento assegnare un nuovo valore ad un indice specifico. L'indice inizia con 0 e termina con (dimensione totale dell'array)-1.

// Modifica il primo elemento in 90
arr[0] = 90;

4. Lunghezza dell'array

Possiamo ottenere la lunghezza di un array utilizzando la proprietà length:

// Ottenere la lunghezza dell'array
int n = arr.lunghezza;

5. Accesso e aggiornamento di tutti gli elementi dell'array

• È possibile accedere a tutti gli elementi dell'array utilizzando Java for Loop.
• Ogni elemento dell'array è accessibile tramite il suo indice.

Il programma Java per illustrare la creazione di un array di numeri interi inserisce alcuni valori nell'array e stampa ciascun valore sullo standard output

   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      // declares an Array of integers.      int  []     arr  ;      // allocating memory for 5 integers.      arr     =     new     int  [  5  ]  ;      // initialize the elements of the array      // first to last(fifth) element      arr  [  0  ]     =     2  ;      arr  [  1  ]     =     4  ;      arr  [  2  ]     =     8  ;      arr  [  3  ]     =     12  ;      arr  [  4  ]     =     16  ;      // accessing the elements of the specified array      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      System  .  out  .  println  (  'Element at index '     +      i     +     ' : '     +     arr  [  i  ]  );      }   }   

Element at index 0 : 2 Element at index 1 : 4 Element at index 2 : 8 Element at index 3 : 12 Element at index 4 : 16  

Matrici di oggetti in Java

Un array di oggetti viene creato come un array di elementi di dati di tipo primitivo

Esempio : Qui stiamo prendendo una classe Student e creando un array di Student con cinque oggetti Student memorizzati nell'array. Gli oggetti Student devono essere istanziati utilizzando il costruttore della classe Student e i loro riferimenti devono essere assegnati agli elementi dell'array.

   class   Student     {      public     int     roll_no  ;      public     String     name  ;          Student  (  int     roll_no       String     name  ){      this  .  roll_no     =     roll_no  ;      this  .  name     =     name  ;      }   }   public     class   Geeks     {      public     static     void     main  (  String  []     args  ){          // declares an Array of Student      Student  []     arr  ;      // allocating memory for 5 objects of type Student.      arr     =     new     Student  [  5  ]  ;      // initialize the elements of the array      arr  [  0  ]     =     new     Student  (  1       'aman'  );      arr  [  1  ]     =     new     Student  (  2       'vaibhav'  );      arr  [  2  ]     =     new     Student  (  3       'shikar'  );      arr  [  3  ]     =     new     Student  (  4       'dharmesh'  );      arr  [  4  ]     =     new     Student  (  5       'mohit'  );      // accessing the elements of the specified array      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      System  .  out  .  println  (  'Element at '     +     i     +     ' : { '      +     arr  [  i  ]  .  roll_no     +     ' '      +     arr  [  i  ]  .  name  +  ' }'  );      }   }   

Element at 0 : { 1 aman } Element at 1 : { 2 vaibhav } Element at 2 : { 3 shikar } Element at 3 : { 4 dharmesh } Element at 4 : { 5 mohit }  

Cosa succede se proviamo ad accedere a elementi al di fuori della dimensione dell'array?

JVM lancia ArrayIndexOutOfBoundsException per indicare che è stato effettuato l'accesso all'array con un indice non valido. L'indice è negativo oppure maggiore o uguale alla dimensione di un array.

Il codice seguente mostra cosa succede se proviamo ad accedere a elementi al di fuori della dimensione dell'array:

   public     class   Geeks     {      public     static     void     main  (  String  []     args  )      {      int  []     arr     =     new     int  [  4  ]  ;      arr  [  0  ]     =     10  ;      arr  [  1  ]     =     20  ;      arr  [  2  ]     =     30  ;      arr  [  3  ]     =     40  ;      System  .  out  .  println  (      'Trying to access element outside the size of array'  );      System  .  out  .  println  (  arr  [  5  ]  );      }   }   

Produzione:

Passaggio di array ai metodi

Come le variabili possiamo anche passare gli array ai metodi. Ad esempio, il programma seguente passa l'array al metodo sum per calcolare la somma dei valori dell'array.

Esempio:

   public     class   Geeks     {      // Driver method      public     static     void     main  (  String     args  []  )      {      int     arr  []     =     {     3       1       2       5       4     };      // passing array to method m1      sum  (  arr  );      }      public     static     void     sum  (  int  []     arr  )      {      // getting sum of array values      int     sum     =     0  ;      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      sum     +=     arr  [  i  ]  ;      System  .  out  .  println  (  'sum of array values : '     +     sum  );      }   }   

sum of array values : 15  

Spiegazione

• Questo programma Java dimostra come passare un array a un metodo.
• Un array di numeri interi arr viene dichiarato e inizializzato nel metodo main.
• Il metodo sum() viene chiamato con arr come argomento.
• All'interno del metodo sum() tutti gli elementi dell'array vengono aggiunti utilizzando un ciclo for.
• La somma finale viene quindi stampata sulla console.

Restituzione di array dai metodi

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

Esempio:

   class   Geeks     {      // Driver method      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     };      }   }   

1 2 3  

Vantaggi degli array Java

• Accesso efficiente: L'accesso a un elemento tramite il suo indice è rapido e ha una complessità temporale costante O(1).
• Gestione della memoria: Gli array hanno dimensioni fisse che rendono la gestione della memoria semplice e prevedibile.
• Organizzazione dei dati: Gli array aiutano a organizzare i dati in modo strutturato semplificando la gestione degli elementi correlati.

Svantaggi degli array Java

• Dimensione fissa: Una volta creato un array, la sua dimensione non può essere modificata, il che può portare a spreco di memoria se la dimensione è sovrastimata o a spazio di archiviazione insufficiente se sottostimata.
• Tipo Omogeneità: Gli array possono memorizzare solo elementi dello stesso tipo di dati che potrebbero richiedere una gestione aggiuntiva per tipi di dati misti.
• Inserimento e cancellazione: L'inserimento o l'eliminazione di elementi, soprattutto al centro di un array, può essere costoso in quanto potrebbe richiedere lo spostamento degli elementi.

Articoli correlati

• Array frastagliato in Java
• Per ogni ciclo in Java
• Classe Array in Java