Contenido del curso

Introducción al Curso

1
Java SE Avanzado: Programación Modular y Persistencia con JDBC
03:17 min

Clases avanzadas

JavaDocs

Clases Anidadas

Interfaces Avanzadas

Colecciones Avanzadas

21
Implementaciones y uso de Map en Java
Viendo ahora

Excepciones

JDBC

Lambdas

Fin del Curso

40
Programación Avanzada en Java: Clases e Interfaces
01:30 min

Tomar examen

En el Curso Básico de Java vimos esta estructura de Colecciones interfaces

Te las expliqué todas menos la interfaz Map la cual te la dejé como reto . Existe otra que no aparece en ese árbol se llama Deque

Hoy te platicaré sobre Map

Lo primero que debes saber es que tiene tres implementaciones:

HashTable
LinkedHashMap
HashMap
SortedMap ➡️ TreeMap

La interfaz Map no hereda de la interfaz Collection porque representa una estructura de datos de Mapeo y no de colección simple de objetos. Esta estructura es más compleja, pues cada elemento deberá venir en pareja con otro dato que funcionará como la llave del elemento.

Map<K,V>

Donde K es el key o clave
Donde V es el value o valor

Podemos declarar un map de la siguiente forma:

Map<Integer, String> map = new HashMap<Integer, String>();
Map<Integer, String> treeMap = new TreeMap<Integer, String>();
Map<Integer, String> linkedHashMap = new LinkedHashMap<Integer, String>();

Como observas solo se puede construir el objeto con tres elementos que implementan de ella: HashMap, TreeMap y LinkedHashMap dejando fuera HashTable y SortedMap. SortedMap estará fuera pues es una interfaz y HashTable ha quedado deprecada pues tiene métodos redundantes en otras clases. Mira la funcionalidad de cada uno.

Como te conté hace un momento Map tiene implementaciones:

HashMap: Los elementos no se ordenan. No aceptan claves duplicadas ni valores nulos.
LinkedHashMap Ordena los elementos conforme se van insertando; provocando que las búsquedas sean más lentas que las demás clases.
TreeMap El Mapa lo ordena de forma “natural”. Por ejemplo, si la clave son valores enteros (como luego veremos), los ordena de menos a mayor.

Para iterar alguno de estos será necesario utilizar la interface Iterator y para recorrerlo lo haremos un bucle while así como se muestra:

Para HashMap

// Imprimimos el Map con un Iterador
Iterator it = map.keySet().iterator();
while(it.hasNext()){
  Integer key = it.next();
  System.out.println("Clave: " + key + " -> Valor: " + map.get(key));
}

Para LinkedHashMap

// Imprimimos el Map con un Iterador
Iterator it = linkedHashMap.keySet().iterator();
while(it.hasNext()){
  Integer key = it.next();
  System.out.println("Clave: " + key + " -> Valor: " + linkedHashMap.get(key));
}

Para TreeMap

// Imprimimos el Map con un Iterador
Iterator it = treeMap.keySet().iterator();
while(it.hasNext()){
  Integer key = it.next();
  System.out.println("Clave: " + key + " -> Valor: " + treeMap.get(key));
}

Ahora lee esta lectura y en la sección de tutoriales cuentanos en tus palabras cómo funciona Deque.

Implementaciones y uso de Map en Java

Comentarios

Diego Fernando Gómez Álvarez

student•

deque es un arreglo de elementos similar a un hashMap (Que inserta los elementos, sin un orden particular, uno después del otro) pero con la particularidad de que se puede insertar, remover y hacer otra operaciónes sobre los elementos en ambos extremos del arreglo usando métodos como:

addLast(); removeLast();
addFirst(); removeFirst();

Franco David Oliva

student•

La interfaz Deque Se pronuncia como deck, un deque es una cola de doble extremo (double-ended-queue). Un double-ended-queue es una colección lineal de elementos que soportan la inserción y eliminación de elementos en ambos finales (extremos). La interfaz Deque es un tipo de dato abstracto más enriquecido que Stack y Queue porque implementa ambos al mismo tiempo (stacks y queues). La interfaz Deque, define métodos para acceder a los elementos de ambos finales o extremos de una instancia Duque. Se proporcionan métodos para insertar, quitar y examinar los elementos. Las clases predefinidas como ArrayDeque y LinkedList impelementan la interfaz Deque. Insert Los métodos addfirst y offerFirst agregan elementos al principio de una instancia Duque. Los métodos addLast y offerLast agregan elementos al final de una instancia. Cuando la capacidad de la instancia es restringida, los métodos preferidos son: offerFirst y OfferLast porque addFirst puede no arrojar una excepción si esta lleno. Remove Los métodos removeFirst y pollFirst eliminan elementos al principio de la instancia y, removeLast y pollLast, eliminan elementos al final. Los métodos pollFirst y pollLast retornan null si la instancia esta vacia (empty) mientras que, los métodos removeFirst y removeLast, arrojan una excepción si la instancia esta vacia (empty). Retrieve Los métodos getFirst y peekFirst recuperan los primeros elementos de una instancia Duque. Estos métodos no eliminan el valor de una instancia Duque. Los métodos getLast y peekLast recuperan los últimos elementos. Los métodos getFirst y getLast arrojan una excepción si la instancia esta vacia (empty) mientras que, los métodos peekFirst y peekLast retornan NULL. Los 12 métodos de inserción, eliminación y recuperación de elementos de un Deque, se resumen en la siguiente tabla:

Jorge Vidoni

student•

Deque es la interfaz que nos proporciona java para manejar una lista doblemente enlazada. La interfaz Deque nos proporciona una abstracción de los métodos que necesitaremos para manejar tanto una Cola como una Pila. Ademas de esta interfaz java los proporciona las siguientes implementasiones de la misma:

ArrayDeque
ConcurrentLinkedDeque
LinkedBlockingDeque
LinkedList

Cesar David Ramírez Dimaté

student•

Dejo el siguiente ejemplo utilizando HashMap:

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class HashMapExample {
  public static void main(String[] args) {
    HashMap<Integer, String> hmap = new HashMap<Integer, String>();

    hmap.put(12, "Bogotá");
    hmap.put(2, "Medellín");
    hmap.put(7, "Cali");
    hmap.put(49, "Barranquilla");
    hmap.put(3, "Cartagena");

    Set<Entry<Integer, String>> set = hmap.entrySet();
    Iterator<Entry<Integer, String>> iterator = set.iterator();
    while (iterator.hasNext()) {
      Map.Entry<Integer, String> mentry = (Map.Entry<Integer, String>) iterator.next();
      System.out.println("Llave: " + mentry.getKey() + "\tValor: " + mentry.getValue());
    }

    String var = hmap.get(2);
    System.out.println("\nEl valor en el índice 2 es: " + var);

    hmap.remove(3);
    System.out.println("Elemento con índice 3 eliminado.\n");
    Set<Entry<Integer, String>> set2 = hmap.entrySet();
    Iterator<Entry<Integer, String>> iterator2 = set2.iterator();
    while (iterator2.hasNext()) {
      Map.Entry<Integer, String> mentry2 = (Map.Entry<Integer, String>) iterator2.next();
      System.out.println("Llave: " + mentry2.getKey() + "\tValor: " + mentry2.getValue());
    }
  }
}

Bruno Gabriel Cal Olivera

student•

Gracias! Me ayudó a entender ésto.

Carlos Uriel de Jesus Sánchez González

student•

El uso del map yo lo utilizo cuando realizo las consultas complejas a BD, ya que es la combinación de diferentes tablas, ya que te permite tener acceso a los datos de forma facil. Ademas desde java 8 para poder hacer la interacción con el mapa es mas facil son los streams, map, filters, foreach y todo el concepto de programación funcional.

List<Map> consultas = (metodo de traer los datos de bd);
consultas.forEach ( consulta -> {
	//Codigo
});

En debes de utilizar el interator

Francisco Javier Suarez Verdugo

student•

Deque vendría siendo un tipo de interfaz que tiene métodos para insertar, quitar y examinar elementos. Funcionando como una especie de cola o fila almacenando datos.

Usuario ESolutions

student•

Deque es una interface que implementa en conjunto queue (cola) y stack (pila), permitiendo operaciones sobre ambos extremos de la colección

Sebastian Pernett

student•

Creo que la descripción de LinkedHashMap en este artículo: “LinkedHashMap Ordena los elementos conforme se van insertando; provocando que las búsquedas sean más lentas que las demás clases.” es incorrecta. Porque si es una estructura que mientras va insertando va ordenando los elementos, no tiene que ser lenta la busqueda. Es mas por eso se ordena, para que sea más rápida la busqueda. pero esto si da un costo a la hora de la inserción.

Raúl Paredes Solís

student•

La interfase Deque es una colección lineal de elementos cuyo funcionamiento permite de manera eficiente la inserción y remoción elementos del principio y final de la colección, esto favorece el uso eficiente de pilas y colas.

Jorge Mario Hernández Beufford

student•

He instanciado Map's mediante su clase hija HashMap y hasta el momento sé que sí puede aceptar valores nulos

César Augusto Calad Hernández

student•

https://platzi.com/tutoriales/1629-java-oop/10485-la-interfaz-deque-3/

Braian Peña

student•

Es una interface que funciona como cola , los elementos de pueden trabajar desde los extremos ,añadir , eliminar o seleccionar.

movigostudio movigostudio

student•

Una colección lineal que apoya la inserción de elementos y la eliminación en ambos extremos.
Esta interfaz define métodos para acceder a los elementos en ambos extremos de la deque. Se proporcionan métodos para insertar, eliminar, y examinar el elemento.

Yossijaki Jorge Astilleros Chávez

student•

Lo que entendí es que un Deque o (Deck) es una cola de doble terminación (Valor,Clave): esto implica que es una colección que soporta la inserción y eliminación de elementos en ambas terminaciones.
Deque es un tipo de dato abstracto mucho mas rica que las los del tipo Stack y Queue, ya que implementa ambas al mismo tiempo

Hipólito Morales

student•

Imagina que desarrollas un juego de naipes. En el hay un modo de juego donde puedes cambiar una carta de tu mano por una de la cima (topdeck) poniendo la primer al fondo (bottom). La interfaz Deque (Deck) modela perfectamente ese comportamiento ya que mezcla las interfaces Stack y Queue

Luis José Villarreal Rincón

student•

Deque -> lo que entiendo es que funciona como Pilas y las Colas, tienen las funciones de ambos. Puedes acceder al inicio o al final de esta collection.

Eliana Mejia Santander

student•

Deque es una interfaz con comportamineto similar a una pila o cola en la cual se pueden insertar y eliminar elementos de tipo LIFO y FIFO

Jhon Olarte

student•

Es una interfáz que simula el comportamiento de una pila o cola. Con métodos que pueden ser usados dependiendo de la necesidad, que lancen excepciones o simplemente devuelvan valor null, bastante útil !!

Julio Cesar Mulcue Burbano

student•

Es una interfaz que funciona como pila y la cola de dos extremos, y tiene métodos para acceder a ambos extremos y realizar, agregaciones, eliminación y obtener los elementos.

Daniel Alejandro Contreras Suárez

student•

De que es la combinacion de Stack y Queue. Es una coleccion lineal que permite sacar elementos desce ambos extremos. De esta manera puede comportarse tanto como un Stack donde el primero que entra es el ultimo en salir, o como un Queue donde el primero que entra es el primero en salir.

// Imprimimos el Map con un Iterador
Iterator it = linkedHashMap.keySet().iterator();
while(it.hasNext()){
  Integer key = it.next();
  System.out.println("Clave: " + key + " -> Valor: " + linkedHashMap.get(key));
}

// Imprimimos el Map con un Iterador
Iterator it = treeMap.keySet().iterator();
while(it.hasNext()){
  Integer key = it.next();
  System.out.println("Clave: " + key + " -> Valor: " + treeMap.get(key));
}

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class HashMapExample {
  public static void main(String[] args) {
    HashMap<Integer, String> hmap = new HashMap<Integer, String>();

    hmap.put(12, "Bogotá");
    hmap.put(2, "Medellín");
    hmap.put(7, "Cali");
    hmap.put(49, "Barranquilla");
    hmap.put(3, "Cartagena");

    Set<Entry<Integer, String>> set = hmap.entrySet();
    Iterator<Entry<Integer, String>> iterator = set.iterator();
    while (iterator.hasNext()) {
      Map.Entry<Integer, String> mentry = (Map.Entry<Integer, String>) iterator.next();
      System.out.println("Llave: " + mentry.getKey() + "\tValor: " + mentry.getValue());
    }

    String var = hmap.get(2);
    System.out.println("\nEl valor en el índice 2 es: " + var);

    hmap.remove(3);
    System.out.println("Elemento con índice 3 eliminado.\n");
    Set<Entry<Integer, String>> set2 = hmap.entrySet();
    Iterator<Entry<Integer, String>> iterator2 = set2.iterator();
    while (iterator2.hasNext()) {
      Map.Entry<Integer, String> mentry2 = (Map.Entry<Integer, String>) iterator2.next();
      System.out.println("Llave: " + mentry2.getKey() + "\tValor: " + mentry2.getValue());
    }
  }
}

Introducción al Curso

Java SE Avanzado: Programación Modular y Persistencia con JDBC

Clases avanzadas

Clases Abstractas y Polimorfismo en Java: Avances y Aplicaciones

Reducción de Código con Clases Abstractas en Java

Sobrescritura de métodos en clases derivadas en Java

Polimorfismo y Abstracción en Clases Java

JavaDocs

Generación de Documentación Java con Javadocs

Documentación en Java: Uso de Etiquetas y Comentarios HTML

Documentación de librería Report en Java SE

Documentación de Clases Heredadas en Java

Generación de Documentación JavaDoc en HTML

Clases Anidadas

Clases Anidadas en Java: Conceptos y Aplicaciones Prácticas

Clase Song como clase interna en Album en Java

Implementación de Clases Anidadas en Java: Ejemplo Práctico con Page y Book

Simulación de Lectura con Clases Anidadas en Java

Uso de Enumerations en Programación

Interfaces Avanzadas

Interfaces Avanzadas en Java: Métodos Default y Private

Creación de Interfaces DAO en Java para Gestión de Bases de Datos

Encapsulación y Abstracción en Diseño de APIs

Diferencias entre Clases Abstractas e Interfaces en Programación

Herencia y métodos en interfaces de Java 8 y 9

Colecciones Avanzadas