• Author / Uploaded
• jayadevi piñeiro

Citation preview

Hashmap - TREEMAP-- LINKEDHASHMAP HashMap

1.UN HashMap contiene valores basados en la clave. 2.Contiene solo elementos únicos. 3.Puede tener una clave nula y múltiples valores nulos.

4.Mantiene sin orden. public class HashMap extends AbstractMap implements Map, Cloneable, Serializable

LinkedHashMap

1.UN LinkedHashMap contiene valores basados en la clave. 2.Contiene solo elementos únicos. 3.Puede tener una clave nula y múltiples valores nulos.

4.Es lo mismo que HashMap sin embargo mantiene orden de insercion. // Ver desaceleración de clase a continuación public class LinkedHashMap extends HashMap implements Map

TreeMap

1.UN TreeMap contiene valores basados en la clave. Implementa la interfaz NavigableMap y amplía la clase AbstractMap. 2.Contiene solo elementos únicos. 3.No puede tener una clave nula, pero puede tener múltiples valores nulos.

4.Es lo mismo que HashMap en cambio mantiene orden ascendente(Ordenado usando el orden natural de su clave). public class TreeMap extends AbstractMap implements NavigableMap, Cloneable, Serializable

/** *Ing: Luis T. */ import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.Map; import java.util.TreeMap; public class InterfaceMap { private static Iterator it; /** * HashMap: * Los elementos que inserta en el map no tendrán un orden específico. No aceptan claves duplicadas ni valores nulos. * * TreeMap: * El Mapa lo ordena de forma "natural". Por ejemplo, si la clave son valores enteros (como

luego veremos), los ordena * de menor a mayor. * * LinkedHashMap: * Inserta en el Map los elementos en el orden en el que se van insertando; es decir, que no tiene una ordenación de los * elementos como tal, por lo que esta clase realiza las búsquedas de los elementos de forma más lenta que las demás * clases. */ public static void main(String[] args) { System.out.println("======= HASHMAP ======="); buildHashMap(); System.out.println("======= TREEMAP ======="); buildTreeMap(); System.out.println("======= LINKEDHASHMAP ======="); buildLinkedHashMap(); } private static void buildHashMap() { Map map = new HashMap(); map.put(1, "valo_1"); map.put(2, "valor_2"); map.put(22, "valor_22"); map.put(4, "valor_4"); map.put(5, "valor_5"); map.put(6, "valor_6"); map.put(51, "valor_51"); map.put(8, "valor_8"); map.put(9, "valor_9"); map.put(39, "valor_39"); // Imprimimos el HashMap it = map.keySet().iterator(); while(it.hasNext()){ Integer key = (Integer) it.next(); System.out.println("Clave: " + key + " -> Valor: " + map.get(key)); } System.out.println("\n"); }

private static void buildTreeMap(){ Map treeMap = new TreeMap(); treeMap.put(1, "valo_1"); treeMap.put(2, "valor_2"); treeMap.put(22, "valor_22"); treeMap.put(4, "valor_4"); treeMap.put(5, "valor_5"); treeMap.put(6, "valor_6"); treeMap.put(51, "valor_51");

treeMap.put(8, "valor_8"); treeMap.put(9, "valor_9"); treeMap.put(39, "valor_39"); // Imprimimos el TreeMap it = treeMap.keySet().iterator(); while(it.hasNext()){ Integer key = (Integer) it.next(); System.out.println("Clave: " + key + " -> Valor: " + treeMap.get(key)); } System.out.println("\n"); } private static void buildLinkedHashMap(){ Map linkedHashMap = new LinkedHashMap(); linkedHashMap.put(1, "valo_1"); linkedHashMap.put(2, "valor_2"); linkedHashMap.put(22, "valor_22"); linkedHashMap.put(4, "valor_4"); linkedHashMap.put(5, "valor_5"); linkedHashMap.put(6, "valor_6"); linkedHashMap.put(51, "valor_51"); linkedHashMap.put(8, "valor_8"); linkedHashMap.put(9, "valor_9"); linkedHashMap.put(39, "valor_39"); // Imprimimos el Map con un Iterador que ya hemos instanciado anteriormente it = linkedHashMap.keySet().iterator(); while(it.hasNext()){ Integer key = (Integer) it.next(); System.out.println("Clave: " + key + " -> Valor: " + linkedHashMap.get(key)); } } } /** * ======================= RESULTADO OBTENIDO ========================= * * ======= HASHMAP ======= * Clave: 51 -> Valor: valor_51 * Clave: 1 -> Valor: valo_1 * Clave: 2 -> Valor: valor_2 * Clave: 4 -> Valor: valor_4 * Clave: 39 -> Valor: valor_39 * Clave: 5 -> Valor: valor_5 * Clave: 6 -> Valor: valor_6 * Clave: 22 -> Valor: valor_22 * Clave: 8 -> Valor: valor_8

* Clave: 9 -> Valor: valor_9 * * ======= TREEMAP ======= * Clave: 1 -> Valor: valo_1 * Clave: 2 -> Valor: valor_2 * Clave: 4 -> Valor: valor_4 * Clave: 5 -> Valor: valor_5 * Clave: 6 -> Valor: valor_6 * Clave: 8 -> Valor: valor_8 * Clave: 9 -> Valor: valor_9 * Clave: 22 -> Valor: valor_22 * Clave: 39 -> Valor: valor_39 * Clave: 51 -> Valor: valor_51 * * ======= LINKEDHASHMAP ======= * Clave: 1 -> Valor: valo_1 * Clave: 2 -> Valor: valor_2 * Clave: 22 -> Valor: valor_22 * Clave: 4 -> Valor: valor_4 * Clave: 5 -> Valor: valor_5 * Clave: 6 -> Valor: valor_6 * Clave: 51 -> Valor: valor_51 * Clave: 8 -> Valor: valor_8 * Clave: 9 -> Valor: valor_9 * Clave: 39 -> Valor: valor_39 */

Las implementaciones generales de los mapas en Java son: •HashMap: mapa implementado mediante una tabla de troceado. •TreeMap: mapa implementado mediante un árbol binario.

Los datos se ordenan por su clave. •LinkedHashMap: mapa implementado mediante una tabla de troceado

(tabla hash) en la que el orden de inserción se almacena además mediante una lista doblemente enlazada. Ejemplo Vamos a poner en práctica todo los visto hasta el momento. Vamos a crear una agenda telefónica en la que vamos a vincular al nombre del contacto, el número de teléfono. Como veis, la estructura es clara, el nombre será la clave, mientras que el número de teléfono será el valor. import java.util.*; public class AgendaTelefonica {

// la agenda se guarda en un mapa private Map agenda; /** * Constructor que deja la agenda vacía */ public AgendaTelefonica() { agenda = new HashMap(); } /** * Añadir un nombre con su teléfono */ public void anadeTelefono(String nombre, int telefono) { agenda.put(nombre,new Integer(telefono)); } /** * Consultar un nombre; retorna el telefono, * o 0 si el nombre no existe */ public int consulta (String nombre) { Integer tel= agenda.get(nombre); if (tel==null) { return 0; } else { return tel.intValue(); } } /** * Saber si un nombre esta en el diccionario */ public boolean estaIncluido(String nombre) {

return agenda.containsKey(nombre); } /** * Mostrar la lista de toda la agenda */ public void mostrarNumeros() { Set lista=agenda.entrySet(); System.out.println(); System.out.println("Nombre - Telefono:"); for (Map.Entry e:lista) { System.out.println(e.getKey()+" - " +e.getValue()); } } }

prueba de la agenda /** * Programa de prueba de la agenda telefónica */ public class PruebaAgenda { public static void main (String[] args) { AgendaTelefonica agenda = new AgendaTelefonica(); agenda.anadeTelefono("a",1); agenda.anadeTelefono("b",2); agenda.anadeTelefono("c",3); agenda.anadeTelefono("d",4); agenda.anadeTelefono("e",5); agenda.anadeTelefono("f",6); agenda.anadeTelefono("g",7); // cambiamos un numero

agenda.anadeTelefono("d",44); System.out.println("Consulta a: "+agenda.consulta("a")); System.out.println("Consulta d: "+agenda.consulta("d")); System.out.println("Consulta g: "+agenda.consulta("g")); System.out.println("Consulta x: "+agenda.consulta("x")); System.out.println("Consulta y: "+agenda.consulta("y")); System.out.println("Esta a: "+agenda.estaIncluido("a")); System.out.println("Esta x: "+agenda.estaIncluido("x")); System.out.println("Esta d: "+agenda.estaIncluido("d")); agenda.mostrarNumeros(); } }

otro ejercicio

ordenar public class Testing { public static void main(String[] args) { HashMap map = new HashMap(); ValueComparator bvc = new ValueComparator(map);

TreeMap sorted_map = new TreeMap(bvc);

map.put("A", 99.5); map.put("B", 67.4); map.put("C", 67.4); map.put("D", 67.3);

System.out.println("unsorted map: " + map); sorted_map.putAll(map); System.out.println("results: " + sorted_map); } } class ValueComparator implements Comparator { Map base;

public ValueComparator(Map base) { this.base = base; }

//Note: this comparator imposes orderings that are inconsistent with

//equals. public int compare(String a, String b) { if (base.get(a) >= base.get(b)) { return -1; } else { return 1; } //returning 0 would merge keys } }