Post
Array
§ Array: sequenza di valori omogenei (cioè dello stesso
tipo).
§ Costruire un
array:
double[ ]
new double[10]
§ Memorizzare in una variabile il riferimento all'array.
§ Il tipo di una variabile che fa riferimento a un array è
il tipo
dell'elemento.
§ Dichiarazione di una variabile array
double[]
data = new double[10];
Array
§ Nel momento in cui viene creato l’array, tutti i suoi
valori sono
inizializzati al valore
§ 0 (per un array di numeri come int[] o double[]),
§ false (per un array boolean[]),
§ null (per un array di riferimenti a
oggetti).
Array
Un
riferimento ad array
e un array
Array
§ Usare [ ] per identificare un elemento di un array
data[2] = 29.95;
Memorizzare
un valore
in un Array
Array
§ Si accede agli elementi di un array tramite un indice di
tipo intero, usando
la notazione a [i].
System.out.println("The value of this
data item is " + data[2]);
§ I valori per gli indici di un array vanno da 0 a length –
1.
L’accesso a un elemento non esistente provoca il lancio di
un’eccezione
per errori di limiti.
§ Per conoscere il numero di elementi di un array usare il
campo length.
– Es: data.length
§ Gli array hanno un limite pesante: la loro lunghezza è fissa.
Sintassi 7.1: Costruzione di array
new nomeTipo[lunghezza]
Esempio:
new double[10]
Obiettivo:
Costruire un array con un determinato numero di elementi
Sintassi 7.2: Accesso a elementi di array
riferimentoAdArray[indice]
Esempio:
data[2]
Obiettivo:
Accedere a un elemento di un array
Vettori
§ La classe ArrayList
(vettore o lista sequenziale)
gestisce oggetti disposti
in sequenza.
§ Un vettore può crescere e calare di dimensione in base
alle necessità
§ La classe ArrayList
fornisce metodi per svolgere le
operazioni
più comuni, come l’inserimento e la rimozione di elementi
§ La classe ArrayList
è una classe generica: ArrayList<T> contiene
oggetti di tipo T.
ArrayList<BankAccount>
accounts = new ArrayList<BankAccount>();
BankAccount account1 = new
BankAccount(1001);
accounts.add(account1);
accounts.add(new BankAccount(1015));
accounts.add(new BankAccount(1022));
§ Il metodo size()
restituisce la dimensione attuale del
vettore.
Ispezionare gli elementi
§ Per ispezionare gli oggetti contenuti nel vettore si usa
il metodo get
e non l’operatore [ ] (tranne che in Java 7)
§ Come con gli array, i valori degli indici iniziano da 0
§ Ad esempio, accounts.get(2) restituisce il
conto bancario
avente indice 2, cioè il terzo elemento del vettore:
BankAccount anAccount = accounts.get(2);
// fornisce il terzo elemento del vettore
§ Accedere a un elemento non esistente è un errore.
§ L’errore di limiti più frequente è il seguente:
int i = accounts.size();
anAccount = accounts.get(i);
// Errore
// gli indici validi vanno da 0 a i-1
Aggiungere elementi
§ Per assegnare un nuovo valore a un elemento di un vettore
già
esistente si usa il metodo set:
BankAccount anAccount = new
BankAccount(1729);
accounts.set(2, anAccount);
§ È possibile inserire un oggetto in una posizione
intermedia
all’interno di un vettore.
accounts.add(i, c)
§ L’invocazione accounts.add(i, c) aggiunge
l’oggetto c nella
posizione i e sposta tutti gli elementi di una posizione, a partire
dall’elemento attualmente in posizione i fino
all’ultimo elemento
presente nel vettore.
Aggiungere elementi
Aggiungere
un elemento
in una
posizione intermedia
di un
vettore.
File: ArrayListTester.java
01: import java.util.ArrayList;
02:
03: /**
04: Questo programma collauda la classe ArrayList.
05: */
06: public class
ArrayListTester
07: {
08: public static void
main(String[] args)
09: {
10: ArrayList<BankAccount>
accounts
11: = new
ArrayList<BankAccount>();
12: accounts.add(new
BankAccount(1001));
13: accounts.add(new
BankAccount(1015));
14: accounts.add(new
BankAccount(1729));
15: accounts.add(1,
new BankAccount(1008));
16: accounts.remove(0);
17:
18: System.out.println("size="
+ accounts.size());
19: BankAccount first
= accounts.get(0);
20: System.out.println("first
account number="
21: +
first.getAccountNumber());
22: BankAccount last =
accounts.get(accounts.size() - 1);
23: System.out.println("last
account number="
24: + last.getAccountNumber());
25: }
26: }
File: BankAccount.java
01: /**
02: Un conto bancario ha un saldo che può essere modificato
03: da depositi e prelievi.
04: */
05: public class BankAccount
06: {
07: /**
08: Costruisce un conto bancario con saldo uguale a zero.
09: @param anAccountNumber il numero di questo conto bancario
10: */
11: public
BankAccount(int anAccountNumber)
12: {
13: accountNumber =
anAccountNumber;
14: balance = 0;
15: }
16:
17: /**
18: Costruisce un conto bancario con un saldo assegnato.
19: @param anAccountNumber il numero di questo conto bancario
20: @param initialBalance il saldo iniziale
21: */
22: public
BankAccount(int anAccountNumber, double initialBalance)
23: {
24: accountNumber = anAccountNumber;
25: balance = initialBalance;
26: }
27:
28: /**
29: Restituisce il numero di conto del conto bancario.
30: @return il numero di conto
31: */
32: public int
getAccountNumber()
33: {
34: return
accountNumber;
35: }
36:
37: /**
38: Versa denaro nel conto bancario.
39: @param amount l’importo da versare
40: */
41: public void
deposit(double amount)
42: {
43: double newBalance
= balance + amount;
44: balance =
newBalance;
45: }
46:
47: /**
48: Preleva denaro dal conto bancario.
49: @param amount l’importo da prelevare
50: */
51: public void
withdraw(double amount)
52: {
53: double newBalance = balance - amount;
54: balance = newBalance;
55: }
56:
57: /**
58: Ispeziona il valore del saldo attuale del conto bancario.
59: @return il saldo
attuale
60: */
61: public double
getBalance()
62: {
63: return balance;
64: }
65:
66: private int
accountNumber;
67: private double
balance;
68: }
Output:
Size: 3
First account number: 1008
Last
account number: 1729
Nessun commento:
Posta un commento