Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Aprenda O Que É Map? | Dominando Map em Java
Estruturas de Dados em Java

bookO Que É Map?

Vamos discutir a interface Map em Java. A interface Map faz parte do framework de Coleções do Java e define métodos para trabalhar com dados na forma de pares chave-valor.

Vamos analisar a definição:

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

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

Main.java

Main.java

copy

              
1

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

Aqui, você vê que nos genéricos ou colchetes em forma de 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 analisar os métodos definidos na interface Map.

Métodos

V put(K key, V value): associa o valor especificado à chave especificada neste Map. Se o Map já continha um mapeamento para a chave, o valor antigo é substituído.

Main.java

Main.java

copy

              
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 Map não contiver mapeamento para a chave.

Aqui é onde especificamos a chave para obter o valor correspondente.

Vamos recuperar o valor com a chave 2:

Main.java

Main.java

copy

              
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 Map contiver um mapeamento para a chave especificada;

  • boolean containsValue(Object value): retorna true se o Map contiver uma ou mais chaves mapeadas para o valor especificado.

Esses dois métodos são claramente relacionados e ajudam a determinar se o Map especificado contém as chaves ou valores desejados. Esses métodos são convenientes para uso em condições, pois retornam valores boolean.

Vamos analisar um exemplo:

Main.java

Main.java

copy

              
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, verifica-se a presença de uma chave e a presença de um valor no Map. Se os valores forem encontrados, eles são exibidos no console. Caso não existam tais valores, são exibidas mensagens indicando a ausência desses dados.

  • boolean isEmpty(): retorna true se este Map não contiver mapeamentos de chave-valor;

  • V remove(Object key): remove o mapeamento para a chave especificada deste Map, se presente, e retorna o valor anterior.

Assim como em outras estruturas de dados, é possível remover elementos do Map.

Main.java

Main.java

copy

              
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, é possível remover elementos pela chave.

Métodos Básicos para Gerenciar Maps

A seguir, estão métodos com os quais você já está familiarizado, que listarei sem exemplos. Mas ainda restam métodos interessantes.

Vamos começar pelo básico:

  • void clear(): remove todos os elementos do Map;

  • int size(): retorna o número de associações chave-valor neste Map;

  • void putAll(Map<? extends K, ? extends V> m): copia todas as associações do Map especificado para este Map.

Agora, vamos para os métodos que retornam uma coleção com valores (ou chaves) do Map. Ou seja, extraímos da estrutura de dados uma estrutura chave-valor que armazena apenas valores (ou chaves). Por exemplo, ArrayList<>.

Main.java

Main.java

copy

              
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, obtivemos uma coleção de valores do Map. Agora, é possível transferir essa coleção para um ArrayList:

Main.java

Main.java

copy

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

Inicialização de um ArrayList utilizando valores provenientes do Map.

Existe também um método que retorna as chaves do Map. No entanto, essas chaves serão retornadas na forma de uma estrutura chamada Set. Não abordaremos essa estrutura de dados neste momento; vale ressaltar que um Set é uma estrutura de dados que contém exclusivamente valores únicos.

Veja este método:

Set<K> keySet(): retorna uma visão do tipo Set das chaves contidas neste Map.

Main.java

Main.java

copy

              
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 obter um conjunto de todas as chaves do Map.

Bem, parece que finalizamos os métodos. Agora, vamos analisar o uso do Map, bem como exemplos práticos:

Uso do Map

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

Vamos criar um Map onde a chave é do tipo String, representando o nome do aluno, e o valor é do tipo Integer, representando a nota do aluno. Dessa forma, é possível atribuir notas aos alunos e recuperar facilmente a nota de um aluno específico utilizando a chave:

Main.java

Main.java

copy

              
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, imagine que precisamos recuperar as notas de Mike e Alice, e então compará-las. Isso pode ser facilmente realizado utilizando os métodos que você aprendeu acima. Vamos implementar isso no código:

Main.java

Main.java

copy

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

O operador ternário e o método compareTo() da classe wrapper Integer foram utilizados. Caso não entenda como funciona, pode ser explicado da seguinte forma:

Main.java

Main.java

copy

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

Agora, considere o seguinte: e se for solicitado reunir todos os alunos com nota superior a 7 (excluindo 7)? Isso se torna interessante, e agora vou explicar como fazer isso!

Iteração através do Map

A iteração sobre elementos em um Map em Java pode ser realizada utilizando vários métodos fornecidos pela interface Map e suas implementações. Aqui estão algumas formas de iterar sobre um Map:

Iterando sobre as chaves (keySet()): o método keySet() retorna um conjunto de todas as chaves no Map. É possível utilizar esse conjunto para iterar sobre as chaves e recuperar os valores correspondentes.

Main.java

Main.java

copy

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

Iteração sobre valores (values()): o método values() retorna uma coleção de todos os valores no Map. Esta coleção pode ser utilizada para iterar sobre os valores.

Main.java

Main.java

copy

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

Iteração sobre pares chave-valor (entrySet()): o método entrySet() retorna um conjunto de objetos Map.Entry que representam pares chave-valor. Isso permite iterar diretamente sobre os pares.

Main.java

Main.java

copy

              
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 nos aprofundar um pouco mais nisso. Inicialmente, pode parecer extremamente complexo de entender, mas não é necessário se preocupar com os detalhes de como funciona, pois a sintaxe é sempre a mesma.

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

Utilizando o objeto entry, é possível acessar tanto a chave quanto o valor no Map simultaneamente. Agora, vamos resolver a tarefa apresentada anteriormente usando o entry set: recuperar todos os alunos com nota maior que 7. Para isso, será feita uma verificação com entry.getValue(), e ao encontrar alunos adequados, suas chaves serão adicionadas a um ArrayList previamente criado:

Main.java

Main.java

copy

              
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, é possível iterar pelo Map e encontrar a lista desejada de estudantes que foram aprovados no exame!

O entry set é uma ferramenta muito útil, pois permite diversas formas de iterar pelo Map usando um loop, tendo acesso tanto à chave quanto ao valor.

No próximo capítulo, vamos explorar como o HashMap, que utilizamos tão ativamente neste capítulo, realmente funciona!

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

2. Como iterar por todas as chaves em 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?

question mark

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

Select the correct answer

question mark

Como iterar por todas as chaves em um Map usando um loop for-each?

Select the correct answer

question mark

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

Select the correct answer

question mark

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

Select the correct answer

question mark

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

Select the correct answer

Tudo estava claro?

Como podemos melhorá-lo?

Obrigado pelo seu feedback!

Seção 3. Capítulo 1

Pergunte à IA

expand

Pergunte à IA

ChatGPT

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

Suggested prompts:

Can you explain more about how HashMap handles collisions?

What are some other implementations of the Map interface besides HashMap?

Can you provide more practical examples of using Map in Java?

bookO Que É Map?

Deslize para mostrar o menu

Vamos discutir a interface Map em Java. A interface Map faz parte do framework de Coleções do Java e define métodos para trabalhar com dados na forma de pares chave-valor.

Vamos analisar a definição:

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

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

Main.java

Main.java

copy

              
1

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

Aqui, você vê que nos genéricos ou colchetes em forma de 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 analisar os métodos definidos na interface Map.

Métodos

V put(K key, V value): associa o valor especificado à chave especificada neste Map. Se o Map já continha um mapeamento para a chave, o valor antigo é substituído.

Main.java

Main.java

copy

              
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 Map não contiver mapeamento para a chave.

Aqui é onde especificamos a chave para obter o valor correspondente.

Vamos recuperar o valor com a chave 2:

Main.java

Main.java

copy

              
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 Map contiver um mapeamento para a chave especificada;

  • boolean containsValue(Object value): retorna true se o Map contiver uma ou mais chaves mapeadas para o valor especificado.

Esses dois métodos são claramente relacionados e ajudam a determinar se o Map especificado contém as chaves ou valores desejados. Esses métodos são convenientes para uso em condições, pois retornam valores boolean.

Vamos analisar um exemplo:

Main.java

Main.java

copy

              
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, verifica-se a presença de uma chave e a presença de um valor no Map. Se os valores forem encontrados, eles são exibidos no console. Caso não existam tais valores, são exibidas mensagens indicando a ausência desses dados.

  • boolean isEmpty(): retorna true se este Map não contiver mapeamentos de chave-valor;

  • V remove(Object key): remove o mapeamento para a chave especificada deste Map, se presente, e retorna o valor anterior.

Assim como em outras estruturas de dados, é possível remover elementos do Map.

Main.java

Main.java

copy

              
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, é possível remover elementos pela chave.

Métodos Básicos para Gerenciar Maps

A seguir, estão métodos com os quais você já está familiarizado, que listarei sem exemplos. Mas ainda restam métodos interessantes.

Vamos começar pelo básico:

  • void clear(): remove todos os elementos do Map;

  • int size(): retorna o número de associações chave-valor neste Map;

  • void putAll(Map<? extends K, ? extends V> m): copia todas as associações do Map especificado para este Map.

Agora, vamos para os métodos que retornam uma coleção com valores (ou chaves) do Map. Ou seja, extraímos da estrutura de dados uma estrutura chave-valor que armazena apenas valores (ou chaves). Por exemplo, ArrayList<>.

Main.java

Main.java

copy

              
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, obtivemos uma coleção de valores do Map. Agora, é possível transferir essa coleção para um ArrayList:

Main.java

Main.java

copy

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

Inicialização de um ArrayList utilizando valores provenientes do Map.

Existe também um método que retorna as chaves do Map. No entanto, essas chaves serão retornadas na forma de uma estrutura chamada Set. Não abordaremos essa estrutura de dados neste momento; vale ressaltar que um Set é uma estrutura de dados que contém exclusivamente valores únicos.

Veja este método:

Set<K> keySet(): retorna uma visão do tipo Set das chaves contidas neste Map.

Main.java

Main.java

copy

              
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 obter um conjunto de todas as chaves do Map.

Bem, parece que finalizamos os métodos. Agora, vamos analisar o uso do Map, bem como exemplos práticos:

Uso do Map

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

Vamos criar um Map onde a chave é do tipo String, representando o nome do aluno, e o valor é do tipo Integer, representando a nota do aluno. Dessa forma, é possível atribuir notas aos alunos e recuperar facilmente a nota de um aluno específico utilizando a chave:

Main.java

Main.java

copy

              
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, imagine que precisamos recuperar as notas de Mike e Alice, e então compará-las. Isso pode ser facilmente realizado utilizando os métodos que você aprendeu acima. Vamos implementar isso no código:

Main.java

Main.java

copy

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

O operador ternário e o método compareTo() da classe wrapper Integer foram utilizados. Caso não entenda como funciona, pode ser explicado da seguinte forma:

Main.java

Main.java

copy

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

Agora, considere o seguinte: e se for solicitado reunir todos os alunos com nota superior a 7 (excluindo 7)? Isso se torna interessante, e agora vou explicar como fazer isso!

Iteração através do Map

A iteração sobre elementos em um Map em Java pode ser realizada utilizando vários métodos fornecidos pela interface Map e suas implementações. Aqui estão algumas formas de iterar sobre um Map:

Iterando sobre as chaves (keySet()): o método keySet() retorna um conjunto de todas as chaves no Map. É possível utilizar esse conjunto para iterar sobre as chaves e recuperar os valores correspondentes.

Main.java

Main.java

copy

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

Iteração sobre valores (values()): o método values() retorna uma coleção de todos os valores no Map. Esta coleção pode ser utilizada para iterar sobre os valores.

Main.java

Main.java

copy

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

Iteração sobre pares chave-valor (entrySet()): o método entrySet() retorna um conjunto de objetos Map.Entry que representam pares chave-valor. Isso permite iterar diretamente sobre os pares.

Main.java

Main.java

copy

              
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 nos aprofundar um pouco mais nisso. Inicialmente, pode parecer extremamente complexo de entender, mas não é necessário se preocupar com os detalhes de como funciona, pois a sintaxe é sempre a mesma.

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

Utilizando o objeto entry, é possível acessar tanto a chave quanto o valor no Map simultaneamente. Agora, vamos resolver a tarefa apresentada anteriormente usando o entry set: recuperar todos os alunos com nota maior que 7. Para isso, será feita uma verificação com entry.getValue(), e ao encontrar alunos adequados, suas chaves serão adicionadas a um ArrayList previamente criado:

Main.java

Main.java

copy

              
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, é possível iterar pelo Map e encontrar a lista desejada de estudantes que foram aprovados no exame!

O entry set é uma ferramenta muito útil, pois permite diversas formas de iterar pelo Map usando um loop, tendo acesso tanto à chave quanto ao valor.

No próximo capítulo, vamos explorar como o HashMap, que utilizamos tão ativamente neste capítulo, realmente funciona!

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

2. Como iterar por todas as chaves em 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?

question mark

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

Select the correct answer

question mark

Como iterar por todas as chaves em um Map usando um loop for-each?

Select the correct answer

question mark

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

Select the correct answer

question mark

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

Select the correct answer

question mark

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

Select the correct answer

Tudo estava claro?

Como podemos melhorá-lo?

Obrigado pelo seu feedback!

Seção 3. Capítulo 1
some-alt