Fondamenti di Informatica
Prof. Alfredo Cuzzocrea
University of Trieste
Dichiarazione, Creazione e
Gestione di Array
Credits to: Prof. D. Talia – UniCAL / Prof. C.
Limongelli – UniROMA3
10110
Array in Java - creazione
01100
01011
La creazione fa una inizializzazione implicita:
num = new int[10];
con valore 0 per int e double, false per i boolean.
Dopo la creazione, un array ha lunghezza fissata (e non può
cambiare nel programma tramite una nuova dichiarazione).
Gli elementi di un array possono essere assegnati ad elementi di
un array dello stesso tipo:
int x[] = new int[10];
int y[] = new int[50];
x[3] = y[5];
2
10110
Array in Java - copia
01100
01011
Se si vuole copiare un array in un altro:
int vet1[] = new int[20];
int vet2[] = new int[20];
for(int i=0; i< 20; i++)
vet1[i] = vet2[i];
Se si vuole copiare una parte di array in un altro:
int vet3[] = new int[10];
for(int i=0; i< 10; i++)
vet3[i] = vet1[i];
Per copiare la prima metà di vet1 in vet3.
3
10110
Array in Java - copia
01100
01011
Se si vuole copiare una parte di array in un altro:
int vetA[] = new int[20];
int vetB[] = new int[10];
Per copiare la seconda metà di vetA in vetB.
for(int i=0; i< 10; i++)
vetB[i] = vetA[i+10];
oppure
for(int i=10; i< 20; i++)
vetB[i-10] = vetA[i];
4
10110
Array in Java - copia
01100
01011
Se si vuole copiare gli elementi di vet1 in vet2 in ordine
inverso:
int vet1[] = new int[20];
int vet2[] = new int[20];
for(int i=0; i< 20; i++)
vet2[i] = vet1[19-i];
5
Array in Java - copia
10110
01100
01011
Se si vuole copiare da array ad array si può usare il
metodo
System.arraycopy(arr-orig, pos, arr-des, pos, cont)
Esempi:
System.arraycopy(vet1, 0, vet2, 0, 15);
Copia i primi 15 elementi di vet1 in vet2
System.arraycopy(vet2, 5, vet3, 0, 10)
Copia 10 elementi (a partire dal sesto) di vet2 in vet3.
6
10110
Array in Java – assegnamento tra array
01100
01011
Si possono assegnare anche array (ma bisogna porre
attenzione a quello che accade se i due array non
hanno lunghezza uguale !)
x = y;
Dopo questa operazione le due variabili fanno
riferimento alla stessa locazione di memoria (quella di
y);
3
1
3
1
x
y
x
y 8
9
8
9
Prima
6
9
0
7
7
Dopo
6
9
0
7
7
7
10110
Array in Java - lunghezza
01100
01011
Ad ogni variabile array è associata implicitamente
una variabile istanza length:
int [] seq = new int[5]
seq.length
avrà valore 5
Esempi di uso
- N = seq.length;
assegna 5 ad N
- System.out.println(seq.length);
Visualizza il valore 5
Uso nel ciclo for
- for(int i=0; i<vet1.length; i++)
vet1[i] = vet2[i];
8
10110
Array in Java – Massimo tra due numeri
01100
01011
class maxtraduenum
{ public static void main(String args[])
{ int[] x;
int max;
x = new[2];
x[0]= Console.readInt("dammi il primo numero");
x[1]=Console.readInt("dammi il secondo numero");
if (x[0] > x[1])
max=x[0];
else
max=x[1];
System.out.println ("Massimo = " + max);
}
}
9
10110
Array in Java – Massimo tra N numeri
01100
01011
class cercamassimo
{
public static void main(String args[])
{
int[] seq;
int max, ind;
}
seq = new int[10];
for (ind=0; ind < 10; ind++)
{
seq[ind] = Console.readInt("dammi un numero");
}
max = seq[0];
for(ind=0; ind < 10; ind++)
{
if (seq[ind] > max)
max = seq[ind];
}
System.out.println ("Massimo = " + max);
}
10
10110
Array Multidimensionali
01100
01011
Array bidimensionali
In Java si possono avere array a più dimensioni.
Gli array a due dimensioni in Java si realizzano come array di
array.
Dichiarazione:
int [][] Matrice = new int[3][5];
[riga, colonna]
Matrice[0]
12
3
27
74
0
Matrice[1]
4
15
33
-1
2
Matrice[2]
8
30
56
32
8
Matrice[1][3]
11
10110
Array Multidimensionali
01100
01011
Array bidimensionali
Assegnamento di un elemento
matrice[3][5] = 10;
Assegnamento di una riga
matrice[3] = {10, 15, 20, 25, 30, 35};
Il numero di righe è dato da
int nrighe = matrice.length
Il numero di colonne è dato da
int ncolonne = matrice[0].length
12
10110
Array con righe di lunghezza variabile
01100
01011
In un array bidimensionale in Java si possono avere
righe di lunghezza differente.
Dichiarazione:
int[][] tabella = new int[4][];
Assegnamento
for(int i=0; i<tabella.length; i++)
tabella[i] = new int[i+1];
12
3 -6
21 0 7
2 54 80 45
13
Array – Leggere i valori di una matrice
10110
01100
01011
class matrice
{
. . . . .
public void leggimatrice()
{
int[][] mat;
int i,j;
mat = new int[4][5];
}
for (i=0; i < 4; i++)
{
for(j=0; j < 5; j++)
mat[i][j]= Console.readInt("dammi un elemento");
}
. . . .
14
Contenuti
q Esercizi:
§ Lettura e stampa di un array
§ Massimo elemento di un array
§ Verifica sequenza crescente
2
Lettura e stampa di un array…
q Scrivere un programma che legge da input 5 elementi
interi, li memorizza in un array e stampa il contenuto
dell’array
import fiji.io.*;
class LeggiScrivi{
public static void main(String[] args){
final int L=5;
int[] a;
a = new int[L];
leggi(a);
System.out.println("** verifica acquisizione dati **");
stampa(a);
}
3
…Lettura e stampa di un array
public static void leggi(int[] v){
int i;
System.out.println("scrivi " + v.length + “
interi");
for (i=0; i<v.length; i++)
v[i] = Lettore.in.leggiInt();
System.out.println();
}
public static void stampa(int[] v){
int i;
System.out.println("array letto: ");
for (i=0; i<v.length; i++)
System.out.print(v[i] + " ");
System.out.println();
}
}
4
Esempio d’esecuzione
scrivi 5 interi
2 4 6 8 10
** verifica acquisizione dati **
array letto:
2 4 6 8 10
Press any key to continue . . .
5
Massimo elemento in un array
q Scrivere un metodo int massimoArray(int[ ] a) che
calcola e restituisce il valore del massimo
elemento di un array di interi non vuoto a
• massimoArray( new int[ ] { 3, 1, 2 } ) deve restituire 3
• massimoArray( new int[ ] { 3, 7, 5 } ) deve restituire 7
q Scrivere un metodo int posizioneMassimo(int[ ] a)
che calcola la posizione dell’elemento di valore
massimo di a
• posizioneMassimo( new int[ ] { 3, 1, 2 } ) deve restituire 0
• posizioneMassimo( new int[ ] { 3, 1, 3 } ) può restituire 0 o 2
6
Considerazioni
q Se calcoliamo solo l’elemento massimo non
sappiamo in quale posizione si trova,
q Se calcoliamo la posizione dell’elemento
massimo, sappiamo anche accedere al valore
relativo
q Calcolare la posizione in cui si trova l’elemento
massimo è un problema più generale e premette
di risolvere entrambi gli esercizi
7
MassimoArray: verifica di correttezza . . .
/* array con 1 solo elemento */
v = new int[] {1}; stampa(v);
System.out.println("Il massimo e' in posizione
d'indice 0 -- ris. =" + massimoArray(v));
/* array con l'ultimo elemento massimo */
v = new int[] {1,2,3,4,5}; stampa(v);
System.out.println("Il massimo e' in posizione
d'indice 4 -- ris. =" + massimoArray(v));
/* array con il primo elemento massimo */
v = new int[] {5,4,3,2,1}; stampa(v);
System.out.println("Il massimo e' in posizione
d'indice 0 -- ris. =" + massimoArray(v));
8
. . . MassimoArray: verifica di correttezza
/* array con valori tutti uguali */
v = new int[] {5,5,5}; stampa(v);
System.out.println("Il massimo e' in posizione
d'indice 0 -- ris. =" + massimoArray(v));
/* array con un generico elemento massimo */
v = new int[] {5,4,1,6,2,3}; stampa(v);
System.out.println("Il massimo e' in posizione
d'indice 3 -- ris. =" + massimoArray(v));
9
MassimoArray: analisi del problema
q Che tipo di problema è?
q Algoritmo:
Input: array v
Output: posizione del massimo trovato
Pre: array non vuoto (almeno un elemento)
Memorizzo il valore e l’indice della prima
componente in due variabili max e indmax;
§ Esamino tutti i rimanenti elementi dell’array con un
ciclo for: sia i l’indice del generico elemento visitato:
se v[i]>max allora aggiorno max e indmax
rispettivamente con v[i] e i
§
§
§
§
10
MassimoArray : il metodo…
public static int massimoArray(int[] v){
//pre: array non vuoto - almeno 1 elemento
int max;
int i;
i = posizioneMassimo(v);
max = v[i];
return max;
}
11
PosizioneMassimo : il metodo…
public static int posizioneMassimo(int[] v){
//pre: array non vuoto - almeno 1 elemento
int max, indmax;
int i;
max = v[0];
indmax = 0;
for (i=1; i<v.length; i++)
if (v[i] > max){
max = v[i];
indmax = i;
}
return indmax;
}
12
Esempio di esecuzione
array letto:
1
Il massimo e' in posizione d'indice 0 -- ris. =1
array letto:
12345
Il massimo e' in posizione d'indice 4 -- ris. =5
array letto:
54321
Il massimo e' in posizione d'indice 0 -- ris. =5
array letto:
555
Il massimo e' in posizione d'indice 0 -- ris. =5
array letto:
541623
Il massimo e' in posizione d'indice 3 -- ris. =6
Press any key to continue . . .
13
Verifica Sequenza crescente
q Scrivere un metodo boolean crescente(int[ ] a)
che verifica se a è ordinato in modo crescente
§ un array è ordinato in modo crescente se per ogni
indice k, l’elemento di indice k è maggiore di tutti gli
elementi di indice minore di k
§ è sufficiente verificare se ogni elemento è minore
dell’elemento che lo segue immediatamente
§ intuitivamente, bisogna confrontare ciascun
elemento di indice i dell’array con l’elemento che lo
segue immediatamente, quello di indice i+1
§ attenzione – l’ultimo elemento di un array non ha un
elemento che lo segue immediatamente
14
Sequenza crescente: verifica di correttezza
public static void testCrescente(){
int[] v;
/* array vuoto */
v = new int[] {};
stampa(v);
System.out.println("La sequenza e' crescente TRUE ="
+ crescente(v));
/* array di due elementi crescente*/
v = new int[] {1,2};
stampa(v);
System.out.println("La sequenza e' crescente TRUE
+ crescente(v));
="
. . .
15
Sequenza crescente: verifica di correttezza
. . .
/* array di due elementi non crescente */
v = new int[] {2,1};
stampa(v);
System.out.println("La sequenza NON e'
crescente FALSE =" + crescente(v));
/* array con l'ultimo elemento non crescente
*/
v = new int[] {1,2,3,4,1};
stampa(v);
System.out.println("La sequenza NON
e'crescente FALSE =" + crescente(v));
. . .
16
… Sequenza crescente:
verifica di correttezza
. . .
/* array con il secondo elemento non crescente */
v = new int[] {1,-2,3,4,5};
stampa(v);
System.out.println("La sequenza NON e'crescente
FALSE =" + crescente(v));
/* array crescente */
v = new int[] {1,2,3,4,5};
stampa(v);
System.out.println("La sequenza
TRUE =" + crescente(v));
e'crescente
}
17
Sequenza crescente: analisi del problema
q Che tipo di problema è? Verifica universale
q Algoritmo:
§ Input: array v
§ Output: boolean (true/false) (crescente/non
crescente)
§ Pre: array non vuoto
§ verifica universale:
devo verificare che v[i]<v[i+1]
per tutti gli i da 0 fino al penultimo (v.length-1)
18
Sequenza crescente: il metodo
public static boolean crescente(int[]
v){
//pre: array non vuoto
boolean crescente;
int i;
/* verifica universale: devo verificare che v[i]<v[i+1]
per tutti gli i da 0 fino al penultimo */
crescente=true;
i=0;
while (i<v.length - 1 && crescente){
if (v[i]>=v[i+1])
crescente = false;
i=i+1;
}
return crescente;
}
19
Sequenza crescente:
esempio d’esecuzione
array letto:
La sequenza e' crescente TRUE =true
array letto:
3
La sequenza e' crescente TRUE =true
array letto:
12
La sequenza e' crescente TRUE =true
array letto:
21
La sequenza NON e' crescente FALSE =false
array letto:
12341
La sequenza NON e'crescente FALSE =false
array letto:
1 -2 3 4 5
La sequenza NON e'crescente FALSE =false
array letto:
12345
La sequenza e'crescente TRUE =true
Press any key to continue . . .
20
