As linguagens do Karl

Tipos genéricos

Um tipo genérico é uma classe ou interface genérica parametrizada sobre tipos. Isto permite que o compilador imponha a segurança de tipos à classe ou à interface.

Considera esta interface Container não genérica:

class Container {
    private Object object;

    public void set(Object object) { this.object = object; }
    public Object get() { return object; }
}

Uma vez que aceita e devolve tipos Object, funciona com qualquer tipo não primitivo. No entanto, isto tem um custo: algum código pode chamar get à espera de Integers, enquanto outro código chama set a acrescentar Strings, o que resulta numa exceção em tempo de execução.

Uma classe genérica e uma interface genérica têm os seguintes formatos:

class ClassName<T1, T2, ..., Tn> { ... }
interface InterfaceName<T1, T2, ..., Tn> { ... }

A secção de parâmetros de tipo, delimitada por sinais de menor e maior (<>) a seguir ao nome da classe ou da interface, especifica os parâmetros de tipo (também chamados variáveis de tipo) T1, T2, ..., e Tn. Podem ser usados dentro do corpo da classe ou da interface para obter segurança de tipos genéricos.

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; }
}

Quando a criamos, passamos a ter de declarar que tipo contém, e o compilador impõe 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

Em Java, as listas são a coleção de sequências ordenadas. Ao contrário dos arrays, uma List pode crescer para acomodar qualquer número de elementos. Uma implementação padrão é a ArrayList, suportada por um array redimensionável. Outra implementação padrão é a classe LinkedList, suportada por uma lista duplamente ligada.

As Lists podem estar vazias ou conter qualquer número de elementos (incluindo duplicados). As Lists são uma interface genérica tipada para indicar que tipo de objetos 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)