1. Visão geral da interface do Mapa
A interface Mapa é uma coleção de duas colunas, cada elemento contendo um objeto-chave (chave) e um objeto de valor (valor); existe uma correspondência entre os objetos, chamada mapa.
Ao acessar um elemento, desde que a chave seja especificada, o valor correspondente pode ser encontrado.
Para objetos que mapeiam chaves para valores, um mapa não pode conter chaves duplicadas e cada chave orienta no máximo um valor.
2. Visão geral das coleções comuns de mapas
- HashMap <K, V> : estrutura da tabela de hash usada para armazenar dados; não é possível garantir que a sequência de acesso dos elementos seja consistente. Como a chave deve ser exclusiva e não duplicada, o método hashCode () e o método equals () da chave precisam ser reescritos.
- LinkedHashMap <K, V> : existe uma subclasse LinkedHashMap no HashMap, que armazena a estrutura da tabela de hash + a estrutura da lista vinculada usada pelos dados. A estrutura da lista vinculada pode garantir que a sequência de acesso dos elementos seja consistente; a estrutura da tabela de hash pode garantir que as chaves sejam exclusivas e não duplicadas, e o método hashCode () e o método equals () da chave precisam ser reescritos.
- TreeMap <K, V> : O princípio da árvore binária garante que as chaves sejam únicas e possam ser classificadas na ordem especificada.
Terceiro, os métodos comumente usados na interface do Mapa
Exemplos:
import java.util.HashMap;
import java.util.Map;
public class demo_map常用方法 {
public static void main(String[] args) {
//Map<K,V> K：键 V：值
Map<String,String> map=new HashMap<>();
//存入值，返回之前的值，如果没有，返回null
map.put("111","aaa");
map.put("222","bbb");
System.out.println(map);
//获取值 根据键获取值,不存在返回null
String value=map.get("111");
System.out.println(value);
//删除指定key的值
map.remove("111");
System.out.println(map);
}
}
Resultado da operação:
Quarto, a travessia da coleção de mapas
Dois métodos de travessia
Exemplos:
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class demo_集合遍历 {
public static void main(String[] args) {
Map<String,String> map=new HashMap<>();
map.put("1","aaa");
map.put("2","bbb");
map.put("3","ccc");
map.put("4","ddd");
map.put("5","eee");
//第一种遍历方式
//1.先获取所有的键
Set<String> key=map.keySet();
//2.遍历键的集合
for(String k:key){
String value=map.get(k);
System.out.println("获取到的键和值："+k+" "+value);
}
System.out.println("-----------------");
//第二种遍历方式map.entrySet()ctrl+alt+v
//1.获取所有键值对
Set<Map.Entry<String, String>> entries = map.entrySet();
//2.遍历set集合，获取键值对象
for(Map.Entry<String,String>entry:entries){
String key1=entry.getKey();
String value1=entry.getValue();
System.out.println("获取到的键和值："+key1+" "+value1);
}
}
}
Resultado da operação:
Cinco, valor da chave do tipo personalizado da loja HashMap
Ao armazenar um objeto personalizado no HashMap, se o objeto personalizado existir como uma chave, para garantir que o objeto seja exclusivo no momento, você deve reescrever o hashCode e igualar os métodos do objeto
Exemplos:
import java.util.HashMap;
public class HashMap_存储自定义对象 {
public static void main(String[] args) {
HashMap<Student,String> hashMap=new HashMap<>();
hashMap.put(new Student("yyy",18),"111");
hashMap.put(new Student("wtc",18),"222");
hashMap.put(new Student("yyy",18),"333");
System.out.println(hashMap);
}
}
class Student{
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
return super.equals(o);
}
@Override
public int hashCode() {
return this.name.hashCode()+age;
}
@Override
public String toString() {
return "姓名：" + name +
" 年龄：" + age;
}
}Resultado da operação:
Seis, o uso do TreeMap
O princípio da árvore binária garante que as chaves sejam únicas e que as chaves possam ser classificadas na ordem especificada.
Exemplos:
import java.util.Comparator;
import java.util.TreeMap;
public class demo_treemap {
public static void main(String[] args) {
//TreeMap键是有序的
TreeMap<String,String> treeMap=new TreeMap<>();
treeMap.put("02","aaa");
treeMap.put("01","aaa");
treeMap.put("04","aaa");
treeMap.put("03","aaa");
System.out.println(treeMap);
/**
* 自定义对象作为TreeMap的key
*/
TreeMap<Teacher,String> treeMap1=new TreeMap<>(new Comparator<Teacher>() {
@Override
public int compare(Teacher o1, Teacher o2) {
//按年龄排序
return o1.age-o2.age;
}
});
treeMap1.put(new Teacher("yyy",19),"aaa");
treeMap1.put(new Teacher("wtc",18),"bbb");
treeMap1.put(new Teacher("yw",20),"ccc");
System.out.println(treeMap1);
}
}
class Teacher {
String name;
int age;
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Teacher{" +
"姓名：" + name+
'}';
}
}
Resultado da operação:
7. Exercícios
1. O TreeMap conta a ocorrência de strings
Exemplos:
import java.util.TreeMap;
import java.util.Set;
public class demo_TreeMap统计字符串出现次数 {
public static void main(String[] args) {
String s="zzzszsdxxaasswwwayy";
TreeMap<Character,Integer> treeMap=new TreeMap<>();
for(int i=0;i<s.length();i++){
char c=s.charAt(i);
Integer value=treeMap.get(c);
if(value!=null){
//之前存过值
value++;
treeMap.put(c,value);
}
else{
//之前没存过
treeMap.put(c,1);
}
}
StringBuffer ss=new StringBuffer();
Set<Character> keyset=treeMap.keySet();
for(Character key:keyset){
ss.append(key).append("(").append(treeMap.get(key)).append(") ");
}
System.out.println(ss.toString());
}
}
Resultado da operação:
2. Coleção HashMap aninhada caso de coleção HashMap
Exemplos:
import java.util.HashMap;
import java.util.Set;
import java.util.Map;
public class demo_模拟存储班级信息 {
public static void main(String[] args) {
HashMap<String,String> hashMap1=new HashMap<>();
hashMap1.put("001","小米");
hashMap1.put("002","糖糖");
hashMap1.put("002","妮妮");
HashMap<String,String> hashMap2=new HashMap<>();
hashMap2.put("001","天天");
hashMap2.put("002","乐乐");
hashMap2.put("002","可可");
HashMap<String,HashMap<String,String>> hashMap=new HashMap<>();
hashMap.put("2017",hashMap1);
hashMap.put("2018",hashMap2);
//第一种键找值
Set<String> keyset=hashMap.keySet();
for(String key:keyset){
HashMap<String,String> ch=hashMap.get(key);
Set<String> chkeyset=ch.keySet();
System.out.println(key);
for(String chk:chkeyset){
System.out.println("学号："+chk+" 姓名："+ch.get(chk));
}
}
System.out.println("---------------------------");
//第二种获取键值对
Set<Map.Entry<String,HashMap<String,String>>> entrySet=hashMap.entrySet();
for(Map.Entry<String,HashMap<String,String>> entry:entrySet){
String key=entry.getKey();
HashMap<String,String> childHashmap=entry.getValue();
System.out.println(key);
for(Map.Entry<String,String> chEntry:childHashmap.entrySet()){
String s1=chEntry.getKey();
String s2=chEntry.getValue();
System.out.println("学号："+s1+" 姓名："+s2);
}
}
}
}
Resultado da operação:
3. Coleção ArrayList aninhada coleção HashMap
Exemplos:
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
import java.util.Map;
public class demo_Arraylist嵌套map {
public static void main(String[] args) {
HashMap<String,String> hashMap1=new HashMap<>();hashMap1.put("001","小米");
hashMap1.put("002","糖糖");
hashMap1.put("002","妮妮");
HashMap<String,String> hashMap2=new HashMap<>();
hashMap2.put("001","天天");
hashMap2.put("002","乐乐");
hashMap2.put("002","可可");
ArrayList<HashMap<String,String>> list=new ArrayList<>();
list.add(hashMap1);
list.add(hashMap2);
//第一种方式
for(int i=0;i<list.size();i++){
HashMap<String,String> hashMap=list.get(i);
Set<Map.Entry<String,String>> entrySet=hashMap.entrySet();
for(Map.Entry<String,String> entry:entrySet){
System.out.println("学号："+entry.getKey()+"姓名："+entry.getValue());
}
}
System.out.println("-----------------");
//第二种方式
for(HashMap<String,String> hashMap:list){
Set<Map.Entry<String,String>> entrySet=hashMap.entrySet();
for(Map.Entry<String,String> entry:entrySet){
System.out.println("学号："+entry.getKey()+" 姓名:"+entry.getValue());
}
}
}
}
Resultado da operação:
