Finalmente, avançamos para estruturas de dados verdadeiramente complexas e intrigantes. Hoje, vamos discutir a interface Map em Java. A interface Map faz parte do framework de Coleções Java e define métodos para trabalhar com dados na forma de pares chave-valor.

Vamos dar uma olhada na definição:

A implementação principal de tal estrutura de dados em Java é HashMap, que implementa a interface Map. Vamos explorar os principais métodos e os princípios operacionais desta implementação.

Começaremos com a declaração e os métodos:

main.java


              1
            
Map<K, V> map = new HashMap<>();

Aqui, vemos que nos genéricos ou colchetes diamante, dois valores são especificados:

O valor K corresponde ao tipo de dado da chave.
O valor V corresponde ao tipo de dado do valor.

Assim, ao declarar essa estrutura de dados, indicamos os tipos de dados dos nossos valores chave-valor.

Agora, vamos examinar os métodos definidos na interface Map:

V put(K chave, V valor):
Associa o valor especificado à chave especificada neste mapa. Se o mapa continha previamente um mapeamento para a chave, o valor antigo é substituído.

Nota

No caso de usar HashMap<>(), ao inserir múltiplos valores com a mesma chave, ocorre uma colisão. Exploraremos o princípio de funcionamento do HashMap mais adiante nesta seção.

main.java


              1234567891011121314
            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println(map);
    }
}

V get(Object key):
- Retorna o valor ao qual a chave especificada está mapeada, ou null se este mapa não contém mapeamento para a chave.

Aqui é onde nós especificamos a chave para recuperar o valor correspondente.

Vamos recuperar o valor com a chave 2:

main.java


              12345678910111213141516
            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String value = map.get(2);
        System.out.println("Value: " + value);
    }
}

boolean containsKey(Object key):
- Retorna true se o mapa contém uma associação para a chave especificada.
boolean containsValue(Object value):
- Retorna true se o mapa contém uma ou mais chaves mapeadas para o valor especificado.

Esses dois métodos são claramente relacionados e ajudam a determinar se o mapa especificado contém as chaves ou valores desejados. Esses métodos são convenientes para usar como condições, uma vez que retornam valores boolean.

Vamos olhar um exemplo:

main.java


              12345678910111213141516171819202122232425
            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        if (map.containsKey(2)) {
            System.out.println("Value with key 2: " + map.get(2));
        } else {
            System.out.println("There is no value with key 2!");
        }

        if (map.containsValue("Four")) {
            System.out.println(map.get(4));
        } else {
            System.out.println("There is no key with value \"Four\"!");
        }
    }
}

No exemplo acima, verificamos a presença de uma chave e a presença de um valor no mapa. Se valores forem encontrados, nós os exibimos no console. Se não houver tais valores, exibimos mensagens indicando a ausência desses dados.

boolean isEmpty():
- Retorna true se este mapa não contiver nenhuma associação de chave-valor.
V remove(Object key):
- Remove a associação para a chave especificada deste mapa, se estiver presente, e retorna o valor anterior.

Assim como em outras estruturas de dados, podemos remover elementos do mapa.

Nota

Ao usar HashMap, todos os valores sob uma única chave serão removidos. Vamos explorar isso com mais detalhes mais adiante nesta seção.

main.java


              12345678910111213141516
            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String removedElement = map.remove(3);
        System.out.println("Removed value: " + removedElement + ".\nMap after the removal operation: " + map);
    }
}

Assim, podemos remover elementos pela chave.

A seguir, há métodos com os quais você já está familiarizado, que vou listar sem exemplos. Mas ainda há métodos interessantes a serem vistos.

Vamos começar com o básico:

void clear():
- Remove todos os elementos do mapa.
int size():
- Retorna o número de mapeamentos de chave-valor neste mapa.
void putAll(Map<? extends K, ? extends V> m):
- Copia todos os mapeamentos do mapa especificado para este mapa.

Agora, vamos passar para os métodos que retornam uma coleção com valores (ou chaves) do mapa. Em outras palavras, recuperamos da estrutura de dados uma estrutura chave-valor que armazena apenas valores (ou chaves). Por exemplo, ArrayList<>.

main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> list;
        list = map.values();
        System.out.println("Values" + list);
    }
}

Aqui, nós obtivemos uma coleção de valores do mapa. Agora, podemos transferir esta coleção para um ArrayList:

main.java


              123456789101112131415161718
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> collection;
        collection = map.values();
        System.out.println("Values" + collection);
        List<String> arrayList = new ArrayList<>(collection);
        System.out.println("ArrayList: " + arrayList);
    }
}

Inicializamos um ArrayList usando valores do mapa.

Existe também um método que retorna chaves do mapa. No entanto, essas chaves serão retornadas na forma de uma estrutura chamada Set. Não vamos nos aprofundar nessa estrutura de dados agora; vale a pena mencionar que um Set é uma estrutura de dados que contém exclusivamente valores únicos.

Vamos olhar para este método:

Set<K> keySet():
- Retorna uma visão em Set das chaves contidas neste mapa.

main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Set<Integer> keys;
        keys = map.keySet();
        System.out.println("Keys: " + keys);
    }
}

Assim, também podemos recuperar um conjunto de todas as chaves do mapa.

Pois bem, parece que terminamos com os métodos. Vamos agora dar uma olhada no uso do mapa, assim como em exemplos práticos:

Uso de Map

Uma estrutura como chave-valor tem muitas aplicações práticas. Vamos considerar a mais simples dessas estruturas: um sistema de notas de estudantes.

Vamos criar um mapa onde a chave é do tipo String, representando o nome do aluno, e o valor é do tipo Integer, representando a nota do aluno. Assim, podemos atribuir notas aos alunos e facilmente recuperar a nota de um aluno específico usando a chave:

main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
    }
}

Agora, vamos imaginar que nossa tarefa é recuperar as notas de Mike e Alice e, em seguida, compará-las. Podemos realizar isso facilmente utilizando os métodos que aprendemos anteriormente. Vamos implementar isso no código:

main.java


              123456789101112131415161718192021
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        System.out.println(mikeGrade.compareTo(aliceGrade) == -1 ? "Alice's grade is higher": "Mike's grade is higher");
    }
}

Utilizei o operador ternário e o método compareTo() da classe empacotadora Integer. Caso você não compreenda como ele funciona, pode ser explicado da seguinte forma:

main.java


              12345678910111213141516171819202122232425
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        if (mikeGrade.compareTo(aliceGrade) == -1) {
            System.out.println("Alice's grade is higher");
        } else {
            System.out.println("Mike's grade is higher");
        }
    }
}

Nota

Se você pensar bem, essas consultas são muito semelhantes a consultas SQL. Se você está familiarizado com SQL, será muito mais fácil para você entender a interação com diferentes estruturas de dados e bancos de dados.

Agora, vamos considerar o que acontece se nos pedirem para reunir todos os alunos com nota superior a 7 (excluindo o 7). Isso se torna interessante, e agora vou explicar como fazer isso!

Iteração pelo map

Iterar sobre elementos em um Map em Java pode ser feito usando vários métodos fornecidos pela interface Map e suas implementações. Aqui estão algumas maneiras de iterar sobre um Map:

Iterando sobre Chaves (keySet()):
- O método keySet() retorna um conjunto de todas as chaves no Map. Você pode usar esse conjunto para iterar sobre as chaves e recuperar os valores correspondentes.

main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (String key : map.keySet()) {
            Integer value = map.get(key);
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

Iterar sobre Valores (values()):
O método values() retorna uma coleção de todos os valores no Map. Você pode usar esta coleção para iterar sobre os valores.

main.java


              123456789101112131415
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Integer value : map.values()) {
            System.out.println("Value: " + value);
        }
    }
}

Iterando sobre Pares Chave-Valor (entrySet()):
O método entrySet() retorna um conjunto de objetos Map.Entry que representam pares de chave-valor. Isso permite a iteração direta sobre os pares.

main.java


              1234567891011121314151617
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

Vamos explorar isso de forma mais aprofundada. Inicialmente, pode parecer extremamente complexo de entender, mas você não precisa entrar nos detalhes de como isso funciona, já que a sintaxe é sempre a mesma:

Map.Entry<K, V> entry : map.entrySet()

Usando o objeto entry, podemos acessar simultaneamente tanto a chave quanto o valor no mapa. Agora, vamos resolver a tarefa mencionada anteriormente usando o conjunto de entradas: recuperar todos os estudantes com uma nota superior a 7. Para isso, utilizaremos uma verificação por meio de entry.getValue(), e quando encontrarmos os estudantes adequados, vamos obter suas chaves para um ArrayList previamente criado:

main.java


              1234567891011121314151617181920212223242526
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
        
        List<String> studentsWithGradeHigherThanSeven = new ArrayList<>();
        
        for (Map.Entry<String, Integer> entry : studentsGrades.entrySet()) {
            if (entry.getValue() > 7) {
                studentsWithGradeHigherThanSeven.add(entry.getKey());
            }
        
        }
        System.out.println(studentsWithGradeHigherThanSeven);
    }
}

Assim, podemos iterar pelo mapa e encontrar a lista desejada de estudantes que passaram no exame!

O conjunto de entradas é uma ferramenta muito útil, pois permite várias formas de iterar pelo mapa usando um loop, tendo acesso tanto à chave quanto ao valor.

No próximo capítulo, vamos aprofundar em como o HashMap, que usamos ativamente neste capítulo, realmente funciona!

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 3. Capítulo 1

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Suggested prompts:

What are some common use cases for the Map interface in Java?

Can you explain the difference between HashMap and other Map implementations?

How does HashMap handle key collisions?

Deslize para mostrar o menu

Vamos dar uma olhada na definição:

Começaremos com a declaração e os métodos:

main.java


              1
            
Map<K, V> map = new HashMap<>();

Aqui, vemos que nos genéricos ou colchetes diamante, dois valores são especificados:

O valor K corresponde ao tipo de dado da chave.
O valor V corresponde ao tipo de dado do valor.

Assim, ao declarar essa estrutura de dados, indicamos os tipos de dados dos nossos valores chave-valor.

Agora, vamos examinar os métodos definidos na interface Map:

V put(K chave, V valor):
Associa o valor especificado à chave especificada neste mapa. Se o mapa continha previamente um mapeamento para a chave, o valor antigo é substituído.

Nota

No caso de usar HashMap<>(), ao inserir múltiplos valores com a mesma chave, ocorre uma colisão. Exploraremos o princípio de funcionamento do HashMap mais adiante nesta seção.

main.java


              1234567891011121314
            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println(map);
    }
}

V get(Object key):
- Retorna o valor ao qual a chave especificada está mapeada, ou null se este mapa não contém mapeamento para a chave.

Aqui é onde nós especificamos a chave para recuperar o valor correspondente.

Vamos recuperar o valor com a chave 2:

main.java


              12345678910111213141516
            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String value = map.get(2);
        System.out.println("Value: " + value);
    }
}

boolean containsKey(Object key):
- Retorna true se o mapa contém uma associação para a chave especificada.
boolean containsValue(Object value):
- Retorna true se o mapa contém uma ou mais chaves mapeadas para o valor especificado.

Vamos olhar um exemplo:

main.java


              12345678910111213141516171819202122232425
            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        if (map.containsKey(2)) {
            System.out.println("Value with key 2: " + map.get(2));
        } else {
            System.out.println("There is no value with key 2!");
        }

        if (map.containsValue("Four")) {
            System.out.println(map.get(4));
        } else {
            System.out.println("There is no key with value \"Four\"!");
        }
    }
}

boolean isEmpty():
- Retorna true se este mapa não contiver nenhuma associação de chave-valor.
V remove(Object key):
- Remove a associação para a chave especificada deste mapa, se estiver presente, e retorna o valor anterior.

Assim como em outras estruturas de dados, podemos remover elementos do mapa.

Nota

Ao usar HashMap, todos os valores sob uma única chave serão removidos. Vamos explorar isso com mais detalhes mais adiante nesta seção.

main.java


              12345678910111213141516
            
package com.example;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String removedElement = map.remove(3);
        System.out.println("Removed value: " + removedElement + ".\nMap after the removal operation: " + map);
    }
}

Assim, podemos remover elementos pela chave.

A seguir, há métodos com os quais você já está familiarizado, que vou listar sem exemplos. Mas ainda há métodos interessantes a serem vistos.

Vamos começar com o básico:

void clear():
- Remove todos os elementos do mapa.
int size():
- Retorna o número de mapeamentos de chave-valor neste mapa.
void putAll(Map<? extends K, ? extends V> m):
- Copia todos os mapeamentos do mapa especificado para este mapa.

main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> list;
        list = map.values();
        System.out.println("Values" + list);
    }
}

Aqui, nós obtivemos uma coleção de valores do mapa. Agora, podemos transferir esta coleção para um ArrayList:

main.java


              123456789101112131415161718
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> collection;
        collection = map.values();
        System.out.println("Values" + collection);
        List<String> arrayList = new ArrayList<>(collection);
        System.out.println("ArrayList: " + arrayList);
    }
}

Inicializamos um ArrayList usando valores do mapa.

Vamos olhar para este método:

Set<K> keySet():
- Retorna uma visão em Set das chaves contidas neste mapa.

main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Set<Integer> keys;
        keys = map.keySet();
        System.out.println("Keys: " + keys);
    }
}

Assim, também podemos recuperar um conjunto de todas as chaves do mapa.

Pois bem, parece que terminamos com os métodos. Vamos agora dar uma olhada no uso do mapa, assim como em exemplos práticos:

Uso de Map

Uma estrutura como chave-valor tem muitas aplicações práticas. Vamos considerar a mais simples dessas estruturas: um sistema de notas de estudantes.

main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
    }
}

main.java


              123456789101112131415161718192021
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        System.out.println(mikeGrade.compareTo(aliceGrade) == -1 ? "Alice's grade is higher": "Mike's grade is higher");
    }
}

Utilizei o operador ternário e o método compareTo() da classe empacotadora Integer. Caso você não compreenda como ele funciona, pode ser explicado da seguinte forma:

main.java


              12345678910111213141516171819202122232425
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        if (mikeGrade.compareTo(aliceGrade) == -1) {
            System.out.println("Alice's grade is higher");
        } else {
            System.out.println("Mike's grade is higher");
        }
    }
}

Nota

Se você pensar bem, essas consultas são muito semelhantes a consultas SQL. Se você está familiarizado com SQL, será muito mais fácil para você entender a interação com diferentes estruturas de dados e bancos de dados.

Agora, vamos considerar o que acontece se nos pedirem para reunir todos os alunos com nota superior a 7 (excluindo o 7). Isso se torna interessante, e agora vou explicar como fazer isso!

Iteração pelo map

Iterar sobre elementos em um Map em Java pode ser feito usando vários métodos fornecidos pela interface Map e suas implementações. Aqui estão algumas maneiras de iterar sobre um Map:

Iterando sobre Chaves (keySet()):
- O método keySet() retorna um conjunto de todas as chaves no Map. Você pode usar esse conjunto para iterar sobre as chaves e recuperar os valores correspondentes.

main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (String key : map.keySet()) {
            Integer value = map.get(key);
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

Iterar sobre Valores (values()):
O método values() retorna uma coleção de todos os valores no Map. Você pode usar esta coleção para iterar sobre os valores.

main.java


              123456789101112131415
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Integer value : map.values()) {
            System.out.println("Value: " + value);
        }
    }
}

Iterando sobre Pares Chave-Valor (entrySet()):
O método entrySet() retorna um conjunto de objetos Map.Entry que representam pares de chave-valor. Isso permite a iteração direta sobre os pares.

main.java


              1234567891011121314151617
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

Map.Entry<K, V> entry : map.entrySet()

main.java


              1234567891011121314151617181920212223242526
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
        
        List<String> studentsWithGradeHigherThanSeven = new ArrayList<>();
        
        for (Map.Entry<String, Integer> entry : studentsGrades.entrySet()) {
            if (entry.getValue() > 7) {
                studentsWithGradeHigherThanSeven.add(entry.getKey());
            }
        
        }
        System.out.println(studentsWithGradeHigherThanSeven);
    }
}

Assim, podemos iterar pelo mapa e encontrar a lista desejada de estudantes que passaram no exame!

O conjunto de entradas é uma ferramenta muito útil, pois permite várias formas de iterar pelo mapa usando um loop, tendo acesso tanto à chave quanto ao valor.

No próximo capítulo, vamos aprofundar em como o HashMap, que usamos ativamente neste capítulo, realmente funciona!

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 3. Capítulo 1

O que é Mapa?

Uso de Map

Iteração pelo map

1. Qual interface em Java representa uma coleção de pares chave-valor?

2. Como você percorre todas as chaves de um `Map` usando um loop for-each?

3. Qual é o propósito do método `values()` em um `Map`?

4. Qual método é utilizado para verificar se uma chave específica está presente em um `Map`?

5. Qual método é utilizado para remover um par chave-valor de um `Map` em Java?

Awesome!

O que é Mapa?

Uso de Map

Iteração pelo map

1. Qual interface em Java representa uma coleção de pares chave-valor?

2. Como você percorre todas as chaves de um `Map` usando um loop for-each?

3. Qual é o propósito do método `values()` em um `Map`?

4. Qual método é utilizado para verificar se uma chave específica está presente em um `Map`?

5. Qual método é utilizado para remover um par chave-valor de um `Map` em Java?

O que é Mapa?

Uso de Map

Iteração pelo map

1. Qual interface em Java representa uma coleção de pares chave-valor?

2. Como você percorre todas as chaves de um Map usando um loop for-each?

3. Qual é o propósito do método values() em um Map?

4. Qual método é utilizado para verificar se uma chave específica está presente em um Map?

5. Qual método é utilizado para remover um par chave-valor de um Map em Java?

Awesome!

O que é Mapa?

Uso de Map

Iteração pelo map

1. Qual interface em Java representa uma coleção de pares chave-valor?

2. Como você percorre todas as chaves de um Map usando um loop for-each?

3. Qual é o propósito do método values() em um Map?

4. Qual método é utilizado para verificar se uma chave específica está presente em um Map?

5. Qual método é utilizado para remover um par chave-valor de um Map em Java?

2. Como você percorre todas as chaves de um `Map` usando um loop for-each?

3. Qual é o propósito do método `values()` em um `Map`?

4. Qual método é utilizado para verificar se uma chave específica está presente em um `Map`?

5. Qual método é utilizado para remover um par chave-valor de um `Map` em Java?

2. Como você percorre todas as chaves de um `Map` usando um loop for-each?

3. Qual é o propósito do método `values()` em um `Map`?

4. Qual método é utilizado para verificar se uma chave específica está presente em um `Map`?

5. Qual método é utilizado para remover um par chave-valor de um `Map` em Java?