Tipos genéricos
Um tipo genérico é uma classe ou interface genérica que é parametrizada por tipos.
Isso permite que o compilador garanta a segurança de tipos na classe ou na interface.
Considere esta interface Container, que não é genérica:
class Container {
private Object object;
public void set(Object object) { this.object = object; }
public Object get() { return object; }
}
Como ela aceita e retorna tipos Object, funciona com qualquer tipo não primitivo.
No entanto, isso tem um custo: um trecho de código pode chamar get esperando Integers, enquanto outro chama set adicionando Strings, o que resulta em uma exceção em tempo de execução.
Uma classe genérica e uma interface genérica têm o seguinte formato:
class ClassName<T1, T2, ..., Tn> { ... }
interface InterfaceName<T1, T2, ..., Tn> { ... }
A seção de parâmetros de tipo, delimitada pelos sinais de maior e menor (<>), logo depois do nome da classe ou da interface, especifica os parâmetros de tipo (também chamados de variáveis de tipo) T1, T2, ..., e Tn.
Eles podem ser usados dentro do corpo da classe ou da interface para obter a segurança de tipos genérica.
Aqui está a versão genérica de Container:
class Container<E> {
private E object;
public void set(E object) { this.object = object; }
public E get() { return object; }
}
Ao criá-la, agora precisamos declarar qual tipo ela armazena, e o compilador vai garantir essa restrição:
// empty <> can infer from context
Container<String> stringContainer = new Container<>();
// compiler knows this is a String, so it is allowed
stringContainer.set("Some string");
// no cast needed, compiler knows it is a String
String result = stringContainer.get();
// this causes a compiler error:
stringContainer.set(42);
Listas
As listas são a coleção de sequências ordenadas do Java.
Diferente dos arrays, uma List pode crescer de tamanho para acomodar qualquer número de itens.
Uma implementação padrão é a ArrayList, que é sustentada por um array redimensionável.
Outra implementação padrão é a classe LinkedList, que é sustentada por uma lista duplamente encadeada.
As Lists podem estar vazias ou conter qualquer número de itens (incluindo duplicatas).
As Lists são uma interface genérica tipada para indicar qual tipo de objeto elas podem conter.
Por exemplo:
List<String> emptyListOfStrings = List.of();
List<Integer> singleInteger = List.of(1);
List<Boolean> threeBooleans = List.of(true, false, true);
List<Object> listWithMultipleTypes = List.of("hello", 1, true);
As Lists têm vários métodos úteis para adicionar, remover, obter e verificar se um elemento está presente:
List<Character> vowels = new ArrayList<>(List.of('a', 'e', 'i', 'o', 'i', 'e', 'a'));
int startingSize = vowels.size(); // 7
vowels.add('u'); // vowels is now ['a', 'e', 'i', 'o', 'i', 'e', 'a', 'u']
char a = vowels.get(0); // 'a'
boolean hadI = vowels.remove('i'); // true and vowels is now ['a', 'e', 'o', 'i', 'e', 'a', 'u']
boolean hasI = vowels.contains('i'); // true (still have one more left)
Exercício de aprendizagem
