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[];

stringa in Java

// 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. 

.06 come frazione

// 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.

ordinamento veloce

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:

genericità in Java

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