Il ciclo for generalizzato
§ Il ciclo for
generalizzato scandisce tutti gli
elementi
di una
raccolta:
double[] data = . . .;
double sum = 0;
for (double e : data) // si legge "per ogni e in data"
{
sum = sum + e;
}
§ Per scandire tutti gli elementi di un array non è
obbligatorio utilizzare
il ciclo for generalizzato: lo stesso ciclo può essere realizzato con
un for normale e una variabile indice
esplicita.
double[] data = . . .;
double sum = 0;
for (int i = 0; i <
data.length; i++)
{
double e = data[i];
sum = sum + e;
}
§ Il ciclo for
generalizzato può essere usato anche
per ispezionare tutti
gli elementi di un vettore.
Ad esempio, il
ciclo seguente calcola il saldo totale di tutti i conti bancari:
ArrayList<BankAccount>
accounts = . . . ;
double sum = 0;
for (BankAccount a :
accounts)
{
sum = sum + a.getBalance();
}
§ Il ciclo è equivalente a questo ciclo
“normale”:
double sum = 0;
for (int i = 0; i <
accounts.size(); i++)
{
BankAccount a =
accounts.get(i);
sum = sum + a.getBalance();
}
Sintassi 8.3: Il ciclo for generalizzato
for (Tipo variabile : raccolta)
enunciato
Esempio:
for (double e : data)
sum = sum + e;
Obiettivo:
Eseguire
un ciclo avente un’iterazione per ogni elemento appartenente
a una
raccolta. All’inizio di ciascuna iterazione viene assegnato alla variabile
l’elemento successivo
della raccolta, poi viene eseguito l’enunciato.
Semplici algoritmi per vettori
Contare valori aventi determinate
caratteristiche
§ Per contare i valori aventi determinate caratteristiche e
presenti in
un vettore, ispezionare tutti gli elementi e contare quelli che
rispondono ai requisiti, finché non si raggiunge la fine del
vettore.
public class Bank
{
public int count(double atLeast)
{
int matches = 0;
for (BankAccount a : accounts)
{
if (a.getBalance() >= atLeast)
matches++;
// Trovato
}
return matches;
}
. . .
private ArrayList<BankAccount>
accounts;
}
Semplici algoritmi per vettori
Trovare un valore
§ Per trovare un valore in un vettore occorre controllarne
tutti
gli elementi finché non si trova il valore cercato.
public class Bank
{
public BankAccount find(int
accountNumber)
{
for (BankAccount a : accounts)
{
if (a.getAccountNumber() ==
accountNumber)
return
a; // Trovato
}
return
null; // non trovato nell’intero vettore
}
.
. .
}
Semplici algoritmi per vettori
Trovare il valore massimo o minimo
§ Per trovare il valore massimo (o minimo) in un vettore
§ inizializzare un candidato con l’elemento iniziale,
§ confrontare il candidato con gli elementi rimanenti
§ aggiornarlo se si trova un elemento maggiore (o minore).
§ Esempio
BankAccount largestYet =
accounts.get(0);
for (int i = 1; i < accounts.size();
i++)
{
BankAccount a = accounts.get(i);
if (a.getBalance() >
largestYet.getBalance())
largestYet
= a;
}
return
largestYet;
Semplici algoritmi per vettori
Trovare il massimo o il minimo
§ Questo metodo funziona soltanto se il vettore contiene
almeno
un elemento: non ha senso cercare l’elemento di valore maggiore
in un insieme vuoto.
§ Se l'insieme è vuoto, restituisce null
if (accounts.size() == 0) return null;
BankAccount
largestYet = accounts.get(0);
. .
.
File Bank.java
01: import java.util.ArrayList;
02:
03: /**
04: Una banca contiene un insieme di conti bancari.
05: */
06: public class Bank
07: {
08: /**
09: Costruisce una banca priva di conti bancari.
10: */
11: public Bank()
12: {
13: accounts = new
ArrayList<BankAccount>();
14: }
15:
16: /**
17: Aggiunge un conto bancario a questa banca.
18: @param a il conto da aggiungere
19:
*/
20: public void
addAccount(BankAccount a)
21: {
22: accounts.add(a);
23: }
24:
25: /**
26: Restituisce la somma dei saldi di tutti i conti della banca.
27: @return la somma dei saldi
28: */
29: public double
getTotalBalance()
30: {
31: double total = 0;
32: for (BankAccount a
: accounts)
33: {
34: total = total +
a.getBalance();
35: }
36: return total;
37: }
38:
39: /**
40: Conta il numero di conti bancari aventi saldo maggiore
41: o uguale al valore indicato.
42: @param atLeast il saldo minimo perché un
conto venga conteggiato
43: @return il numero di conti aventi saldo >= al saldo
indicato
44: */
45: public int count(double
atLeast)
46: {
47: int matches = 0;
48: for (BankAccount a
: accounts)
49: {
50: if (a.getBalance()
>= atLeast) matches++; // trovato
51: }
52: return matches;
53: }
54:
55: /**
56: Verifica se la banca contiene un conto con il numero indicato.
57: @param accountNumber il numero di
conto da cercare
58: @return il conto con il numero indicato, oppure null se
59: tale conto non esiste
60: */
61: public BankAccount
find(int accountNumber)
62: {
63: for (BankAccount a
: accounts)
64: {
65: if (a.getAccountNumber()
== accountNumber)
66: return a; // trovato
67: }
68: return null; // non trovato nell'intero vettore
69: }
70:
71: /**
72: Restituisce il conto bancario avente il saldo maggiore.
73: @return il conto con il saldo maggiore, oppure null se
74: la banca non ha conti
75: */
76: public BankAccount
getMaximum()
77: {
78: if
(accounts.size() == 0) return null;
79: BankAccount
largestYet = accounts.get(0);
80: for (int i = 1; i
< accounts.size(); i++)
81: {
82: BankAccount a =
accounts.get(i);
83: if (a.getBalance()
> largestYet.getBalance())
84: largestYet = a;
85: }
86: return largestYet;
87: }
88:
89: private
ArrayList<BankAccount> accounts;
90:
}
File BankTester.java
01: /**
02: Questo programma collauda la classe Bank.
03: */
04: public class BankTester
05: {
06: public static void
main(String[] args)
07: {
08: Bank
firstBankOfJava = new Bank();
09: firstBankOfJava.addAccount(new
BankAccount(1001, 20000));
10: firstBankOfJava.addAccount(new
BankAccount(1015, 10000));
11: firstBankOfJava.addAccount(new
BankAccount(1729, 15000));
12:
13: double threshold =
15000;
14: int c =
firstBankOfJava.count(threshold);
15: System.out.println(“Count:
“ + c);
System.out.println(“Expected:
2”);
16:
17: int accountNumber
= 1015;
18: BankAccount a =
firstBankOfJava.find(accountNumber);
19: if (a == null)
20: System.out.println("No
matching account“);
21: else
22: System.out.println(“Balance
of matching account: ”
23: + a.getBalance());
24: System.out.println(“Expected:
10000”);
25: BankAccount max =
firstBankOfJava.getMaximum();
26: System.out.println("Account
with largest balance: "
27: +
max.getAccountNumber()
28: System.out.println(“Expected:
1001”);
29: }
30:
}
Visualizza
Count: 2
Expected: 2
Balance of matching
account: 10000.0
Expected: 10000
Account with largest
balance: 1001
Expected:
1001
Post
