Diferencias entre Hashtable, HashMap y TreeMap
Java define una interfaz java.util.Map para mapear en estructuras de datos.
Tiene cuatro clases de implementación, a saber, HashMap, HashTable, LinkedHashMap y TreeMap.
A continuación se muestra el uso y la diferencia de estos 4 ejemplos.
Análisis técnico clave:
El mapa se utiliza para almacenar pares clave-valor y obtener valores basados en valores clave, por lo que no se permite repetir claves, sino valores. se puede repetir.
l ?(1)HashMap es uno de los mapas más utilizados. Almacena datos de acuerdo con el valor hashCode de la clave y puede obtener directamente su valor en función de la clave, y la velocidad de acceso es. muy rápido. HashMap no admite 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 se requiere sincronización, puede utilizar el método Collections.synchronizedMap (mapa HashMap) para sincronizar HashMap.
l ?(2) Hashtable es similar a HashMap, excepto que no permite que las claves o valores registrados estén vacíos; admite la sincronización de subprocesos, es decir, en un momento dado, solo uno; El hilo puede escribir en Hashtable, pero esto también hace que Hashtable se vuelva más lento al escribir.
l ?(3) LinkedHashMap conserva el orden de inserción de los registros. Cuando se utiliza Iteraor para atravesar LinkedHashMap, el registro obtenido primero definitivamente se insertará primero. 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, está ordenado en orden ascendente. También puede especificar un comparador para ordenar. Al atravesar un TreeMap usando un Iteraor, los registros se ordenan. Las claves y valores de TreeMap no pueden estar vacíos.
importar?java.util.HashMap;
importar?java.util.Hashtable;
importar?java.util.Iterator;
importar?java.util.LinkedHashMap;
importar?LinkedHashMap;
importar?java.util.Map;
importar?java.util.Iterator ;
importar?java.util.LinkedHashMap;
importar?java.util.Map;
¿importar ?" .0";
map.put(key,?key.toString());
//Las claves en el mapa no se repetirán si se insertan dos registros con el mismo valor de clave,
// Luego, el registro insertado más tarde sobrescribirá el registro insertado primero
map.put(key,?key.toString()??"0");?} }
}
public?static?void?output(Map?map){ if(map! =?null){ Object?key?=?null; Object?value?=?null; /Utiliza un iterador para recorrer las claves del Mapa, tomando valores basados en la clave Iterator?it?=?map.keySet().iterator(); while?(it.hasNext()){
clave?= ?it.next();
valor?=?map.get(clave);
System.out.println("clave:?" ? ?clave ? ?" ; valor:?" ? ?valor?); } //O usar un iterador para recorrer los registros de Map Map.Entry Map.Entry?=?null; iterator(); while? (it.hasNext() ){
// Un Map.Entry representa una entrada de registro?=?(Map.Entry)it.next( );
/A través de la entrada puede obtener la clave y el valor del registro
//System.out.println("key:?" ? ?entry.getKey()? ?" ; valor: ? " ?entry.getValue()); } } }
}
público?estático?boolean?containsKey(Mapa?mapa, ?Objeto?clave ){ if(map! =?null){ return?map.containsKey(key); } return?null){ return map.containsValue(valor } return false;
}
public?HashMap (); init(myMap); //El ke
y de un HashMap puede ser nulo myMap.put(null, "ddd"); //El valor de un HashMap puede ser nulo myMap.put("aaa",?null); p>}
public?put(null, "ddd"); //El valor de Hashtable no puede estar vacío//myMap.put("aaa",?null); / p>
}
public?static?void?testLinkedHashMap(){ Map?myMap?=?new?LinkedHashMap(); init(myMap); //La clave de LinkedHashMap puede ser nula myMap .put(null, "ddd"); myMap.put(null, "aaa"); // El valor de LinkedHashMap puede estar vacío myMap.put("aaa", ?null); p>
}
public?put(null, "ddd"); //El valor de TreeMap no puede estar vacío//myMap.put("aaa",?null); );
}
público?{ System.out.println("usando HashMap"); TestMap.testHashMap(); TestMap.testHashtable ();
System.out.testTreeMap(); Mapa?myMap?=?new?HashMap(); TestMap.output(myMap); //Mapa vacío myMap.clear(); .println( "Recientemente inicializado un mapa:?myMap"); ¿Se borrará TestMap.myMap después de que esté vacío? "); System.out.println("¿Se borrará MyMap después de que esté vacío?"); System.out.println("¿Se borrará después de que MyMap esté vacío?"); TestMap. ?myMap.isEmpty()) ; TestMap .output(myMap); myMap.put("aaa",?" aaaa"); myMap.put("bbb",?" bbbb"); //determina si el mapa contiene una clave o un valor. out. println("miMapa contiene la clave aaa " ?TestMap.containsKey(miMapa, ?" aaa")); System.out.println("miMapa contiene el valor aaaa " ?TestMap.containsValue(miMapa, ?" aaa"));