Skip to content

Commit 528acbb

Browse files
pgjbzpgjbz
committed
Colecao Map
1 parent d5e5cb5 commit 528acbb

File tree

4 files changed

+183
-1
lines changed

4 files changed

+183
-1
lines changed

‎4 - Intermediário/09-Sets.md

+3-1
Original file line numberDiff line numberDiff line change
@@ -87,4 +87,6 @@ O modo de trabalho com o TreeSet é praticamente o mesmo dos já mostrados aqui,
8787

8888
### Imutabilidade
8989

90-
Assim como já discutido no [capítulo anterior](./08-Listas-imutaveis.md) os Set's também tem suas versões imutáveis, sendo elas utilizando o `Collections.unmodifiableSet` ou `Set.of`, este método em especifico acima da versão 8, o comportamento é parecido com o das listas imutáveis, porém com as peculiaridades do Set.
90+
Assim como já discutido no [capítulo anterior](./08-Listas-imutaveis.md) os Set's também tem suas versões imutáveis, sendo elas utilizando o `Collections.unmodifiableSet` ou `Set.of`, este método em especifico acima da versão 8, o comportamento é parecido com o das listas imutáveis, porém com as peculiaridades do Set.
91+
92+
[Próximo](./10-Map.md) - Map

‎4 - Intermediário/10-Map.md

+134
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,134 @@
1+
# <center> Map </center>
2+
3+
A ultima coleção que iremos falar é o [Map](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html), é uma coleção baseada em `chave` e `valor`. No capitulo sobre os [Sets](./09-Sets.md) uma das implementações de Map foi mencionada, sendo ela o [HashMap](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/HashMap.html), neste capítulo iremos falar sobre três implementações de Map, assim como fizemos com os `Sets`, sendo elas:
4+
5+
- [HashMap](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/HashMap.html).
6+
- Uma implementação baseada em [HashTable](https://en.wikibooks.org/wiki/Data_Structures/Hash_Tables).
7+
- [LinkedHashMap](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/LinkedHashMap.html).
8+
- Uma implementação que se utiliza uma `HashTable` e [Linked List](07-LinkedList-vs-ArrayList.md).
9+
- [TreeMap](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TreeMap.html).
10+
- Uma implementação baseada em [Red Black Tree](https://en.wikipedia.org/wiki/Red%E2%80%93black_tree), necessario a implementação da interface [Comparator](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Comparator.html), ela mantem a ordenação de acordo com a estrutura de arvore. Temos um exemplo de implementação [aqui](../Extras/implementacoes/ClasseComparator.java).
11+
12+
Todas as implementações tem 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.
13+
14+
## <center>Trabalhando com o Map</center>
15+
16+
Para criarmos as instancias de Map seguimos o seguinte padrão: `Map<Chave, Valor> nome = new Implementacao<>()`:
17+
18+
```java
19+
public class App {
20+
public static void main(String[] args) {
21+
Map<String, String> hashMap = new HashMap<>();
22+
Map<String, String> linkedHashMap = new LinkedHashMap<>();
23+
Map<String, String> treeMap = new TreeMap<>();
24+
}
25+
}
26+
```
27+
28+
Diferentes das listas e sets não temos o método add, para adicionarmos itens em um `Map` utilizamos o método [put](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html#put(K,V)).
29+
30+
```java
31+
public class App {
32+
public static void main(String[] args) {
33+
Map<String, String> map = new HashMap<>();
34+
map.put("chave", "valor");
35+
}
36+
}
37+
```
38+
39+
Caso o valor já exista no `Map` ele é substituido pelo novo valor:
40+
41+
```java
42+
public class App {
43+
public static void main(String[] args) {
44+
Map<String, String> map = new HashMap<>();
45+
map.put("chave", "valor");
46+
map.put("chave", "novo valor");
47+
}
48+
}
49+
```
50+
51+
Para remover algum item do `Map` temos o método [remove](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html#remove(java.lang.Object)) onde temos uma sobrecarga bem interessante na qual só é feita a remoção da chave caso o valor seja igual ao passado.
52+
53+
```java
54+
public class App {
55+
public static void main(String[] args) {
56+
Map<String, String> map = new HashMap<>();
57+
map.put("chave", "valor");
58+
map.put("chave2", "valor2");
59+
map.remove("chave"); //remoção da chave com sucesso
60+
map.remove("chave2", "papagaio"); //não acontece a remoção da chave 2
61+
}
62+
}
63+
```
64+
65+
Também recuperar o valor de uma chave em um `Map` utilizando o método [get](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html#get(java.lang.Object)) ou se quisermos saber se a chave existe antes de buscar, utilizamos o método [containsKey](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html#containsKey(java.lang.Object)), caso o valor não exista o método `get` ira retornar o valor `null`, e o método `containsKey` ira retornar false.
66+
67+
```java
68+
public class App {
69+
public static void main(String[] args) {
70+
Map<String, String> map = new HashMap<>();
71+
map.put("chave", "valor");
72+
map.put("chave2", "valor2");
73+
String valorChave = map.get("chave"); //valor
74+
String chaveInexistente = map.get("aurora"); //null
75+
76+
if (map.containsKey("chave2")) {
77+
String valorChave2 = map.get("chave2");
78+
} else {
79+
//qualquer outro tratamento
80+
}
81+
}
82+
}
83+
```
84+
85+
Podemos também iterar um `Map` por meio de um [Set](./09-Sets.md) de chaves utilizando o método [keySet](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html#keySet()), onde nos é retornado um `Set` com todas as chaves inseridas neste `Map`.
86+
87+
```java
88+
public class App {
89+
public static void main(String[] args) {
90+
Map<String, String> map = new HashMap<>();
91+
map.put("chave", "valor");
92+
map.put("chave2", "valor2");
93+
Set<String> chaves = map.keySet();
94+
for(String chave: chaves) {
95+
System.out.println("Chave: " + chave + ", valor: " + map.get(chave));
96+
}
97+
}
98+
}
99+
```
100+
101+
Também podemos percorrer os valores de um `Map` com o método [values](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html#values()), este método nos retorna uma [Collection](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html) contendo os valores
102+
103+
```java
104+
public class App {
105+
public static void main(String[] args) {
106+
Map<String, String> map = new HashMap<>();
107+
map.put("chave", "valor");
108+
map.put("chave2", "valor2");
109+
Collection<String> valores = map.values();
110+
for(String valor: valores) {
111+
System.out.println("Valor: " + valor);
112+
}
113+
}
114+
}
115+
```
116+
117+
Temos outros métodos como [isEmpty](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html#isEmpty()), [clear](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html#clear()), [size](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html#size()), que tem o mesmo comportamento das outras coleções já apresentadas.
118+
119+
### <center>Imutabilidade</center>
120+
121+
Assim como já discutido no [capítulo de Listas imutaveis](./08-Listas-imutaveis.md) os Map's também tem suas versões imutáveis, sendo elas utilizando o `Collections.unmodifiableMap` no qual não permite o uso do método `put` ou `Map.of`, este método em especifico acima da versão 8, o comportamento é parecido com o das listas imutáveis, porém com o modo de uso um pouco diferente.
122+
123+
```java
124+
public class App {
125+
public static void main(String[] args) {
126+
Map<String, String> mapImutavel = Map.of(
127+
"chave1", "valor1",
128+
"chave2", "valor2",
129+
"chave3", "valor3"
130+
//.......
131+
);
132+
}
133+
}
134+
```

‎Extras/implementacoes/ClasseComparator.java

+45
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,45 @@
1+
import java.util.Comparator;
2+
import java.util.Map;
3+
import java.util.TreeMap;
4+
5+
public class ClasseComparator {
6+
public static void main(String[] args) {
7+
Map<String, Pessoa> map = new TreeMap<>();
8+
map.put("pessoa1", new Pessoa("Jubileu"));
9+
map.put("pessoa2", new Pessoa("Pica Pau"));
10+
map.put("pessoa3", new Pessoa("Zeca Urubu"));
11+
System.out.println(map);
12+
}
13+
14+
static class Pessoa implements Comparator<Pessoa> {
15+
16+
private static int sequencia = 1;
17+
18+
private Integer id;
19+
private String nome;
20+
21+
public Pessoa(String nome) {
22+
this.nome = nome;
23+
this.id = sequencia++;
24+
}
25+
26+
public Integer getId() {
27+
return id;
28+
}
29+
30+
public String getNome() {
31+
return nome;
32+
}
33+
34+
@Override
35+
public int compare(ClasseComparator.Pessoa o1, ClasseComparator.Pessoa o2) {
36+
return Integer.compare(o1.id, o2.id);
37+
}
38+
39+
@Override
40+
public String toString() {
41+
return "Pessoa [id=" + id + ", nome=" + nome + "]";
42+
}
43+
44+
}
45+
}

‎README.md

+1
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,7 @@
5757
7. 🔠 [LinkedList vs ArrayList](/4%20-%20Intermedi%C3%A1rio/07-LinkedList-vs-ArrayList.md)
5858
8. 🔠 [Listas Imutáveis](/4%20-%20Intermedi%C3%A1rio/08-Listas-imutaveis.md)
5959
9. 🔠 [Sets](/4%20-%20Intermedi%C3%A1rio/09-Sets.md)
60+
10. 🔠 [Map](/4%20-%20Intermedi%C3%A1rio/10-Map.md)
6061

6162
### Extras
6263

0 commit comments

Comments
 (0)