14-Map.md

Map

A última coleção que iremos falar é o Map, é uma coleção baseada em chave e valor. No capítulo sobre os Sets uma das implementações de Map foi mencionada, sendo ela o HashMap, neste capítulo iremos falar sobre três implementações de Map, assim como fizemos com os Sets, sendo elas:

• HashMap.
  • Uma implementação baseada em HashTable.
• LinkedHashMap.
  • Uma implementação que se utiliza uma HashTable e Linked List.
• TreeMap.
  • Uma implementação baseada em Red Black Tree, necessario a implementação da interface Comparator, ela mantém a ordenação de acordo com a estrutura de árvore. Temos um exemplo de implementação aqui.

Todas as implementações têm usos parecidos, por este motivo iremos demonstrar com apenas uma de suas implementações. Claro todas tem as suas ressalvas, tem prós e contras, vem do desenvolvedor saber o local correto de sua utilização.

Trabalhando com o Map

Para criarmos as instâncias de Map seguimos o seguinte padrão: Map<Chave, Valor> nome = new Implementacao<>():

public class App {
    public static void main(String[] args) {
        Map<String, String> hashMap = new HashMap<>();
        Map<String, String> linkedHashMap = new LinkedHashMap<>();
        Map<String, String> treeMap = new TreeMap<>();
    }
}

Diferentes das listas e sets não temos o método add, para adicionarmos itens em um Map utilizamos o método put.

public class App {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("chave", "valor");
    }
}

Caso o valor já exista no Map ele é substituído pelo novo valor:

public class App {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("chave", "valor");
        map.put("chave", "novo valor");
    }
}

Para remover algum ‘item’ do Map temos o método remove onde temos uma sobrecarga bem interessante onde só é feita a remoção da chave caso o valor seja igual ao passado.

public class App {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("chave", "valor");
        map.put("chave2", "valor2");
        map.remove("chave"); //remoção da chave com sucesso
        map.remove("chave2", "papagaio"); //não acontece a remoção da chave 2
    }
}

Também podemos recuperar o valor de uma chave em um Map utilizando o método get ou se quisermos saber se a chave existe antes de buscar, utilizamos o método containsKey, caso o valor não exista o método get ira retornar o valor null, e o método containsKey ira retornar false.

public class App {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("chave", "valor");
        map.put("chave2", "valor2");
        String valorChave = map.get("chave"); //valor
        String chaveInexistente = map.get("aurora"); //null

        if (map.containsKey("chave2")) {
            String valorChave2 = map.get("chave2");
        } else {
            //qualquer outro tratamento
        }
    }
}

Podemos também iterar um Map através de um Set de chaves utilizando o método keySet, onde nos é retornado um Set com todas as chaves inseridas neste Map.

public class App {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("chave", "valor");
        map.put("chave2", "valor2");
        Set<String> chaves = map.keySet();
        for(String chave: chaves) {
            System.out.println("Chave: " + chave + ", valor: " + map.get(chave));
        }
    }
}

Também podemos percorrer os valores de um Map com o método values, este método nos retorna uma Collection contendo os valores

public class App {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("chave", "valor");
        map.put("chave2", "valor2");
        Collection<String> valores = map.values();
        for(String valor: valores) {
            System.out.println("Valor: " + valor);
        }
    }
}

Temos outros métodos como isEmpty, clear, size, que tem o mesmo comportamento das outras coleções já apresentadas.

Imutabilidade

Assim como já discutido no capítulo de Listas imutáveis os Map's também tem suas versões imutáveis, sendo elas utilizando o Collections.unmodifiableMap onde não permite o uso do método put ou replace ou Map.of, este método em específico acima da versão 8, o comportamento é parecido com o das listas imutáveis, porém com o modo de uso um pouco diferente.

public class App {
    public static void main(String[] args) {
        Map<String, String> mapImutavel = Map.of(
            "chave1", "valor1",
            "chave2", "valor2",
            "chave3", "valor3"
            //.......
        );
    }
}

Próximo - Genéricos