Análisis del código fuente de Ddd
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 de acuerdo con el valor hashCode de la clave y su valor se puede obtener directamente en función de 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 usar 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 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 gt0;?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,
//El registro insertado más tarde sobrescribirá el registro insertado anteriormente.
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, ¿mi mapa está 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")); 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:
Usando Lista dispersa
Clave: nulo; valor: ddd
Clave: 3,0; valor: £3,00
Clave: aaa valor: nulo
clave: 4,0; valor: £4,00
clave: 1,00
clave: 5,0; valor: £5,00
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
Valor: 2,00
Usando LinkedHashMap
Clave: 5,0; Valor: £5,00
Clave: 4,0; Valor: £4,00
Valor: £3,00
Clave: 2,0 ; Valor: 2,00
clave: 1,0; valor: 1,00
clave: nulo; valor: aaa
Punto clave: aaa valor: nulo
Adoptar diagrama de árbol
clave: 1,0; valor: 1,00
Clave: 2,00; valor: 2,00
Valor: 3,00
p>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 el registro establecido en el mapa, 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 el mapa de registro.
Entrada entrada = null
it = map.entrySet(). iterador();
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. fuera. println(" clave: " entrada . getkey() "; valor: " entrada . getvalue());