Estructuras de datos en Java

1. Arrays

Es la estructura de datos más básica que cuenta Java.

Permite almacenar un número fijo de un mismo tipo.

Complejidad algorítmica

Insertar valores: O(1)

Ver valor: O(1)

Cambiar valor: (1)

Remover: O(n)

Recorrer: 0(n)

Cuando usarse

Cuando se requiera almacenar valores del mismo tipo, por ejemplo, números enteros. Es ideal para este tipo de tareas ya que al ser una estructura de tipo primitiva, está muy bien optimizada.

Ejemplos de uso:

• Lista de números enteros
• Caracteres dentro de un string.

String[] contries = {"México", "Argentina", "España", "Colombia"};
contries[1] = "Francia";
System.out.println(contries[1]); //Francia
//Ordenar
Arrays.sort(contries);   

2. ArrayList

Los ArrayList son un tipo de estructura de datos que tiene un comportamiento similar de un array, pero con la posibilidad de tener un tamaño flexible.

En el caso de Java, básicamente comparte las mismas operaciones que una lista ya que implementa la interfaz List.

Cuándo usarse

Lo ideal es usarse cuando necesites almacenar valores de un mismo tipo y no sepas de antemano el número de elementos que tendrá.

Directorio en el que se encuentra:

java.util.ArrayList;

Complejidad algorítmica

En cuanto a complejidad algorítmica, es prácticamente la misma que la de los Arraysm es decir:

Insertar valores: O(1)

Ver valor: O(1)

Cambiar valor: (1)

Remover: (n)

Recorrer: 0(n)

Ejemplos de uso

• Tener un conjunto de elementos en las que el orden es importante
• Almacenar elementos del mismo tipo y no saber el tamaño final que pueda tener.

ArrayList<String> cars = new ArrayList<String>();

//Agregar elemntos al arraylist
cars.add("Tesla");
cars.add("Mercedes");
cars.add("BMW");
cars.add("Ferrari");

//Elegir un elemento en específico
cars.get(0); // Tesla

//Verificar el largo
cars.size();

//Cambiar el valor
cars.set(2, "Audi");

//Ordenar el arraylist 
// Se necesita agregar: import java.util.Collections;  
Collections.sort(cars);  // Sort cars

//Imprimir todos los elmentos
for (String i : cars) {
    System.out.println(i);
  }

HashMap

Los hashmap son una estructura de datos compuesta por un llave o “key” y un valor.

En Java, es una de las implementaciones más usadas de la interface Map. Es también una de las colecciones más importantes.

Directorio en el que se encuentra:

java.util.Hashmap;

Complejidad algorítmica

Insertar valores: O(1)

Ver valor: O(1)

Cambiar valor: (1)

Remober: (1)

Recorrer: 0(n)

Cuando usarse

Los Hashmaps tienen sentido cuando se quieren almacenar valores particulares en función a otro valor único.

A diferencia de los arrays –que también cuentan con esa correspondencia con un valor de referencia– los hashmaps no tienen un orden en específico.

Ejemplos de uso:

• Cuando se quiere conocer el número de veces que se repiten las letras en una plabra
• Si se quiere contar el número total de visitas que ha hecho un usuario en específico

//Declarar el Hashmap
HashMap<Integer,String> countries=new HashMap<Integer,String>(); 

//Agregar valores
countries.put(1,"Argentina");  //Put elements in Map  
countries.put(2,"México");    
countries.put(3,"España");   
countries.put(4,"Colombia");

//Regresar el valor par una llave en específica
String country = map.get(2);

// Remover valores
countries.remove(3);

//Cambiar valores
countries.put(4,"Perú");

//Verificar si está el valor en el map
if (countries.containsKey(5)) {
	System.out.println("El valor se encuntra en el hashmap");
}

//Recorrer usando ForEach
countries.forEach((key, vvalue) -> 
				System.out.println(key + " : " + value));

//Recorrer usando la api de stream
countries.entrySet().stream()
      // ... Se realiza otra operación
      .forEach(e -> System.out.println(e.getKey() + ":" + e.getValue()));