Estructura de datos - Colas.

Cola.

La interface java.util.List es un subtipo de la interface java.util.Collection y representa una lista ordenada de objetos, lo que significa que se puede tener acceso a los elementos de List en un orden específico y por un índice también. Además, se puede agregar el mismo elemento más de una vez a List.

Siendo List un subtipo de Collection, todos los métodos en la interface Collection también se encuentran disponibles en la interface List.

Ya que List es una interface, se necesita instanciar una implementación concreta de la interface para poder usarla. Se puede escoger entre las siguientes implementaciones de List en las colecciones API de Java:

·         java.util.ArrayList

·         java.util.LinkedList

·         java.util.Vector

·         java.util.Stack

Algunos de sus métodos son:

Método	Descripción
boolean add(Elemento elemento)	Adiciona el elemento especificado al final de la lista.
void add(int índice, Elemento elemento)	Inserta el elemento especificado en la posición especificada de la lista.
Elemento remove(Elemento elemento)	Borra el elemento especificado de la lista, si lo encuentra. Todos los elementos siguientes de la lista son movidos una posición hacia adelante y sus índices decrecen en 1.
Elemento remove(int índice)	Borra el elemento en el índice especificado.

List contiene métodos heredados de la interface Collection, como clear(), get(), set() o size(), por mencionar algunos.

Ver demostración

Ejemplo:

import java.util.*;
public class ListDemo {
        public static void main(String args[]) {
                System.out.println("===== Listas =====\n");
               
                ArrayList a1 = new ArrayList();
                a1.add("perro");
                a1.add("gato");
                a1.add("perro");
                System.out.println("Lista a1 (ArrayList) = " + a1);
               
                List a2 = new ArrayList();
                a2.add("armario");
                a2.add("mesa");
                a2.add("armario");
                System.out.println("Lista a2 (List) = " + a2);
               
                Collection a3 = new ArrayList();
                a3.add("hermano");
                a3.add("hermana");
                a3.add("hermano");
                System.out.println("Lista a3 (Collection) = " + a3);
        }
}

Prueba tu código aquí

Enlace a Google Drive

¿Cómo insertar un enlace de un documento compartido en Google Drive?

Ejemplo:

Mi opinión sobre Google Drive

Estructura de datos - Pila.

Pila.

La clase java.util.Stack implementa una pila de tipo LIFO (Last In First Out – Último en Entrar Primero en Salir). A continuación se presentan los puntos importantes sobre Stack:

• Cuando una pila es creada, no contiene elementos.
• En esta clase, el último elemento insertado es accedido primero.

Algunos de sus métodos son:

Método	Descripción
boolean empty()	Verifica si la pila contiene elementos.
Elemento peek()	Mira el elemento en la parte superior de la pila sin borrarlo.
Elemento pop()	Devuelve el elemento en la parte superior de la pila y lo borra.
Elemento push()	Inserta el elemento en la parte superior de la pila.
int search(Elemento elemento)	Devuelve la posición del elemento dentro de la pila, o -1 si no lo encuentra.

Adicionalmente, Stack hereda métodos de las siguientes clases:

• java.util.Vector
• java.util.AbstractList
• java.util.Object
• java.util.List

Ver demostración sobre pila

Ejemplo:

import java.util.*;
public class StackDemo {
      public static void main(String [] args) {
           
            // Creando la pila
            Stack st = new Stack();
           
            // Agregando elementos a la pila
            st.push("Java");
            st.push("Source");
            st.push("code");
           
            // Mostrando los elementos de la pila
            System.out.println("Elementos de la pila: " + st);
           
            // Eliminando el elemento de la parte superior de la pila
            System.out.println("El objeto eliminado es: " + st.pop());
           
            // Mostrando los elementos de la pila después del borrado
            System.out.println("Elementos de la pila: " + st);
           
            // Verificando que existe el valor "A" en la pila
            System.out.println("Contiene el valor \"A\"? " + (st.contains("A") ? "si" : "no"));
           
            // Verificando que existe el valor "Source" en la pila
            System.out.println("Contiene el valor \"Source\"? " + (st.contains("Source") ? "si" : "no"));
           
            // Verificando que la pila contenga datos
            System.out.println("Pila vacía? " + (st.empty() ? "si" : "no"));
           
            // Buscando el elemento "Source"
            System.out.println("Resultado de la búsqueda del elemento \"Source\": "
                        + st.search("Source") + " elemento encontrado");
      }
}

Prueba tu código java

Estructuras de datos

Colecciones.

Una colección (o contenedor) es un objeto que agrupa múltiples elementos en una sola unidad. Las colecciones son usadas para almacenar, recuperar, operar y comunicar los datos agregados.

Típicamente representan elementos de datos que forman un grupo natural, como:

• Una mano de póquer (una colección de cartas).

 

• Una carpeta de correos (una colección de cartas).

 

• Un directorio telefónico (un mapeo de nombres a números de teléfono).

Las implementaciones de colecciones en las primeras versiones de la plataforma Java incluyeron vectores, arreglos y tablas hash, pero no contenían un marco de trabajo de colecciones.

Collections framework (marco de trabajo de colecciones) es una arquitectura unificada para representar y manipular colecciones, diseñado para cumplir varios objetivos:

• Tenía que ser altamente eficiente. La implementación de las colecciones fundamentales (arreglos dinámicos, listas enlazadas, árboles y tablas hash) son altamente eficientes.
• Tenía que permitir a diferentes tipos de colecciones trabajar de forma similar y con un alto nivel de interoperabilidad.
• Extender y/o adaptar una colección tenía que ser fácil.

Collections framework incluye lo siguiente:

1.     Interfaces: son tipos de datos abstractos que representan colecciones. Las interfaces permiten que las colecciones sean manipuladas independientemente de los detalles de su representación y generalmente forman una jerarquía.

2.     Implementaciones: es la implementación concreta de la interface colección – estructuras de datos reusables.

3.     Algoritmos: son métodos que realizan cálculos útiles (tales como búsqueda, ordenamiento e iteración) sobre objetos que implementan interfaces colección. Los algoritmos son polimórficos – el mismo método puede ser usado en muchas implementaciones diferentes de la interface colección apropiada. En esencia, los algoritmos son funcionalidades reutilizables.