Interfaces y Clases Principales de Colecciones en Java

Curso de Java SE Orientado a Objetos

Contenido del curso

Entender la Programación orientada a objetos

Definir Clases y sus componentes

Reutilizar Código

Aplicar Abstracción

Ensamblando Objetos el proyecto

Tomar examen

Otras interfaces que son muy importantes en Java son los llamados Collections

Los Collections nos van a servir para trabajar con colecciones de datos, específicamente y solamente con objetos, para esto recuerda que tenemos disponibles nuestras clases Wrapper que nos ayudan a convertir datos primitivos a objetos.

Los collections se diferencian de los arrays en que su tamaño no es fijo y por el contrario es dinámico.

A continuación te muestro un diagrama de su composición:

Como podemos observar el elemento más alto es la interfaz Collection, para lo cual, partiendo de su naturalidad de interface, entendemos que tiene una serie de métodos “básicos” dónde su comportamiento será definido a medida que se vaya implementando en más elementos. De ella se desprenden principalmente las interfaces Set y List.

La interface Set tendrá las siguientes características:

Almacena objetos únicos, no repetidos. La mayoría de las veces los objetos se almacenarán en desorden. No tenemos índice.

La interface List tiene éstas características:

Puede almacenar objetos repetidos. Los objetos se almacenan en orden secuencial. Tenemos acceso al índice.

Si seguimos analizando las familias tenemos que de Set se desprenden:

Clase HashSet Interfaz SortedSet y de ella la clase TreeSet.

HashSet los elementos se guardan en desorden y gracias al mecanismo llamado hashing (obtiene un identificador del objeto) permite almacenar objetos únicos.

TreeSet almacena objetos únicos, y gracias a su estructura de árbol el *acceso es sumamente rápido.

Ahora si analizamos la familia List, de ella se desprenden:

Clase ArrayList puede tener duplicados, no está sincronizada por lo tanto es más rápida Clase Vector es sincronizada, los datos están más seguros pero es más lento. Clase LinkedList, puede contener elementos duplicados, no está sincronizada (es más rápida) al ser una estructura de datos doblemente ligada podemos añadir datos por encima de la pila o por debajo.

Sigamos con 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

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 cuéntanos en tus palabras cómo funciona Deque.

Interfaces y Clases Principales de Colecciones en Java

BRYAN ARIEL MENDOZA MENOSCAL

Estudiante

ehh regresado y si me alargado de mas en esta clase les recomiendo cojer bases solidas aqui vengo del futuro y necesitaran saber cual elegir a futuro

Para este momento hemos aprendido mucho y es momento de poner ver nuevos conceptos es muy posible que ya algunos esten usando lo que me hemos mostrado a continuacion o ya tuviero su primer acercamiento con aquello sin mas empecemos. Que son las collections veamolo como mas bodegas para poder almacenar pero ya no datos. Ni cadenas string ni ni tipo de dato primitivo ahora almacenaremos Objetos y esto es gracias a nuestras clases warpper que son aquellas que nos permiten convertir y usar datos primitivos a objetos recalco las clases que veremos a continuacion cada una tiene caracteristicas que le hacen muy especial y diferente veamos.

Como podemos visualizar en la imagen tenemos la superclase Collection de esta se despliega las clases hijas set y list como ya lo mencione antes cada una con sus caracteristicas pero comencemos con una.

Set esta como caracteristicas principales no nos deja tener datos duplicados solo unicos, los objetos se almacenaran en desorden no contamos con indices esta cuenta con metodos para busca, eliminacion y agregar pero estos depedaran de cual de sus variantes usemos. Pero en general es muy eficiente para la eliminacion de datos, adicion y la busqueda recalco depende sus variantes pero cuales son estas veamos:

àHashset esta tiene como caracteristicas no podemos tener datos duplicados no tenemos un orden especificio pero esta a diferencia de su padre nos ayudara a encontrar datos o lo que tengamos almacenado de manera eficiente y rapida gracias a que esta asigna un dato numerico a cada objeto para poder buscarlo de forma rapida.

àSortedSet este si ordena nuestro objetos o datos , no podemos tener datos repetidos ya que estos son eliminados al momento y en lo que respeta a datos y eficiencia rapida para busca y eliminacion es muy eficiente debido a que se usa tiempo algortimico pero aquí surge una incognita ¿Que es esto? El concepto general nos dice que este trabaja mucho mejor cuando la entrada es de muchos datos, ya que este aumenta de formas lenta a medida que mas datos se procesan y esto dado como resultado mas eficiencias, esto es debido a que la busqueda binaria separa nuestra lista, objetos o datos en dos para hacer una busqueda muchas rapida esto se hace simplemente con divisiones y mas eficiente cuando esta supera los 10 datos.

àTreeSet esta nos ayuda ordenando nuestro datos de forma natural o de forma personalizada, no permite elementos duplicados si usted intenta agregar datos de este tipos simplemente seran eliminados, es basado en arboles binarios que quiere decir esto que este tipo de estructura de datos es muy eficiente en busca, eliminacion y insercion

Por otro lado tenemos las list esta es un amor para mi es eficiente en cierta cosas como es ordenado y flexible con los datos cada elemento cuenta con un indice con el cual podemos acceder a este y estas nos permiten tener elementos duplicados sin tener algun inconveniente este nos ofrece variedad de metodos que veremos poco a poco sin mas que decir porfundicemos.

àArrayList estas nos permite tener elemento duplicados, para busquedas de elementos no es muye eficiente ya que esta es dinamica crece a medida que se le agregan sus elementos cada uno esta ordenado y cuenta con un indice, eliminar datos facil independientemente del metodo personalidada aunque recalco si eliminamos el elemento final es muy rapido pero elemento del medio puede ser muy costoso.

Esta no es sincronizada algo que se me escapaba era el concepto de este que es esto. Cuando una lista cuenta con este topico se nos da conocer que es una lista segura aunque puede llegar a ser un poco lentos

/* *futuro lector puedes completemetar este texto leyendo logica de programacion y haciendo tu propio proyecto */

àVector esta es una clase sincronizada debido a esta cualidad aquella es un poco lenta pero se mantienen seguro los datos que estan almacenados esto esta hecha para ser utilizada en entornos multiHilos pero aquí nace una duda que SON LOS HILOS? Estos son los encargados de las que tareas se cumplan pero como es posible esto pensemos en esto como un taxi o un delivery que se le carga ir del punto A al punto B es asi como los hilos nos ayudan a ejecutar datos pero entonces que son los MULTiHILOS? Estos son aquellos que se encargan de ejecutar varias tareas ojo no todas al mismo tiempo esto depende de tu procesador veamos un poco mas profundo para que logres entender esto. Tenemos dos tipos principales de hilos de usuario y de sistema el primero es creado por nosotros y gestionado por nuestra app o software. El segundo es gestionado y planificado por nuestro sistema este es muy pesado pero se beneficia de la optimizacion del sistema por otro lado el del usuario esto son ligeros, rapido de crear pero no se benefician del sistema que beneficios nos pueden dar los hilos es una excelente pregunta lector entre los principales ya antes mecionados tenemos fluidez, rapidez, eficiencia, mejor uso de recursos, modularidad y respuesta respuesta pero veamos conceptos claves para poder entender mas.

*- Concurencia : este nos dice que el sistema tiene la capacidad de gestionar multiples tareas a la vez pero se aclara que no se ejecutan al mismo tiempo pero puede progresar juntas se que esto parece una contradicion dicha en primera plana como ya antes se les menciona depende tambien de su multiprocesador.

*-Paralelismo : En este caso se nos dice que tiene la capacidad de ejecutar tareas multiples tareas al mimso tiempo ojo requiere multiprocesador ya antes mecionado.

*-DeadLock: situacion donde uno o mas hilos estan esperando que otros terminen por tal no avanzan.

àLinkedList esta es una clase que puede contener elementos duplicados ojo esta no esta sincronizada por es mas eficiente mas rapido se nos dice que esta clase es de doble fila que quiere decir esto nos dice que podremos navegar tanto para adelante y para atrás un pequeña analogia para que logres comprender digamos que quieres buscar la siguiente palabra “Fuck”. Y separamos la mitad y comenzamos a buscar en caso que no este vamos hasta adelante sino hasta atrás tenemos libertad de movimiento para poder buscar nuestros datos. Algo que acortar sobre esta lista cada numero sabe sin es el siguiente debido que estan en comunicación constante esto la convierten en una lista eficiente para eliminacion y bsuqueda de datos.

Robert Báez

Estudiante

Me parecio interesante la informacion que compartes y como le has explicado que quiero hacer un pequño aporte a nivel de ejemplo, que seria basados en Set, Hashset, SortedSet, TreeSet.

Clase Users

Implementa Compareble para el uso de SortedSet

y los metodo equals y hasCcode para manejar los duplicado en las listas

import java.util.Objects;

public class Users implements Comparable<Users>{

    private Integer id;
    private String name;
    private String lastName;
    private String email;
    private char sex;
    private int phone;

    public Users() {
    }

    public Users(Integer id, String name, String lastName, String email, char sex, int phone) {
        this.id = id;
        this.name = name;
        this.lastName = lastName;
        this.email = email;
        this.sex = sex;
        this.phone = phone;
    }

    public Users(Integer id, String name, String lastName, String email) {
        this.id = id;
        this.name = name;
        this.lastName = lastName;
        this.email = email;
    }

    
    public int getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getPhone() {
        return phone;
    }

    public void setPhone(int phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "Users{" + "id=" + id + ", name=" + name + ", lastName=" 
                + lastName + ", email=" + email + ", sex=" + sex + ", phone=" + phone + '}';
    }

    @Override
    public int hashCode() {
        int hash = 5;
        hash = 97 * hash + Objects.hashCode(this.id);
        hash = 97 * hash + Objects.hashCode(this.name);
        hash = 97 * hash + Objects.hashCode(this.lastName);
        hash = 97 * hash + Objects.hashCode(this.email);
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Users other = (Users) obj;
        if (!Objects.equals(this.name, other.name)) {
            return false;
        }
        if (!Objects.equals(this.lastName, other.lastName)) {
            return false;
        }
        if (!Objects.equals(this.email, other.email)) {
            return false;
        }
        return Objects.equals(this.id, other.id);
    }
    
    @Override
    public int compareTo(Users user) {
        return Integer.compare(this.id, user.id );
    }

}

````Clase CollectionsExample`

Clase principal para ejecucion con metodos estaticos.

```java
import collectionsexample.model.Users;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

public class CollectionsExample {

    public static void main(String[] args) {
        System.out.println("Collection with java\n");

       manageSetInterface();
       sortedListWithOutDuplicate();
    }

    //Trabajando con la interface Set para manejo de duplicados
    // con los metodos equal y hashcode
    public static void manageSetInterface() {

        List<Users> lstUsers = new ArrayList<>();

        lstUsers.add(new Users(1, "Domingo", "Leiba", "DLeiba@mlb.com"));
        lstUsers.add(new Users(2, "Sergio", "Alcantara", "SAlcantara@mlb.com"));
        lstUsers.add(new Users(1, "Domingo", "Leiba", "DLeiba@mlb.com"));
        lstUsers.add(new Users(4, "Harold", "Ramirez", "HRamirez@mlb.com"));
        lstUsers.add(new Users(5, "Junior", "Severino", "JSeverino@mlb.com"));

        lstUsers.forEach(System.out::println);

        Set<Users> setUsers = new HashSet<>(lstUsers);
        List<Users> lstSinDuplicado = new ArrayList<>(setUsers);

        System.out.println("\nSin Duplicados");
        lstSinDuplicado.forEach(System.out::println);

    }

    public static void sortedListWithOutDuplicate() {

        SortedSet<Users> sortedUsers = new TreeSet<Users>();

        sortedUsers.add(new Users(1, "Domingo", "Leiba", "DLeiba@mlb.com"));
        sortedUsers.add(new Users(2, "Sergio", "Alcantara", "SAlcantara@mlb.com"));
        sortedUsers.add(new Users(1, "Domingo", "Leiba", "DLeiba@mlb.com"));
        sortedUsers.add(new Users(4, "Harold", "Ramirez", "HRamirez@mlb.com"));
        sortedUsers.add(new Users(5, "Junior", "Severino", "JSeverino@mlb.com"));

        System.err.println("Lista Ordenada Sin duplicados.");
        sortedUsers.forEach(System.out::println);

        for (Users u : sortedUsers) {
            System.out.println(u.getId() + " ::  " + u.getName() + " -> " + u.getEmail());
        }
    }
}

Andres López

Vanesa Percy

David Galicia Gomez

Joel Pimentel Salvatierra

Agustín Rafael Tortello Ditta

Usuario anónimo

User

Brandon Pinzón Pérez

Enrique Ruvalcaba

Natalia Gutierrez

Juan Diego Suárez Londoño

Esteban Cerda Román

Antony Suica Cuartas

Elvis Rafael Perez Gutierrez

LUIS ALEJANDRO BERNAL ROMERO

Jesús Enrique García

Alejandro Ching

Ricardo Rito Anguiano

Rodrigo Emmanuel Chi Ozalde

Johann Eduardo Rangel

Katherine Benjumea

Diego Joel Requejo Torero

Jaime Ortiz

Cristian Felipe Patiño Cáceres

Denis Morales

Carlos Chirinos

Silvana Rolón

Daniel Jaramillo

Andrés Antonio Azuara Portillo

Interfaces y Clases Principales de Colecciones en Java

Entender la Programación orientada a objetos

Curso actualizado ⚠️

Programación Orientada a Objetos con Java: Clases, Herencia e Interfases

Propiedades y Comportamientos de los Objetos en Programación

Clases y Abstracción en Programación Orientada a Objetos

Modularidad y Orientación a Objetos en Programación Java

Definir Clases y sus componentes

Creación de Clases y Objetos en Java: Sistema de Citas Médicas

Métodos Constructores en Java: Creación y Uso Efectivo

Métodos y Variables Estáticas en Java: Uso y Acceso

Definición y Uso de Variables y Métodos Estáticos en Java

Variables y Métodos Estáticos en Java: Uso y Beneficios

Sobrecarga de Métodos y Constructores en Java

Clase "Paciente" en Java: Atributos y Constructor

Encapsulamiento de Datos en Java: Modificadores de Acceso

Encapsulamiento y Validación de Datos en Programación Orientada a Objetos

Diferencias entre Variables y Objetos en Programación Java

Diferencias entre variables primitivas y objetos en la memoria

Clases Anidadas en Java: Internas y Estáticas

Clases Anidadas y Estáticas en Java: Uso y Ventajas

Uso de Enumeraciones en Java: Definición y Ejemplos Prácticos

Reutilizar Código

Reutilización de Código y Herencia en Programación Orientada a Objetos

Herencia y Abstracción de Clases en Java: Doctor y Paciente

Sobre escritura de métodos en Java: cómo redefinir comportamientos

Polimorfismo en Programación Orientada a Objetos: Método toString

Herencia e Interfaces en Programación Orientada a Objetos

Composición de Interfaces en Java: Implementación y Beneficios