1. Elenco dei metodi

Ricordi che i creatori di Java hanno scritto un'intera classe helper chiamata Arraysper nostra comodità quando lavoriamo con gli array?

Hanno fatto la stessa cosa per le collezioni. Java ha una java.util.Collectionsclasse che ha molti metodi utili per lavorare con le raccolte. Ecco solo i più interessanti:

Metodi Descrizione 
addAll(colls, e1, e2, e3, ...)
 Aggiunge gli elementi e1, e2, e3, ... alla collsraccolta 
fill(list, obj)
 Sostituisce tutti gli elementi nell'elenco passato conobj 
nCopies(n, obj)
 Restituisce un elenco di copie ndell'oggettoobj 
replaceAll(list, oldVal, newVal)
 Sostituisce tutte le istanze di oldValcon newValnell'elencolist 
copy(dest, src)
 Copia tutti gli elementi dall'elenco srcall'elencodest 
reverse(list)
 Inverte l'elenco. 
sort(list)
 Ordina l'elenco in ordine crescente 
rotate(list, n)
 Sposta ciclicamente gli elementi dell'elenco listper nelementi 
shuffle(list)
 Mescola casualmente gli elementi nell'elenco 
min(colls)
 Trova l'elemento minimo nella collsraccolta 
max(colls)
 Trova l'elemento massimo nella collsraccolta 
frequency(colls, obj)
 Determina quante volte l' objelemento si verifica nella collsraccolta 
binarySearch(list, key)
 Cerca keyin un elenco ordinato e restituisce l'indice corrispondente. 
disjoint(colls1, colls2)
 Restituisce truese le raccolte non hanno elementi in comune
Importante:

Molti di questi metodi non usano le classi ArrayList, HashSete HashMapdi per sé, ma con le interfacce corrispondenti: Collection<T>, List<T>, Map<K, V>.

Questo non è un problema: se un metodo accetta un List<T>, puoi sempre passargli un ArrayList<Integer>, ma l'operatore di assegnamento non funziona nella direzione opposta.

Java university

2. Creazione e modifica di collezioni

Collections.addAll(Collection<T> colls, T e1, T e2, T e3, ...)metodo

Il addAll()metodo aggiunge gli elementi e1, e2, e3, ... alla collsraccolta È possibile passare qualsiasi numero di elementi.

Codice Uscita console 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5);

for (int i: list)
   System.out.println(i);
 
1
2
3
4
5

Collections.fill(List<T> list, T obj)metodo

Il fill()metodo sostituisce tutti gli elementi della listraccolta con l' objelemento.

Codice Uscita console 
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);

Collections.fill(list, 10);

for (int i: list)
   System.out.println(i);
 
10
10
10

Collections.nCopies(int n, T obj)metodo

Il nCopies()metodo restituisce un elenco di ncopie dell'elemento obj. Si noti che l'elenco restituito è immutabile, il che significa che non è possibile modificarlo! Puoi usarlo solo per leggere i valori:

Codice Descrizione 
List<String> immutableList = Collections.nCopies(5, "Hello");

ArrayList<String> list = new ArrayList<String>(immutableList);

for(String s: list)
   System.out.println(s);
 Crea un elenco immutabile di 5 Hellostringhe
Crea un mutabile liste riempilo con i valori dell'elenco immutableList.

Uscita console:
Hello
Hello
Hello
Hello
Hello

Collections.replaceAll (List<T> list, T oldValue, T newValue)metodo

Il replaceAll()metodo sostituisce tutti gli elementi nella listraccolta uguale a oldValuecon newValue.

Codice Uscita console 
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);

Collections.replaceAll(list, 2, 20);

for (int i: list)
   System.out.println(i);
 
1
20
3

Collections.copy (List<T> dest, List<T> src)metodo

Il copy()metodo copia tutti gli elementi della srcraccolta nella destraccolta.

Se la destraccolta inizia più a lungo della srcraccolta, gli elementi rimanenti della destraccolta rimarranno intatti.

Importante:
La destcollezione deve essere lunga almeno quanto la srccollezione (altrimenti, IndexOutOfBoundsExceptionverrà lanciata una).
Codice Uscita console 
ArrayList<Integer> srcList = new ArrayList<Integer>();
Collections.addAll(srcList, 99, 98, 97);

ArrayList<Integer> destList = new ArrayList<Integer>();
Collections.addAll(destList, 1, 2, 3, 4, 5, 6, 7);

Collections.copy(destList, srcList);

for (int i: destList)
   System.out.println(i);
 
99
98
97
4
5
6
7

3. Ordine degli elementi

Collections.reverse(List<T> list)metodo

Il reverse()metodo inverte l'ordine degli elementi dell'elenco passato.

Codice Uscita console 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5);

Collections.reverse(list);

for (int i: list)
   System.out.println(i);
 
5
4
3
2
1

Collections.sort(List<T> list)metodo

Il sort()metodo ordina l'elenco passato in ordine crescente.

Codice Uscita console 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 4, 15);

Collections.sort(list);

for (int i: list)
   System.out.println(i);
 
2
4
11
15
23

Collections.rotate(List<T> list, int distance)metodo

Il rotate()metodo sposta ciclicamente gli elementi dell'elenco passato di distanceposizioni in avanti.

Codice Uscita console 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9);

Collections.rotate(list, 3); // Shift by 3 positions

for (int i: list)
   System.out.println(i);
 
7
8
9
1
2
3
4
5
6

Collections.shuffle(List<T> list)metodo

Il shuffle()metodo mescola casualmente tutti gli elementi dell'elenco passato. Il risultato è ogni volta diverso.

Codice Uscita console 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5);

Collections.shuffle(list); // Shuffle the elements

for (int i: list)
   System.out.println(i);
 
5
2
4
3
1

4. Trovare elementi nelle raccolte

Collections.min(Collection<T> colls)metodo

Il min()metodo restituisce l'elemento minimo nella raccolta.

Codice Uscita console 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 4, 15);

int min = Collections.min(list);

System.out.println(min);
 
2

Collections.max(Collection<T> colls)metodo

Il max()metodo restituisce l'elemento massimo nella raccolta.

Codice Uscita console 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 4, 15);

int max = Collections.max(list);

System.out.println(max);
 
23

Collections.frequency(Collection<T> colls, T obj)metodo

Il frequency()metodo conta il numero di volte in cui l' objelemento si verifica nella collsraccolta

Codice Uscita console 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 4, 15, 4, 2, 4);

int count = Collections.frequency(list, 4);

System.out.println(count);
 
3

Collections.binarySearch(Collection<T> colls, T obj)metodo

Il binarySearch()metodo cerca l' objelemento nella collsraccolta. Restituisce l'indice dell'elemento trovato. Restituisce un numero negativo se l'elemento non viene trovato.

Importante:
Prima di chiamare il binarySearch()metodo, la raccolta deve essere ordinata (usa Collections.sort()).
Codice Uscita console 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 11, 2, 23, 5, 15, 4, 2, 4);

Collections.sort(list);  // 2, 2, 4, 4, 5, 11, 15, 23

int index = Collections.binarySearch(list, 5);    // 4
System.out.println(index);

int index2 = Collections.binarySearch(list, 15);  // 6
System.out.println(index2);

int index3 = Collections.binarySearch(list, 16); // The element doesn't exist
System.out.println(index3);
 
4
6
-8

Collections.disjoint(Collection<T> coll1, Collection<T> coll2)metodo

Il disjoint()metodo restituisce truese le raccolte passate non hanno elementi in comune.

Codice Uscita console 
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7);

ArrayList<Integer> list2 = new ArrayList<Integer>();
Collections.addAll(list2, 99, 98, 97);

boolean isDifferent = Collections.disjoint(list, list2);
System.out.println(isDifferent);
 
true