Cómo ver el código fuente de hashmap
Tiene cuatro clases de implementación, a saber, HashMap, HashTable, LinkedHashMap y TreeMap.
A continuación se muestran el uso y las diferencias de estos cuatro ejemplos.
Análisis técnico de claves:
El mapa se utiliza para almacenar pares clave-valor y obtener valores en función de las claves, por lo que no se permite repetir claves, sino valores. se puede repetir.
¿l? (1)HashMap es el mapeo más utilizado. Almacena datos según el valor hashCode de la clave y su valor se puede obtener directamente según la clave, por lo que la velocidad de acceso es muy rápida. HashMap solo permite que la clave de un registro esté vacía y no permite que el valor de varios registros esté vacío. HashMap no admite la sincronización de subprocesos, es decir, varios subprocesos pueden escribir en HashMap al mismo tiempo en cualquier momento, lo que puede provocar inconsistencia en los datos. Si necesita sincronizar, puede utilizar colecciones. El método de mapeo sincrónico (HashMap) le da a HashMap la capacidad de sincronizarse.
¿l? (2) Hashtable es similar a HashMap, excepto que no permite que las claves o valores registrados estén vacíos y admite la sincronización de subprocesos, es decir, solo un subproceso puede escribir una tabla hash en cualquier momento; Sin embargo, esto también da como resultado que las tablas hash se escriban muy lentamente.
¿l? (3)LinkedHashMap mantiene el orden de inserción de los registros. Cuando se utiliza Iteraor para iterar sobre un LinkedHashMap, primero se debe insertar el primer registro. Será más lento que HashMap al atravesar. Tiene todas las características de HashMap.
¿l? (4) TreeMap puede ordenar los registros que guarda según las claves. De forma predeterminada, ordena en orden ascendente; también puede especificar un comparador de clasificación. Al recorrer un TreeMap usando Iteraor, los registros obtenidos se ordenan. Las claves y valores de TreeMap no pueden estar vacíos.
¿Importado? Java .util .hashmap;
¿Importar? Java .util .hashtable;
¿Importar? iterador de Java . util;
¿Importar? Java . util . hashmap vinculado;
¿Importar? Java . util . mapa;
¿Importar? Java . util . mapa de árbol;
¿Público? ¿clase? ¿Mapa de prueba? {
¿Público? ¿Electricidad estática? ¿Vacío? init(mapa?mapa){
¿Si? (¿Imagen?!=?null){
¿Cadena? ¿llave? =?null
¿Para qué? (int?I = 5;?I>0;?I-){
¿Clave? =?¿Nuevo? Entero(I). aCadena()? +?".0";
map.put(key, key . tostring());
//Las claves en el mapa no se repiten. Si se insertan dos registros con el mismo valor clave,
//Entonces el registro insertado más tarde sobrescribirá el registro insertado antes.
map.put(clave, clave.toString()?+?"0");? }
}
}
¿Público? ¿Electricidad estática? ¿Vacío? salida(mapa?mapa){
si? (¿Imagen?!=?null){
¿Objeto? ¿llave? =?nulo
¿Objeto? ¿valor? =?null
//Utilice un iterador para recorrer las claves del Mapa y obtener el valor según la clave.
¿Iterador? ¿él? =?mapa.keySet().
Iterador();
¿Cuándo? (it.hasNext()){
¿Clave? =?it . siguiente();
¿Valor? =?map . get(clave);
System.out.println("clave:"?+?Clave?+?";?Valor:?"?+?Valor?);
}
//O utilice un iterador para recorrer el mapa de registros. Entrada del mapa.
Mapa. ¿empezando? ¿empezando? =?nulo
¿Eso? =?map.entrySet(). Iterador();
¿Cuándo? (it.hasNext()){
//Un mapa. Una entrada representa un registro.
¿Empezando? =?(Fig. entrada)it . next();
//La clave y el valor del registro se pueden obtener mediante la entrada.
//System.out.println("key:"?+?entry.getKey()?+?";?value:?"?+?entry.getvalue());
}
}
}
¿Público? ¿Electricidad estática? ¿Booleano? contieneClave(¿Mapa? ¿Mapa? ¿Objeto? Clave){
¿Si? (¿Imagen?!=?null){
¿Volver? map contiene clave(clave);
}
¿Regresión? Falso;
}
¿Público? ¿Electricidad estática? ¿Booleano? contiene valor(mapa?mapa,?objeto?valor){
si? (¿Imagen?!=?null){
¿Volver? map.containsValue(valor);
}
¿Regresión? Falso;
}
¿Público? ¿Electricidad estática? ¿Vacío? testHashMap(){
¿Mapa? ¿Mi mapa? =?Nuevo? HashMap();
init(myMap);
//La clave HashMap puede estar vacía.
myMap.put(null, "DDD");
//El valor de HashMap puede estar vacío.
miMapa.put("aaa ", nulo);
Salida(miMapa);
}
¿Público? ¿Electricidad estática? ¿Vacío? testHashtable(){
¿Mapa? ¿Mi mapa? =?Nuevo? hashtable();
init(myMap);
//La clave de la tabla hash no puede estar vacía.
//myMap.put(null, "DDD");
//El valor de Hashtable no puede ser nulo.
//myMap.put("aaa ", null);
Salida(myMap);
}
¿Público? ¿Electricidad estática? ¿Vacío? testLinkedHashMap(){
¿Mapa? ¿Mi mapa? =?Nuevo? linked hashmap();
init(myMap);
//La clave de LinkedHashMap puede estar vacía.
myMap.put(null, "DDD");
myMap.put(null, "AAA");
//El valor de LinkedHashMap puede ser nulo.
miMapa.put("aaa ", nulo);
Salida(miMapa);
}
¿Público? ¿Electricidad estática? ¿Vacío? testTreeMap(){
¿Mapa? ¿Mi mapa? =?Nuevo? TreeMap();
init(myMap);
//Las claves de TreeMap no pueden estar vacías.
//myMap.put(null, "DDD");
//El valor de TreeMap no puede ser nulo.
//myMap.put("aaa ", null);
Salida(myMap);
}
¿Público? ¿Electricidad estática? ¿Vacío? principal(Cadena[]?args)? {
System.out.println("Usar HashMap ");
mapa de prueba testhashmap();
System.out.println("Usar HashMap. "); Hashtable");
test map .test hashtable();
system out . map . testlinkedhashmap();
System.out.println("Usar TreeMap ");
test map.testtreemap();
¿Mapa? ¿Mi mapa? =?¿Nuevo? HashMap();
probar mapa .init(miMapa);
System.out.println("Inicializar nuevo mapa:?miMapa");
prueba map .output(myMap);
//Borrar el mapa
mymap .
System.out.println ("¿Mi mapa? Después borrando, ¿está mi mapa vacío? "?+?mymap . isempty());
test map . output(myMap);
myMap.put("aaa ", "AAAA ");
myMap.put("bbb", "bbbb");
//Determina si el mapa contiene claves o valores.
System.out.println("myMap contiene la clave aaa?"+?TestMap.containsKey(myMap, "AAA"));
System.out.println("myMap contiene Valor aaaa? "+?TestMap.containsValue(myMap, "AAAA"));
//Eliminar registros en el mapa según la clave.
mymap . remove(" AAA ");
System.out.println("Después de eliminar la clave aaa, ¿myMap contiene la clave aaa?"+?TestMap.containsKey(myMap) , " AAA"));
//Obtiene el número de registro del mapa.
Sistema.
out . println("El número de registros contenidos en mymap:"?+?mymap . size());
}
}Resultado de salida:
Tabla hash usada
Clave: nula; valor: ddd
Clave: 3,0; valor: £3,00
Clave: aaa valor: nulo
Clave: 4,0; Valor: £4,00
Clave: 1,00; Valor: 1,00
Valor: £5,00
Clave: 2,0; Valor: 2,00
Usando una tabla hash
Clave: 4,0; valor: £4,00
clave: 1,00; Clave: 3,0; valor: £ 3,00
Clave: 5,0; valor: £5,00
Clave: 2,0; valor: 2,00
Usar LinkedHashMap
Clave: 5,0; Valor: £5,00
Clave: 4,0; Valor: £4,00
Clave: 3,0; 2.0 ; Valor: 2.00
Clave: 1.0; Valor: 1.00
clave: nulo; Valor: aaa
Punto clave: valor aaa: nulo
Utilizar un diagrama de árbol
Clave: 1,0; valor: 1,00
Clave: 2,0; valor: 2,00
Clave: 3,0; 3,00
Clave: 4,0; Valor: £4,00
Clave: 5,0; Valor: £5,00
Inicializar un nuevo mapa: myMap.
Clave: 3,0; Valor: £3,00
Clave: 4,0; Valor: £4,00
Valor: 1,00
Clave: 5.0; Valor: £5.00
Clave: 2.0; Valor: 2.00
¿Está mi mapa vacío después de borrarlo? Así es.
MyMap contiene una clave verdadera.
MyMap contiene el valor aaaa verdadero.
Después de eliminar la clave aaa, myMap contiene la clave aaa falsa.
Número de registros contenidos en myMap:? 1
Análisis del código fuente:
Hay dos métodos para recorrer el mapa:
(1) El método keySet() del mapa obtiene el conjunto de claves y luego llamadas El método iterador de la colección de claves obtiene el iterador de la clave, eliminando así iterativamente las claves en el Mapa y obteniendo el valor correspondiente a la clave a través del método get, completando así el recorrido del Mapa. El código es el siguiente:
//Utilice un iterador para recorrer las claves del Mapa y obtener el valor según la clave.
Iterador it = map.keySet(). iterador();
mientras (it.hasNext()){
? clave = eso . siguiente();
? valor = mapa . obtener(clave);
? system . out . println(" clave: "+clave+"; valor: "+valor");
}
(2) Utilice el método EntrySet de Map para obtener los registros. en el conjunto de mapas, cada objeto es un objeto de entrada de mapa, use su método getKey para obtener la clave del registro y use su método getValue para obtener el valor del registro:
//O use un iterador para recorrer. Mapeo de registros
Map.Entrada entrada = null
it = map.entrySet()
mientras (it. hasNext(); ){
//Un mapa. Una entrada representa un registro.
? entrada =(map.entry)it .next();
? // Puede obtener la clave y el valor del registro mediante la entrada.
? //sistema . out . println(" clave: "+entrada . getkey()+"; valor: "+entrada . getvalue());