1. Lista de métodos

Lembra que os criadores de Java escreveram toda uma classe auxiliar chamada Arrayspara nossa conveniência ao trabalhar com arrays?

Eles fizeram a mesma coisa para coleções. Java tem uma java.util.Collectionsclasse que possui muitos métodos úteis para trabalhar com coleções. Aqui estão apenas os mais interessantes:

Métodos Descrição 
addAll(colls, e1, e2, e3, ...)
 Adiciona os elementos e1, e2, e3, ... à collscoleção 
fill(list, obj)
 Substitui todos os elementos na lista passada porobj 
nCopies(n, obj)
 Retorna uma lista de ncópias do objobjeto 
replaceAll(list, oldVal, newVal)
 Substitui todas as instâncias de oldValpor newValna listlista 
copy(dest, src)
 Copia todos os elementos da srclista para a destlista 
reverse(list)
 Inverte a lista. 
sort(list)
 Classifica a lista em ordem crescente 
rotate(list, n)
 Desloca ciclicamente os elementos da listlista por nelementos 
shuffle(list)
 Embaralha aleatoriamente os elementos na lista 
min(colls)
 Encontra o elemento mínimo na collscoleção 
max(colls)
 Encontra o elemento máximo na collscoleção 
frequency(colls, obj)
 Determina quantas vezes o objelemento ocorre na collscoleção 
binarySearch(list, key)
 Pesquisa keyem uma lista classificada e retorna o índice correspondente. 
disjoint(colls1, colls2)
 Retorna truese as coleções não tiverem elementos em comum
Importante:

Muitos desses métodos não usam as classes ArrayList, HashSete HashMapper se, mas com as interfaces correspondentes: Collection<T>, List<T>, Map<K, V>.

Isso não é um problema: se um método aceita um List<T>, você sempre pode passar um ArrayList<Integer>, mas o operador de atribuição não funciona na direção oposta.

Java webinar

2. Criando e modificando coleções

Collections.addAll(Collection<T> colls, T e1, T e2, T e3, ...)método

O addAll()método adiciona os elementos e1, e2, e3, ... à collscoleção. Qualquer número de elementos pode ser passado.

Código Saída do 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)método

O fill()método substitui todos os elementos da listcoleção pelo objelemento.

Código Saída do 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)método

O nCopies()método retorna uma lista de ncópias do objelemento. Observe que a lista retornada é imutável, o que significa que você não pode alterá-la! Você só pode usá-lo para ler valores:

Código Descrição 
List<String> immutableList = Collections.nCopies(5, "Hello");

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

for(String s: list)
   System.out.println(s);
 Crie uma lista imutável de 5 Hellostrings
Crie uma lista mutável liste preencha-a com os valores da immutableListlista.

Saída do console:
Hello
Hello
Hello
Hello
Hello

Collections.replaceAll (List<T> list, T oldValue, T newValue)método

O replaceAll()método substitui todos os elementos da listcoleção igual a oldValuecom newValue.

Código Saída do 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)método

O copy()método copia todos os elementos da srccoleção para a destcoleção.

Se a destcoleção começar mais do que a srccoleção, os elementos restantes da destcoleção permanecerão intactos.

Importante:
A destcoleção deve ser pelo menos tão longa quanto a srccoleção (caso contrário, um IndexOutOfBoundsExceptionserá lançado).
Código Saída do 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. Ordem dos elementos

Collections.reverse(List<T> list)método

O reverse()método inverte a ordem dos elementos da lista passada.

Código Saída do 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)método

O sort()método classifica a lista passada em ordem crescente.

Código Saída do 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)método

O rotate()método desloca ciclicamente os elementos da lista passada por distanceposições para frente.

Código Saída do 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)método

O shuffle()método embaralha aleatoriamente todos os elementos da lista passada. O resultado é diferente a cada vez.

Código Saída do 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. Encontrando elementos em coleções

Collections.min(Collection<T> colls)método

O min()método retorna o elemento mínimo na coleção.

Código Saída do 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)método

O max()método retorna o elemento máximo na coleção.

Código Saída do 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)método

O frequency()método conta o número de vezes que o objelemento ocorre na collscoleção

Código Saída do 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)método

O binarySearch()método procura o objelemento na collscoleção. Retorna o índice do elemento encontrado. Retorna um número negativo se o elemento não for encontrado.

Importante:
Antes de chamar o binarySearch()método, a coleção deve ser classificada (use Collections.sort()).
Código Saída do 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)método

O disjoint()método retorna truese as coleções passadas não tiverem nenhum elemento em comum.

Código Saída do 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