Array monodimensionali
- #java
- #programmazione
- #array
- #array monodimensionali
In questa lezione
- 1. Descrizione
- 2. Dichiarazione
- 2.1 Valori di default
- 3. Dimensione Array
- 4. Operazioni
- 4.1 Accesso elemento
- 4.2 Lettura elemento
- 4.3 Scrittura elemento
- 4.4 Uscire dai limiti dell’array
- 4.5 Cosa NON si fa (o non fa quello che ti aspetti)
- 4.6 Soluzione a questi problemi
- 5. Il ciclo for-each
- 6. Algoritmi principali
- 6.1 Stampa Array
- 6.2 Leggi Array
- 6.3 Ordinamento Array (Bubble Sort)
- 6.4 Ricerca Massimo/Minimo
- 6.5 Somma e media
- 7. Array e metodi
- 8. Riepilogo: Java vs C/C++
- 9. Quiz a risposta multipla
- 10. Esercizi
- 10.1 Esercizio - Array palindromo
- 10.2 Esercizio - Numeri unici
- 10.3 Esercizio - Voti della classe
- 10.4 Esercizio - Inverti l’array
1. Descrizione
Un array monodimensionale (o vettore) è una sequenza di variabili dello stesso tipo che vengono situate consecutivamente nella memoria ed alle quali è possibile accedere usando uno stesso nome (identificatore) a cui viene aggiunto un indice. Pensiamo all’array come ad un insieme di cassetti numerati.
Definizione: Sequenza di elementi () tutti di tipo individuati singolarmente da un numero intero int fra 0 e (detto indice).

Nota
2. Dichiarazione
In Java un array è un tipo reference (come abbiamo visto nella lezione Hello World): la variabile non contiene gli elementi, ma un riferimento all’array che si trova in memoria. Per questo l’array va creato con new, come gli oggetti.
dove:
- → identificatore (nome);
- → tipo degli elementi;
- → dimensione (numero di elementi), un valore intero.
final int N = 10;
// dichiara un array di 10 interi
int[] A = new int[N];
// dichiara un array di 10 elementi float
float[] V = new float[10];
// la dimensione può essere decisa a run-time (es. letta da tastiera)
int m = 100;
int[] B = new int[m];
// array di interi con la dimensione definita implicitamente (5 elementi)
int[] C = {3, 5, 6, 2, 1};
// forma equivalente, utile quando l'array non viene creato nella dichiarazione
int[] D;
D = new int[] {3, 5, 6, 2, 1};
// array di stringhe
String[] nomi = {"Anna", "Luca", "Marco"};
Suggerimento
Java accetta anche la sintassi del C int A[] = new int[10];, ma per convenzione si preferisce int[] A: le parentesi quadre fanno parte del tipo (“array di int”).
2.1 Valori di default
A differenza del C/C++, in Java un array appena creato non contiene mai valori casuali: ogni elemento viene inizializzato automaticamente.
| Tipo degli elementi | Valore iniziale |
|---|---|
int, long, short, byte | 0 |
float, double | 0.0 |
char | '\u0000' (carattere nullo) |
boolean | false |
tipi reference (String, oggetti, …) | null |
int[] voti = new int[5];
System.out.println(voti[3]); // Output: 0
3. Dimensione Array
In Java la dimensione di un array:
- può essere decisa a run-time (non serve una costante come in C);
- si legge con l’attributo
length(senza parentesi!); - una volta creato l’array non può più cambiare.
int[] vett = {2, 0, 1, 6, 3};
System.out.println(vett.length); // Output: 5
Nota
Se serve una “lista” che cresce e si accorcia durante l’esecuzione, in Java si usa ArrayList, che vedremo nella lezione sulle collezioni.
4. Operazioni
4.1 Accesso elemento
int[] vett = {2, 0, 1, 6, 3};
vett[4]; // -> mi riferisco al valore 3
4.2 Lettura elemento
Scanner input = new Scanner(System.in);
int[] vett = new int[5];
vett[2] = input.nextInt(); // inserisco un valore nella posizione 3
4.3 Scrittura elemento
int[] vett = {2, 0, 1, 6, 3};
System.out.println(vett[2]); // Output: 1

4.4 Uscire dai limiti dell’array
In C/C++ accedere a una posizione che non esiste produce un comportamento indefinito. Java invece controlla sempre l’indice e, se è fuori dall’intervallo , interrompe il programma con un’eccezione:
int[] vett = new int[5];
vett[5] = 10; // ERRORE a run-time
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
Attenzione
L’ultimo indice valido è sempre vett.length - 1. Nei cicli usa i < vett.length, non i <= vett.length.
4.5 Cosa NON si fa (o non fa quello che ti aspetti)
-
Confronto con
==: compila, ma confronta i riferimenti (cioè “sono lo stesso array in memoria?”), non il contenuto.int[] A = {1, 2, 3}; int[] B = {1, 2, 3}; System.out.println(A == B); // false! sono due array diversi -
Assegnamento con
=: non copia gli elementi, ma fa puntare entrambe le variabili allo stesso array.int[] A = {1, 2, 3}; int[] B = A; // B e A sono lo STESSO array B[0] = 99; System.out.println(A[0]); // Output: 99 -
Stampa diretta: non stampa gli elementi, ma un codice interno.
int[] A = {1, 2, 3}; System.out.println(A); // Output simile a: [I@1b6d3586
4.6 Soluzione a questi problemi
Come in C/C++, per eseguire correttamente operazioni di confronto, copia ed I/O si possono usare i cicli, lavorando elemento per elemento:
-
Confronto e assegnamento:
esempio:
A[i] == B[j]esempio:
A[i] = 5 -
I/O su array:
esempio:
A[3] = input.nextInt()esempio:
System.out.println(A[i])
In più Java mette a disposizione la classe di libreria java.util.Arrays, che fa queste operazioni al posto nostro:
import java.util.Arrays;
int[] A = {3, 1, 2};
int[] B = {3, 1, 2};
System.out.println(Arrays.equals(A, B)); // true -> confronta il contenuto
System.out.println(Arrays.toString(A)); // [3, 1, 2] -> stampa
int[] C = Arrays.copyOf(A, A.length); // copia vera (nuovo array)
Arrays.sort(A); // ordina: A = [1, 2, 3]
Arrays.fill(B, 0); // B = [0, 0, 0]
5. Il ciclo for-each
Quando serve solo leggere tutti gli elementi, dall’inizio alla fine, Java offre il ciclo for-each (o enhanced for):
int[] vett = {2, 0, 1, 6, 3};
for (int x : vett) {
System.out.print(x + " ");
}
// Output: 2 0 1 6 3
Si legge: “per ogni x contenuto in vett”.
Attenzione
Nel for-each x è una copia del valore: assegnare x = 0 non modifica l’array. Per modificare gli elementi, o quando ti serve l’indice, usa il for classico.
6. Algoritmi principali
6.1 Stampa Array
int[] vett = {2, 0, 1, 6, 3};
for (int i = 0; i < vett.length; i++) {
System.out.print(vett[i] + " ");
}
// Output: 2 0 1 6 3
6.2 Leggi Array
Scanner input = new Scanner(System.in);
int[] vett = new int[5];
for (int i = 0; i < vett.length; i++) {
vett[i] = input.nextInt();
}
6.3 Ordinamento Array (Bubble Sort)

int[] vett = {2, 0, 1, 6, 3};
for (int i = 0; i < vett.length; i++) {
for (int j = 0; j < vett.length - 1; j++) {
if (vett[j] > vett[j + 1]) {
int temp = vett[j];
vett[j] = vett[j + 1];
vett[j + 1] = temp;
}
}
}
Ragionamento per “swappare” gli elementi di un array tra di loro:

Suggerimento
Nei programmi reali si usa direttamente Arrays.sort(vett);, ma scrivere il Bubble Sort a mano è un ottimo esercizio per capire come funzionano gli indici.
6.4 Ricerca Massimo/Minimo
int[] vett = {2, 5, 1, 0, 3};
int max = vett[0];
for (int i = 0; i < vett.length; i++) {
if (max < vett[i]) {
max = vett[i];
}
}
System.out.println(max);
// Output: 5

6.5 Somma e media
int[] voti = {7, 8, 6, 9};
int somma = 0;
for (int v : voti) {
somma += v;
}
double media = (double) somma / voti.length;
System.out.println("Media: " + media); // Output: Media: 7.5
Nota
Il (double) davanti a somma è un casting esplicito: senza, 30 / 4 sarebbe una divisione tra interi e darebbe 7. Approfondiamo nella lezione Casting implicito ed esplicito.
7. Array e metodi
Un array si può passare a un metodo e un metodo può restituire un array. Poiché si passa il riferimento, le modifiche fatte dentro al metodo si vedono anche fuori.
public class Main {
static void raddoppia(int[] a) {
for (int i = 0; i < a.length; i++) {
a[i] = a[i] * 2;
}
}
static int[] creaSequenza(int n) {
int[] s = new int[n];
for (int i = 0; i < n; i++) {
s[i] = i + 1;
}
return s;
}
public static void main(String[] args) {
int[] numeri = creaSequenza(4); // [1, 2, 3, 4]
raddoppia(numeri);
System.out.println(java.util.Arrays.toString(numeri)); // [2, 4, 6, 8]
}
}
Nota
Anche il parametro String[] args del main è un array: contiene gli argomenti passati al programma da riga di comando.
8. Riepilogo: Java vs C/C++
| C / C++ | Java | |
|---|---|---|
| Dichiarazione | int A[10]; | int[] A = new int[10]; |
| Dimensione | costante (array statici) | anche decisa a run-time |
| Numero di elementi | va memorizzato a parte | A.length |
| Valori iniziali | casuali (se non inizializzati) | 0, false, null, … |
| Indice fuori dai limiti | comportamento indefinito | ArrayIndexOutOfBoundsException |
A = B | errore | copia il riferimento (stesso array) |
A == B | errore / confronta indirizzi | confronta i riferimenti |
| Stampa | ciclo | ciclo oppure Arrays.toString(A) |
9. Quiz a risposta multipla
Mettiti alla prova
0/7 risposte
1) Come si dichiara correttamente un array di 10 interi in Java?
2) Dopo int[] v = new int[5]; quanto vale v[4]?
3) Come si ottiene il numero di elementi di un array v?
4) Cosa succede eseguendo v[5] = 1; se v ha 5 elementi?
5) Dati int[] a = {1,2}; int[] b = a; b[0] = 9; quanto vale a[0]?
6) Qual è il modo corretto per confrontare il CONTENUTO di due array a e b?
7) Nel ciclo for (int x : v) { x = 0; } cosa succede all'array v?
Leggi il codice
0/2 risposte
Cosa stampa questo codice?
Cosa stampa?int[] v = {4, 7, 1, 9}; int s = 0; for (int i = 1; i < v.length; i += 2) { s += v[i]; } System.out.println(s);Trova la riga con il bug
Trova il bugClicca la riga che contiene l'errore.
int[] v = new int[5]; for (int i = 0; i <= v.length; i++) { v[i] = i * 2; }
10. Esercizi
Esercizi con gli array in Java
10.1 Esercizio - Array palindromo
Leggere un array di interi di 10 posizioni e verificare se è palindromo (ovvero se non cambia ad essere letto dalla prima cella all’ultima o viceversa).
Esempio Output: inserisci 10 valori: 3 5 7 9 1 1 9 7 5 3 l’array e’ palindromo
💡 Mostra soluzione
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int[] a = new int[10];
System.out.print("inserisci 10 valori: ");
for (int i = 0; i < a.length; i++) {
a[i] = input.nextInt();
}
boolean palindromo = true;
for (int i = 0; i < a.length / 2; i++) {
if (a[i] != a[a.length - 1 - i]) {
palindromo = false;
}
}
if (palindromo) {
System.out.println("l'array e' palindromo");
} else {
System.out.println("l'array NON e' palindromo");
}
input.close();
}
}10.2 Esercizio - Numeri unici
Leggere un array di 10 interi e stampare solo i numeri che appaiono nell’array una volta soltanto.
Esempio Output: inserisci 10 numeri interi: 1 3 5 3 2 0 5 2 3 4 1 0 4
💡 Mostra soluzione
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int[] a = new int[10];
// memorizzo l'array
System.out.print("inserisci 10 numeri interi: ");
for (int i = 0; i < a.length; i++) {
a[i] = input.nextInt();
}
// per ogni numero dell'array conto quante volte compare
for (int i = 0; i < a.length; i++) {
int volte = 0;
for (int j = 0; j < a.length; j++) {
if (a[j] == a[i]) {
volte++;
}
}
if (volte == 1) {
System.out.print(a[i] + " ");
}
}
input.close();
}
}10.3 Esercizio - Voti della classe
Chiedere all’utente quanti studenti ci sono in classe (n), creare un array di n voti (double), leggerli e stampare:
- la media;
- il voto più alto e quello più basso;
- quanti voti sono sufficienti (≥ 6).
Esempio Output: quanti studenti? 4 voto 1: 7 voto 2: 5.5 voto 3: 8 voto 4: 6 media: 6.625 massimo: 8.0 - minimo: 5.5 sufficienti: 3
💡 Mostra soluzione
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("quanti studenti? ");
int n = input.nextInt();
double[] voti = new double[n]; // dimensione decisa a run-time
for (int i = 0; i < voti.length; i++) {
System.out.print("voto " + (i + 1) + ": ");
voti[i] = input.nextDouble();
}
double somma = 0;
double max = voti[0];
double min = voti[0];
int sufficienti = 0;
for (double v : voti) {
somma += v;
if (v > max) max = v;
if (v < min) min = v;
if (v >= 6) sufficienti++;
}
System.out.println("media: " + somma / voti.length);
System.out.println("massimo: " + max + " - minimo: " + min);
System.out.println("sufficienti: " + sufficienti);
input.close();
}
}10.4 Esercizio - Inverti l’array
Scrivere un metodo static void inverti(int[] a) che inverte l’ordine degli elementi dello stesso array (senza crearne uno nuovo). Provarlo nel main stampando l’array prima e dopo con Arrays.toString.
Esempio Output: prima: [1, 2, 3, 4, 5] dopo: [5, 4, 3, 2, 1]
💡 Mostra soluzione
import java.util.Arrays;
public class Main {
static void inverti(int[] a) {
for (int i = 0; i < a.length / 2; i++) {
int temp = a[i];
a[i] = a[a.length - 1 - i];
a[a.length - 1 - i] = temp;
}
}
public static void main(String[] args) {
int[] numeri = {1, 2, 3, 4, 5};
System.out.println("prima: " + Arrays.toString(numeri));
inverti(numeri); // l'array viene modificato perché passiamo il riferimento
System.out.println("dopo: " + Arrays.toString(numeri));
}
}