1. Descripción general de la interfaz del mapa
La interfaz de Mapa es una colección de dos columnas, y cada elemento contiene un objeto clave (clave) y un objeto de valor (valor). Existe una correspondencia entre los objetos, llamada mapa.
Al acceder a un elemento, siempre que se especifique la clave, se puede encontrar el valor correspondiente.
Para los objetos que asignan claves a valores, un mapa no puede contener claves duplicadas, y cada clave guía como máximo un valor.
2. Descripción general de las colecciones comunes de mapas
- HashMap <K, V> : estructura de la tabla hash utilizada para almacenar datos, no se puede garantizar que la secuencia de acceso de los elementos sea coherente. Dado que la clave debe ser única y no duplicada, el método hashCode () y el método equals () de la clave deben reescribirse.
- LinkedHashMap <K, V> : hay una subclase LinkedHashMap debajo de HashMap, que almacena la estructura de la tabla hash + la estructura de la lista vinculada utilizada por los datos almacenados. La estructura de la lista vinculada puede garantizar que la secuencia de acceso de los elementos sea coherente; la estructura de la tabla hash puede garantizar que las claves sean únicas y no estén duplicadas, y el método hashCode () y el método equals () de la clave deben reescribirse.
- TreeMap <K, V> : el principio del árbol binario garantiza que las claves son únicas y que las claves se pueden ordenar en el orden especificado.
En tercer lugar, los métodos de uso común en la interfaz del mapa
Ejemplos:
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 de la operación:
Cuarto, el recorrido de la colección de mapas.
Dos métodos transversales
Ejemplos:
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 de la operación:
Cinco, valor de clave de tipo personalizado de la tienda HashMap
Al almacenar un objeto personalizado en HashMap, si el objeto personalizado existe como una clave, para asegurarse de que el objeto sea único en este momento, debe reescribir el código hash e iguales métodos del objeto.
Ejemplos:
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 de la operación:
Seis, el uso de TreeMap
El principio del árbol binario garantiza que las claves son únicas y que las claves se pueden ordenar en el orden especificado.
Ejemplos:
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 de la operación:
7. Ejercicios
1. TreeMap cuenta la aparición de cadenas
Ejemplos:
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 de la operación:
2. Colección HashMap anidada Caso de colección HashMap
Ejemplos:
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 de la operación:
3. Colección ArrayList colección HashMap anidada
Ejemplos:
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 de la operación:
