Estructuras de datos en Java

Java proporciona una amplia variedad de estructuras de datos para procesar y organizar datos.

El paquete java.util de Java proporciona implementaciones de muchas de estas estructuras de datos, y puedes elegir la clase adecuada según tus necesidades.

A continuación se presentan algunas estructuras de datos comunes en Java:

Arreglos (Arrays)

Los arreglos (Arrays) son una estructura de datos básica que puede almacenar una cantidad fija de elementos del mismo tipo.

int[] array = new int[5];

• Características:Tamaño fijo, almacena elementos del mismo tipo.
• Ventajas:Acceso aleatorio a elementos con alta eficiencia.
• Desventajas:Tamaño fijo, inserción y eliminación de elementos relativamente lentas.

Listas (Lists)

Java ofrece varias implementaciones de listas, como ArrayList y LinkedList.

List<String> arrayList = new ArrayList<>();
List<Integer> linkedList = new LinkedList<>();

ArrayList:

• Características:Arreglo dinámico, tamaño variable.
• Ventajas:Acceso aleatorio eficiente e inserción rápida al final.
• Desventajas:Inserción y eliminación en el medio relativamente lentas.

LinkedList:

• Características:Lista doblemente enlazada, los elementos se conectan mediante punteros.
• Ventajas:Inserción y eliminación de elementos eficientes, buen rendimiento del iterador.
• Desventajas:Acceso aleatorio relativamente lento.

Conjuntos (Sets)

Los conjuntos (Sets) se utilizan para almacenar elementos no duplicados; las implementaciones comunes son HashSet y TreeSet.

Set<String> hashSet = new HashSet<>();
Set<Integer> treeSet = new TreeSet<>();

HashSet:

• Características:Conjunto desordenado, basado en HashMap.
• Ventajas:Operaciones de búsqueda e inserción eficientes.
• Desventajas:No garantiza orden.

TreeSet:

• Características:TreeSet es un conjunto ordenado, implementado internamente con un árbol rojo-negro, y no permite elementos duplicados.
• Ventajas:Proporciona ordenamiento automático, adecuado para escenarios donde se necesita almacenar elementos en orden.
• Desventajas:Rendimiento relativamente inferior, no permite insertar elementos null.

Mapas (Maps)

Los mapas (Maps) se utilizan para almacenar pares clave-valor; las implementaciones comunes son HashMap y TreeMap.

Map<String, Integer> hashMap = new HashMap<>();
Map<String, Integer> treeMap = new TreeMap<>();

HashMap:

• Características:Estructura de almacenamiento de pares clave-valor basada en tabla hash.
• Ventajas:Operaciones de búsqueda, inserción y eliminación eficientes.
• Desventajas:Desordenado, no garantiza orden.

TreeMap:

• Características:Estructura de almacenamiento de pares clave-valor ordenada basada en árbol rojo-negro.
• Ventajas:Ordenado, admite recorrido en el orden de las claves.
• Desventajas:Inserción y eliminación relativamente lentas.

Pila (Stack)

La pila (Stack) es una estructura de datos lineal que gestiona los elementos según el principio de último en entrar, primero en salir (Last In, First Out, LIFO). En la pila, los nuevos elementos se añaden a la cima de la pila, y solo se pueden eliminar elementos desde la cima. Esto significa que el último elemento añadido es el primero en ser eliminado.

Stack<Integer> stack = new Stack<>();

Clase Stack:

• Características:Representa una pila, normalmente opera los elementos en orden LIFO (último en entrar, primero en salir).

Cola (Queue)

La cola (Queue) sigue el principio de primero en entrar, primero en salir (FIFO); las implementaciones comunes son LinkedList y PriorityQueue.

Queue<String> queue = new LinkedList<>();

Interfaz Queue:

• Características:Representa una cola, normalmente opera los elementos en orden FIFO (primero en entrar, primero en salir).
• Clases de implementación: LinkedList, PriorityQueue, ArrayDeque.

Montículo (Heap)

El montículo (Heap) es la base de las colas de prioridad, y puede implementar montículos máximos y mínimos.

PriorityQueue<Integer> minHeap = new PriorityQueue<>();
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());

Árboles (Trees)

Java proporciona el tipo TreeNode, que se puede utilizar para construir estructuras de datos como árboles binarios.

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

Grafos (Graphs)

La representación de grafos generalmente requiere estructuras de datos personalizadas o el uso de bibliotecas de grafos; Java no tiene una clase de grafos integrada.

Lo anterior son solo algunas estructuras de datos comunes en Java; en realidad, hay muchas otras estructuras de datos y algoritmos que se pueden elegir según el problema específico.

---

Otras notas

Las siguientes clases son heredadas tradicionalmente; en Java 2 se introdujo un nuevo marco: el marco de colecciones (Collection), que discutiremos más adelante.

Enumeración (Enumeration)

Aunque la interfaz Enumeración (Enumeration) no es en sí misma una estructura de datos, se aplica ampliamente en el ámbito de otras estructuras de datos. La interfaz Enumeration define una forma de recuperar elementos consecutivos de una estructura de datos.

Por ejemplo, la enumeración define un método llamado nextElement, que se utiliza para obtener el siguiente elemento de una estructura de datos que contiene múltiples elementos.

Para obtener más información sobre la interfaz de enumeración,consulte Enumeración (Enumeration)。

Conjunto de bits (BitSet)

La clase Conjunto de bits implementa un grupo de bits o indicadores que se pueden establecer y limpiar individualmente.

Esta clase es muy útil al manejar un grupo de valores booleanos; solo necesitas asignar un "bit" a cada valor y luego establecer o limpiar los bits adecuadamente para operar sobre los valores booleanos.

Para obtener más información sobre esta clase,consulte Conjunto de bits (BitSet)。

Vector

La clase Vector es muy similar a los arreglos tradicionales, pero el tamaño de Vector puede cambiar dinámicamente según sea necesario.

Al igual que los arreglos, los elementos de un objeto Vector también se pueden acceder mediante índices.

La principal ventaja de usar la clase Vector es que no es necesario especificar el tamaño al crear el objeto; su tamaño cambia dinámicamente según sea necesario.

Para obtener más información sobre esta clase,consulte Vector

Pila (Stack)

La pila (Stack) implementa una estructura de datos de último en entrar, primero en salir (LIFO).

Puedes entender la pila como una pila de objetos distribuidos verticalmente; cuando agregas un nuevo elemento, lo colocas en la parte superior de los demás elementos.

Cuando sacas un elemento de la pila, tomas un elemento desde la cima. En otras palabras, el último elemento que entró en la pila es el primero en ser extraído.

Para obtener más información sobre esta clase,consulte Pila (Stack)。

Diccionario (Dictionary)

La clase Diccionario (Dictionary) es una clase abstracta que define una estructura de datos donde las claves se asignan a valores.

Cuando deseas acceder a los datos mediante una clave específica en lugar de un índice entero, debes usar Dictionary.

Debido a que la clase Dictionary es abstracta, solo proporciona la estructura de datos de asignación de claves a valores, sin ofrecer una implementación específica.

Para obtener más información sobre esta clase,consulte Diccionario (Dictionary)。

La clase Dictionary ha quedado obsoleta (deprecated) en las versiones más recientes de Java; se recomienda usar la interfaz Map y sus clases de implementación, como HashMap, TreeMap, etc., en lugar de Dictionary.

La interfaz Map y sus clases de implementación se pueden consultar en:Marco de colecciones de Java。

Tabla hash (Hashtable)

La clase Hashtable proporciona un medio para organizar datos basándose en una estructura de claves definida por el usuario.

Por ejemplo, en una tabla hash de listas de direcciones, puedes usar el código postal como clave para almacenar y ordenar los datos, en lugar de usar nombres de personas.

El significado específico de las claves de una tabla hash depende completamente del contexto de uso de la tabla hash y de los datos que contiene.

Para obtener más información sobre esta clase,consulte Tabla hash (HashTable)。

Propiedades (Properties)

Properties hereda de Hashtable. La clase Properties representa un conjunto de propiedades persistente. Cada clave y su valor correspondiente en la lista de propiedades son cadenas.

La clase Properties es utilizada por muchas clases de Java. Por ejemplo, al obtener variables de entorno, sirve como valor de retorno del método System.getProperties().

Para obtener más información sobre esta clase,consulte Propiedades (Properties)。

Otras extensiones