Niklaus Wirth, informático suizo, escribió un libro en 1976 titulado Algoritmos + Estructura de Datos = Programas.

40+ años más tarde, esa ecuación se mantiene. Por eso, los candidatos a ingeniería de software tienen que demostrar su entendimiento de las estructuras de datos junto con sus aplicaciones.

Casi todos los problemas requieren que el candidato demuestre un profundo conocimiento de estructura de datos. No importa si recién te has graduado (de la universidad o bootcamp de programación), o si tienes décadas de experiencia.

A veces las preguntas de la entrevista mencionan explícitamente una estructura de datos, por ejemplo, "dado un árbol binario. "Otras veces es implícito, como "queremos rastrear el número de libros asociados a cada autor."

Aprender estructura de datos es esencial, incluso si solo estás tratando de mejorar en tu trabajo actual. Empecemos con entender lo básico.

¿Qué es una Estructura de Datos?

De manera simple, una estructura de datos es un contenedor que almacena datos en una disposición específica. Esta "disposición" permite que una estructura de datos sea eficiente en algunas operaciones e ineficiente en otras. Tu meta es comprender las estructuras de datos para que puedas elegir la que sea más óptima para el problema en cuestión.

¿Por qué necesitamos Estructuras de Datos?

Así como las estructuras de datos son usadas para almacenar datos de una forma organizada, y dado que los datos son la entidad más crucial en informática, el verdadero valor de las estructuras de datos es claro.

No importa qué problema estés resolviendo, de un modo u otro tienes que tratar con datos — ya sea el salario de un empleado, precios de acciones, una lista de compras, o incluso un directorio telefónico simple.

Basado en diferentes escenarios, los datos necesitan ser almacenados en un formato específico. Tenemos un puñado de estructuras de datos que cubren nuestra necesidad de almacenar datos en distintos formatos.

Estructuras de Datos más Usadas

Enlistemos primero las estructuras de datos más usadas, y después las revisaremos una por una:

1. Arreglos
2. Pilas
3. Colas
4. Listas Enlazadas
5. Árboles
6. Grafos
7. Tries (en realidad son árboles, pero es bueno mencionarlos por separado).
8. Tablas Hash

Arreglos

Un arreglo es la más simple y más usada estructura de datos. Otras estructuras de datos, como las pilas y las colas, provienen de los arreglos.

A continuación puedes ver una imagen de un arreglo simple de tamaño 4, que contiene elementos (1, 2, 3 y 4).

A cada elemento de datos se le asigna un valor numérico positivo llamado índice, que corresponde a la posición de ese elemento en el arreglo. La mayoría de los lenguajes definen al 0 (cero) como el índice inicial.

Los dos tipos de arreglos son:

• Arreglos unidimensionales (como el de la imagen de arriba)
• Arreglos multidimensionales (arreglos dentro de arreglos)

Operaciones Básicas con Arreglos

• Insert — Inserta un elemento en un índice dado
• Get — Devuelve el elemento sobre un índice dado
• Delete — Borra un elemento sobre un índice dado
• Size — Obtiene la cantidad total de elementos en un arreglo

Preguntas Frecuentes sobre Arreglos en las Entrevistas

• Encontrar el segundo elemento mínimo de un arreglo
• Los primeros enteros no repetidos en un arreglo
• Combinar dos arreglos ordenados
• Reordenar los valores positivos y negativos en un arreglo

Pilas

Todos conocemos la famosa opción Deshacer(Undo), que está presente en casi todas las aplicaciones. ¿Te has preguntado alguna vez cómo funciona? La idea: almacenas los estados previos de tu trabajo (que están limitados a un número específico) en la memoria en cierto orden tal que el último aparece primero. Esto no se puede hacer solo usando arreglos. Aquí es donde la Pila resulta útil.

Un ejemplo de la vida real del uso de la Pila podría ser una pila de libros colocados en orden vertical. Para obtener el libro que está en algún lugar en medio, necesitarás remover todos los libros que están encima de él. Así es como funciona el método LIFO (Last In First Out; en español UEPS, o Último en Entrar, Primero en Salir).

Abajo puedes encontrar una imagen de una pila que contiene 3 elementos de datos (1, 2 y 3), donde 3 está en la cima y será removido primero:

Operaciones básicas de la pila:

• Push — Inserta un elemento en la cima
• Pop — Devuelve el elemento de la cima después de eliminarlo de la pila
• isEmpty — Devuelve verdadero si la pila está vacía
• Top — Devuelve el elemento que está en la cima sin eliminarlo de la pila

Preguntas Frecuentes sobre Pilas en las Entrevistas

• Evaluar una expresión postfijas usando una pila
• Ordenar valores en una pila
• Comprobar paréntesis equilibrados en una expresión

Colas

Similar a la Pila, la Cola es otra estructura de datos lineal que almacena elementos de manera secuencial. La única diferencia significativa entre la Pila y la Cola es que en lugar de usar el método LIFO, la Cola implementa el método FIFO (First In First Out; en español PEPS, o Primero en Entrar Primero en Salir).

Un ejemplo perfecto de la Cola en la vida real: una fila de personas esperando en taquilla. Si llega una nueva persona, se formará al final de la fila, no al inicio — y la persona situada al inicio de la fila será la primera en conseguir boleto y, por lo tanto, la primera en dejar la fila.

A continuación una imagen de la Cola conteniendo cuatro elementos de datos (1, 2, 3 y 4), donde 1 está al inicio y será removido primero:

Operaciones básicas de la Cola

• Enqueue() — Inserta un elemento al final de la cola
• Dequeue() — Elimina un elemento del inicio de la cola
• isEmpty() — Devuelve verdadero si la cola está vacía
• Top() — Devuelve el primer elemento de la cola

Preguntas Frecuentes sobre Colas en las Entrevistas

• Implementar una pila usando una cola
• Invertir los primeros k elementos de una cola
• Generar números binarios desde 1 hasta n usando una cola

Lista enlazada

Una lista enlazada es otra estructura de datos lineal importante que a primera vista puede lucir similar a los arreglos, pero difiere en la asignación de memoria, la estructura interna y la forma en que se llevan a cabo las operaciones básicas de inserción y eliminación.

Una lista enlazada es como una cadena de nodos, donde cada nodo contiene información como datos y un puntero al siguiente nodo de la cadena. Hay un puntero a la cabecera, que apunta al primer elemento de la lista enlazada, y si la lista está vacía, entonces simplemente apunta a null o nada.

Las listas enlazadas son usadas para implementar sistemas de archivos, tablas hash y listas de adyacencia.

Aquí está una representación visual de la estructura interna de una lista enlazada:

A continuación se muestran los tipos de listas enlazadas:

• Lista Simple Enlazada (Unidireccional)
• Lista Doblemente Enlazada (Bidireccional)

Operaciones básicas de las Listas Enlazadas

• InsertAtEnd — Inserta un elemento dado al final de la lista enlazada
• InsertAtHead — Inserta un elemento dado al inicio/cabeza de la lista enlazada
• Delete — Elimina un elemento dado de la lista enlazada
• DeleteAtHead — Elimina el primer elemento de la lista enlazada
• Search — Devuelve el elemento dado de una lista enlazada
• isEmpty — Retorna verdadero si la lista enlazada está vacía

Preguntas Frecuentes sobre Listas Enlazadas en las Entrevistas

• Invertir una lista enlazada
• Detectar bucle en una lista enlazada
• Devolver el nodo N del final de una lista enlazada
• Eliminar duplicados de una lista enlazada

Grafos

Un grafo es un conjunto de nodos que están conectados entre sí en forma de red. Los nodos son también llamados vértices. Un par(x,y) se denomina arista, que indica que el vértice x está conectado al vértice y. Una arista puede contener peso/costo, mostrando cuánto cuesta viajar del vértice x al y.

Tipos de Grafos:

• Grafo no dirigido
• Grafo dirigido

En lenguaje de programación, los grafos pueden ser representados de dos formas:

• Matriz de adyacencia
• Lista de adyacencia

Algoritmos comunes de recorrido de grafos:

• Recorrido o Búsqueda en Amplitud o Anchura
• Recorrido o Búsqueda en Profundidad

Preguntas Frecuentes sobre Grafos en las Entrevistas

• Implementar Recorrido en Amplitud o Anchura y en Profundidad
• Comprobar si un grafo es un árbol o no
• Contar el número de aristas en un grafo
• Encontrar el camino más corto entre dos vértices

Árboles

Un árbol es una estructura de datos jerárquica que consiste en vértices (nodos) y aristas que los conectan. Los árboles son similares a los grafos, pero la diferencia clave entre ellos es que un ciclo no puede existir en un árbol.

Los árboles son usados extensamente en la Inteligencia Artificial y algoritmos complejos para proveer un mecanismo eficiente de almacenamiento para la resolución de problemas.

Abajo se puede ver la imagen de un árbol simple, y la terminología básica usada en la estructura de datos de un árbol:

Lo siguiente son los tipos de árboles:

• Árbol N-ario
• Árbol Equilibrado
• Árbol Binario
• Árbol de Búsqueda Binaria
• Árbol AVL
• Árbol Rojo Negro
• Árbol 2-3

De todos los mencionados, el Árbol Binario y el Arbol de Búsqueda Binaria son los más comúnmente usados.

Preguntas Frecuentes sobre Árboles en las Entrevistas

• Hallar la altura de un árbol binario
• Hallar el k-ésimo valor máximo en un árbol de búsqueda binaria
• Hallar los nodos a "k" distancia desde la raíz
• Hallar los ancestros de un nodo dado en un árbol binario

Trie

Trie, también conocido como "Árboles de Prefijos", es una estructura de datos en forma de árbol que prueba ser muy eficiente para resolver problemas relacionados con cadenas de caracteres. Proporciona una recuperación rápida y es mayormente usada para buscar palabras en un diccionario, proveer sugerencias automáticas en un motor de búsqueda, e incluso para enrutamiento IP.

Abajo hay una ilustración de cómo las tres palabras “top”, “thus”, y “their” se almacenan en un Trie:

Las palabras son almacenadas de arriba a abajo donde los nodos de color verde “p”, “s” y “r” indican el final de “top”, “thus”, y “their” respectivamente.

Preguntas Frecuentes sobre Tries en las Entrevistas

• Contar el número total de palabras en un Trie
• Imprimir todas las palabras almacenadas en un Trie
• Ordenar los elementos de un arreglo usando un Trie
• Formar palabras a partir de un diccionario usando un Trie
• Construir un diccionario T9

Tabla Hash

El Hashing es un proceso utilizado para identificar objetos de forma única, y almacenar cada objeto en algún índice único precalculado llamado su "llave". Entonces, el objeto es almacenado en forma de un par "llave-valor", y la colección de dichos elementos es llamada "diccionario". Cada objeto puede ser buscado usando esa llave. Hay diferentes estructuras de datos basadas en hashing, pero la más usada es la tabla hash.

Las tablas hash generalmente se implementan usando arreglos.

El rendimiento de la estructura de datos hash depende de estos tres factores:

• Función Hash
• Tamaño de la Tabla Hash
• Método de Manejo de Colisiones

Aquí hay una ilustración de cómo el hash es mapeado en un arreglo. El índice de este arreglo es calculado mediante una Función Hash.

Preguntas Frecuentes sobre Hash en las Entrevistas

• Hallar pares simétricos en un arreglo
• Trazar el camino completo de un viaje
• Hallar si un arreglo es un subconjunto de otro arreglo
• Comproban si arreglos dados son disjuntos

Éstas son las ocho principales estructuras de datos que definitivamente deberías conocer antes de presentarte a una entrevista de programación.

¡Buena suerte y feliz aprendizaje! :)

La interfaz en Java es un poco como la Clase, pero con una diferencia significativa: una interface puede tener firmas de métodos, campos y métodos predeterminados. Desde Java 8, también puedes crear métodos predeterminados. En el siguiente bloque puedes ver un ejemplo de interfaz:

public interface Vehiculo {
    public String matricula = "";
    public float maxVel
    public void arrancar();
    public void detener();
    default void claxon(){
      System.out.println("Sonando claxon");
   }
}

La interfaz anterior contiene dos campos, dos métodos y un método predeterminado. Solo, no es de mucha utilidad, pero normalmente se usan junto con las Clases. ¿Cómo? Simple, tienes que asegurarte de que alguna clase lo implemente (implements).

public class Coche implements Vehiculo {
    public void arrancar() {
        System.out.println("arrancando motor...");
    }
    public void detener() {
        System.out.println("deteniendo motor...");
    }
}

Ahora, hay una regla básica: la clase debe implementar todos los métodos que hay en la interfaz. Los métodos deben tener exactamente la misma firma (nombre, parámetros y excepciones) como se describe en la interfaz. Sin embargo, la clase no necesita declarar los campos, solo los métodos.

Instancias de una interfaz

Una vez que creas una clase Java que implements (implementa) cualquier interfaz, se puede hacer referencia a la instancia del objeto como una instancia de la interfaz. Este concepto es similar al de creación de instancias de herencia.

// siguiendo nuestro ejemplo anterior

Vehiculo tesla = new Coche();

tesla.arrancar(); // arrancar el motor...

Una interfaz no puede contener métodos constructores. Por lo tanto, no puedes crear una instancia de una interfaz en sí. Debes crear una instancia de alguna clase que implemente una interfaz para hacer referencia a ella.

Piensa en las interfaces como un formulario de contrato en blanco o una plantilla.

¿Qué puedes hacer con esta función? ¡Polimorfismo! ¡Puedes usar solo interfaces para referirte a instancias de objetos!

class Camion implements Vehiculo {
    public void arrancar() {
        System.out.println("arrancando el motor del camión...");
    }
    public void detener() {
        System.out.println("deteniendo el motor del camión...");
    }
}

class Arrancador {
    // método estático, se puede llamar sin instanciar la clase
    public static void arrancarMotor(Vehiculo vehiculo) {
        vehiculo.arrancar();
    }
}

Vehiculo tesla = new Coche();
Vehiculo tata = new Camion();

Arrancador.arrancarMotor(tesla); // arrancando motor...
Arrancador.arrancarMotor(tata); // arrancar el motor del camión...

Pero, ¿qué hay de las múltiples interfaces?

Sí, puedes implementar varias interfaces en una sola clase. Mientras estaba en Herencia dentro de las clases estaba restringido a heredar solo una clase, aquí puedes ampliar cualquier cantidad de interfaces. Pero no olvides implementar todos los métodos de todas las interfaces, de lo contrario, la compilación fallará.

public interface GPS {
    public void obtenerCoordenadas();
}

public interface Radio {
    public void iniciarRadio();
    public void detenerRadio();
}

public class Smartphone implements GPS,Radio {
    public void obtenerCoordenadas() {
        // devuelve algunas coordenadas
    }
    public void iniciarRadio() {
      // iniciar Radio
    }
    public void detenerRadio() {
        // detener Radio
    }
}

Algunas características de las interfaces

• Puedes colocar variables dentro de una interfaz, aunque no será una decisión sensata, ya que las clases no están obligadas a tener la misma variable. En resumen, ¡evita colocar variables!
• Todas las variables y métodos en una interfaz son públicos, incluso si omites la palabra clave public.
• Una interfaz no puede especificar la implementación de un método en particular. Depende de las Clases hacerlo. Aunque ha habido una excepción reciente (ver más abajo).
• Si una clase implementa varias interfaces, existe una posibilidad remota de superposición de la firma del método. Dado que Java no permite múltiples métodos de la misma firma exacta, podría generar problemas. Consulta esta pregunta para obtener más información.

Métodos predeterminados de la interfaz

Antes de Java 8, no teníamos forma de dirigir una interfaz para que tuviera una implementación de método particular, lo que genera mucha confusión y roturas de código si la definición de una interfaz cambia repentinamente.

Pongamos que escribes una biblioteca de código abierto, que contiene una interfaz. Digamos que tus clientes, es decir, prácticamente todos los desarrolladores de todo el mundo, lo están usando mucho y están contentos. Ahora has tenido que actualizar la biblioteca agregando una nueva definición de método a la interfaz para admitir una nueva característica. Pero eso rompería todas las compilaciones, ya que todas las clases que implementan esa interfaz tienen que cambiar ahora. ¡Qué catástrofe!

Afortunadamente, Java 8 ahora nos proporciona métodos default (predeterminados) para interfaces. ¡Un método default puede contener su propia implementación directamente dentro de la interfaz! Entonces, si una Clase no implementa un método predeterminado, el compilador tomará la implementación mencionada dentro de la Interfaz. Bonito, ¿no? Entonces, en tu biblioteca, puede agregar cualquier cantidad de métodos predeterminados en las interfaces sin miedo a estropear nada.

public interface GPS {
    public void obtenerCoordenadas();
    default public void obtenerCoordenadasAproximadas() {
        // implementación para devolver coordenadas de fuentes aproximadas
        // como wifi y móvil
        System.out.println("Obteniendo coordenadas aproximadas por wifi y GSM...");
    }
}

public interface Radio {
    public void iniciarRadio();
    public void detenerRadio();
}

public class Smartphone implements GPS,Radio {
    public void obtenerCoordenadas() {
        // devuelve algunas coordenadas
    }
    public void iniciarRadio() {
      // iniciar Radio
    }
    public void detenerRadio() {
        // detener Radio
    }

    // sin implementación de getRoughCoordinates()
}

Smartphone motoG = new Smartphone();
motog.obtenerCoordenadasAproximadas(); // Obteniendo coordenadas aproximadas por wifi y GSM...

Pero, ¿qué sucede si dos interfaces tienen la misma firma de método?

Gran pregunta. En ese caso, si no proporcionas la implementación en la clase, el pobre compilador se confundirá y simplemente fallará. También debes proporcionar una implementación de método predeterminada dentro de la Clase. También hay una forma ingeniosa de usar super para llamar a la implementación que te gusta:

public interface Radio {
    // public void iniciarRadio();
    // public void detenerRadio();

    default public void siguiente() {
        System.out.println("Siguiente emisora de Radio");
    }
}

public interface ReproductorMusica {
    // public void iniciar();
    // public void pausar();
    // public void detener();

    default public void siguiente() {
        System.out.println("Siguiente canción del Reproductor de Música");
    }
}

public class Smartphone implements Radio, ReproductorMusica {
    public void siguiente() {
        // Supongamos que deseas llamar a siguiente del ReproductorMusica
        ReproductorMusica.super.siguiente();
    }
}

Smartphone motoG = new Smartphone();
motoG.siguiente();  // Siguiente desde ReproductorMusica

Métodos estáticos en interfaces

Otra novedad de Java 8 es la capacidad de agregar métodos estáticos a las interfaces. Los métodos estáticos en interfaces son casi idénticos a los métodos estáticos en clases concretas. La única gran diferencia es que los métodos static no se heredan en las clases que implementan la interfaz. Esto significa que se hace referencia a la interfaz cuando se llama al método estático, no a la clase que lo implementa.

interface ReproductorMusica {
  public static void comercial(String patrocinador) {
    System.out.println("Nuevo mensaje de " + patrocinador);
  }
  
  public void play();
}


class Smartphone implements ReproductorMusica {
	public void reproducir() {
		System.out.println("Reproduciendo desde el Smartphone");
	}
}

class Main {
  public static void main(String[] args) {
    Smartphone motoG = new Smartphone();
    ReproductorMusica.comercial("Motorola"); 
    // Llamada a la interfaz no a la clase implementada
    // motoG.comercial("Motorola");  // Esto causaría un error de compilación
  }
}

Heredar una interfaz

También es posible en Java que una interfaz herede otra interfaz usando, la palabra clave extends:

public interface Reproductor {
    public void iniciar();
    public void pausar();
    public void detener();
}

public interface ReproductorMusica extends Reproductor {
    default public void siguiente() {
        System.out.println("siguiente canción del Reproductor de Música");
    }
}

Eso significa que la clase que implementa ReproductorMusica tiene que implementar todos los métodos de ReproductorMusica así como los de Reproductor:

public class SmartPhone implements ReproductorMusica {
    public void iniciar() {
        System.out.println("iniciar");
    }
    public void detener() {
        System.out.println("detener");
    }
    public void pausar() {
        System.out.println("pausar");
    }
}

¡Ahora ya tienes una buena comprensión de las interfaces de Java! Obtén información sobre las clases abstractas para ver cómo Java te brinda otra forma de definir contratos.

Una lista con preguntas frecuentes de Java en entrevistas de trabajo para programadores.

¡Hola todos! En los últimos años, he estado compartiendo muchas preguntas y debates sobre entrevistas de Java individualmente. Muchos de mis lectores me han pedido que las reúna para poder tenerlas en un mismo lugar. Este post es el resultado de ello.

Este artículo contiene más de 50 preguntas de entrevistas de Java que cubren todos los temas importantes, como los fundamentos de Core Java, Java Collection Framework , Java Multithreading and Concurrency , Java IO , JDBC , JVM Internals , Problemas de codificación , Programación orientada a objetos , etc.

Las preguntas también están extraídas de varias entrevistas y no son, en modo alguno, muy difíciles. Es posible que ya las hayas visto en tu teléfono o en la ronda de entrevistas cara a cara.

Las preguntas también son muy útiles para repasar temas importantes como hilos o subprocesos múltiples y colecciones. También he compartido algunos recursos útiles para seguir aprendiendo y mejorando, como The Complete Java MasterClass para repasar y llenar los vacíos en tus habilidades de Java.

Entonces... ¿Qué estamos esperando? Aquí está la lista de algunas de las preguntas de Java más frecuentes en entrevistas para desarrolladores de Java principiantes y experimentados.

Más de 50 preguntas de entrevista de Java para programadores experimentados de 2 a 3 años

Pues... sin perder más tiempo, aquí está mi lista de algunas preguntas de entrevista de Core Java más frecuentes para programadores principiantes. Esta lista se enfoca en principiantes y desarrolladores menos experimentados, con 2 o 3 años de experiencia en Java.

1) ¿Cómo consigue Java la independencia de la plataforma? (respuesta)

pista: bytecode y Java Virtual Machine

2) ¿Qué es el ClassLoaderen Java? (respuesta)

pista: parte de JVM que carga bytecodes para clases. Puedes escribir el tuyo propio.

3) ¿Escribir un programa Java para comprobar si un número es par o impar? (respuesta)

pista: puedes usar el operador bit a bit, como AND bit a bit, recuerda que, los números pares tienen un cero al final en formato binario y los impares acaban en 1.

4) ¿Diferencia entre ArrayListy HashSeten Java? (respuesta)

pista: todas las diferencias entre Listy Setson aplicables aquí, por ejemplo, ordenamiento, duplicados, búsqueda aleatoria, etc. Consulta Fundamentos de Java: colecciones de Richard Warburton para obtener más información sobre ArrayList, HashSet y otras colecciones importantes en Java.

5) ¿Qué es el bloqueo de doble verificación en Singleton? (respuesta)

pista: verifica dos veces si las instancias están inicializadas o no, primero sin bloqueo y segundo con bloqueo.

6) ¿Cómo se crea Singleton seguro para subprocesos en Java? (respuesta)

pista: de muchas maneras, como usar Enum o usar un patrón de bloqueo verificado dos veces así cómo usar una clase estática anidada.

7) ¿Cuándo usar la variable volátil en Java? (respuesta)

pista: cuando necesitas indicar a la JVM que una variable puede ser modificada por múltiples subprocesos y dar una pista a la JVM para que no almacene en caché su valor.

8) ¿Cuándo usar una variable transitoria en Java? (respuesta)

pista: cuando quieras hacer que una variable no sea serializable en una clase que implemente la interfaz Serializable. En otras palabras, puedes usarla para una variable cuyo valor no quieras guardar. Consulta The Complete Java MasterClass para obtener información sobre las variables transitorias en Java.

9) ¿Diferencia entre la variable transitoria y volátil en Java?  (respuesta)

pista: totalmente diferente, una se usa en el contexto de la serialización mientras que la otra se usa en concurrencia.

10) ¿Diferencia entre serializable y externalizable en Java? (respuesta)

pista: externalizable da más control sobre el proceso de serialización.

11) ¿Podemos sobreescribir un método privado en Java? (respuesta)

pista: No, porque no está visible en la subclase, que es requisito principal para sobreescribir un método en Java.

12) ¿Diferencia entre Hashtable y HashMapen Java? (respuesta)
pista: varias pero la más importante es que Hashtable está sincronizada, mientras que HashMapno lo está. También es heredada y lenta en comparación con HashMap.

13) ¿Diferencia entre List y Set en Java? (respuesta)

pista: Listestá ordenada y permite duplicacidad. Setestá desordenado y no permite elementos duplicados.

14) Diferencia entre ArrayList y Vectoren Java (respuesta)

pista: muchas, pero lo más importante es que ArrayList no está sincronizada y es rápida, mientras que Vector está sincronizada y es lenta. También es una clase heredada como Hashtable.

15) ¿Diferencia entre Hashtabley ConcurrentHashMapen Java? (respuesta)

pista: más escalable. Consulte Fundamentos de Java: Colecciones de Richard Warburton para obtener más información.

16) ¿Cómo consigue ConcurrentHashMap escalabilidad? (respuesta)

pista: dividiendo el mapa en segmentos y solo bloqueando durante la operación de escritura.

17) ¿Qué dos métodos sobreescribir para que Objectse use como Keyen HashMap? (respuesta)

pista: equals y hashcode

18) ¿Diferencia entre esperar y dormir en Java? ( respuesta )

pista: el método wait() libera el bloqueo o monitoriza, mientras que sleep() no lo hace.

19) ¿Diferencia entre notify y notifyAllen Java? (respuesta)

pista: notify notifica que un subproceso aleatorio está esperando el bloqueo mientras notifyAll informa a todos los subprocesos que esperan un monitor. Si estás seguro de que solo hay un subproceso en espera, usa notify, sinó notifyAlles preferible. Consulta el minicurso de conceptos básicos de creación de subprocesos impartido por el campeón de Java Heinz Kabutz para obtener más información sobre los conceptos básicos de creación de subprocesos.

20) ¿Por qué anula el código hash, junto con equals()Java? (respuesta)

pista: para cumplir con la función de equals y hashcode, que se requiere si planeas almacenar un objeto en clases de colección, por ejemplo, HashMapo ArrayList.

21) ¿Qué representa el factor de carga de HashMap? (respuesta)

pista: el umbral que activa el cambio de tamaño HashMapes generalmente 0,75, lo que significa que HashMap cambia de tamaño si está lleno en un 75 por ciento.

22) ¿Diferencia entre ArrayList y LinkedListen Java? (respuesta)

pista: la misma que una matriz y una lista vinculada, una permite la búsqueda aleatoria mientras que la otra no. La inserción y la eliminación son fáciles en la lista vinculada, pero la búsqueda es fácil en una matriz. Consulta Fundamentos de Java: Colecciones , el curso de Richard Warburton sobre Pluralsight, para obtener más información sobre la estructura de datos de colección esencial en Java.

23) ¿Diferencia entre CountDownLatchy CyclicBarrieren Java? (respuesta)

pista: puedes reutilizar CyclicBarrierdespués de que se rompa la barrera, pero no puedes reutilizar CountDownLatchdespués de que el conteo llegue a cero.

24) ¿Cuándo usar Runnable vs Threaden Java? (respuesta)

pista: siempre

25) ¿Cuál es el significado de que Enum sea seguro para tipos en Java? (respuesta)

pista: significa que no se puede asignar una instancia de diferente tipo Enum a una variable Enum. por ejemplo, si tienes una variable como DiaDeLaSemana, entonces no puedes asignarle al día un valor desde una enumeración DiaDelMes.

26) ¿Cómo funciona Autoboxing of Integer en Java? (respuesta)

pista: Usando el método valueOf() en Java.

27) ¿Diferencia entre PATHy Classpath en Java? (respuesta)

pista: PATHlo utiliza el sistema operativo, mientras que Classpath lo utiliza JVM para localizar archivos binarios de Java, por ejemplo, archivos JAR o archivos de clase. Consulta Fundamentos de Java: la plataforma principal para obtener más información acerca de PATH, Classpath, y otras variables de entorno de Java.

28) ¿Diferencia entre sobrecarga y anulación de métodos en Java? (respuesta)

pista: la sobreescritura ocurre en la subclase mientras que la sobrecarga ocurre en la misma clase. Además, la sobreescritura es una actividad en tiempo de ejecución, mientras que la sobrecarga se resuelve en tiempo de compilación.

29) ¿Cómo evitar que una clase se subclasifique en Java? (respuesta)

pista: simplemente haciendo que tu constructor sea privado

30) ¿Cómo restringir una clase para que no sea utilizada por el cliente? (respuesta)

pista: haciendo que el constructor sea privado o lanzando una excepción desde el constructor

31) ¿Diferencia entre StringBuildery StringBufferen Java? (respuesta)

pista: StringBuilderno está sincronizado mientras que StringBufferestá sincronizado.

32) ¿Diferencia entre polimorfismo y herencia en Java? (respuesta)

pista: la herencia permite la reutilización del código y construye la relación entre clases, lo cual es requerido por el polimorfismo, que proporciona un comportamiento dinámico. Consulta Fundamentos de Java: diseño orientado a objetos para obtener más información sobre las funciones de programación orientada a objetos.

33) ¿Podemos sobreescribir un método estático en Java? (respuesta)

pista: No, porque la sobreescritura se resuelve en tiempo de ejecución mientras que la llamada al método estático se resuelve en tiempo de compilación.

34) ¿Podemos acceder al método privado en Java? (respuesta)

pista: sí, en la misma clase pero no fuera de la clase

35) ¿Diferencia entre interfaz y clase abstracta en Java? (respuesta)

pista: desde Java 8 , la diferencia es borrosa. Sin embargo, una clase Java aún puede implementar múltiples interfaces pero solo puede extender una clase.

36) ¿Diferencia entre el analizador DOM y SAX en Java? (respuesta)

pista: DOM carga todo el archivo XML en la memoria mientras que SAX no lo hace. Es un analizador basado en eventos y se puede usar para analizar un archivo grande, DOM es rápido y es preferible para archivos pequeños.

37) ¿Diferencia entre la palabra clave throw y throws en Java? (respuesta)

pista: throws declara qué excepción puede lanzar un método en caso de error, pero la palabra clave throw en realidad arroja una excepción. Consulta Conceptos básicos de Java: manejo de excepciones para obtener más información sobre el manejo de excepciones en Java.

38) ¿Diferencia entre iteradores a prueba de fallos y rápidos en Java? (respuesta)

pista: a prueba de fallos no arroja ConcurrentModificationException mientras que fail-fast lo hace cada vez que detecta un cambio externo en la colección subyacente mientras itera sobre ella.

39) ¿Diferencia entre iterador y enumeración en Java? (respuesta)

pista: Iterator también proporciona la capacidad de eliminar un elemento mientras itera, sin embargo Enumeration no lo permite.

40) ¿Qué es IdentityHashMap en Java? (respuesta)

pista: Un Map, que utiliza el operador de igualdad== para verificar la igualdad en lugar del método equals().

41) ¿Qué es el String pool en Java? (respuesta)

pista: un grupo de String literales. Recuerda que se movió al heap desde el perm gen space en JDK 7.

42) ¿Puede una clase Serializable contener un campo no serializable en Java? (respuesta)

pista: Sí, pero debe ser estático o transitorio.

43) ¿Diferencia entre this y super en Java? (respuesta)

pista: this se refiere a la instancia actual, mientras que super se refiere a una instancia de la superclase.

44) ¿Diferencia entre Comparatory Comparableen Java? (respuesta)

pista: Comparatordefine el orden personalizado mientras Comparabledefine el orden natural de los objetos, por ejemplo, el orden alfabético para String. Consulta The Complete Java MasterClass para obtener más información sobre la clasificación en Java.

45) ¿Diferencia entre java.util.Date y java.sql.Date en Java? (respuesta)

pista: la primera contiene tanto la fecha como la hora, mientras que la segunda contiene sólo  parte de la fecha.

46) ¿Por qué los métodos esperar y notificar se declaran en la claseObject en Java? (respuesta)

pista: porque requieren un bloqueo que solo está disponible para un Object.

47) ¿Por qué Java no admite herencias múltiples? (respuesta)

pista: No es compatible debido a una mala experiencia con C++, pero con Java 8, en cierto sentido sí lo es; sólo la herencia múltiple deType no son compatibles con Java ahora.

48) ¿Diferencia entre Excepción marcada y no marcada en Java? (respuesta)

pista: en caso de ser checked, debes manejar la excepción usando el bloque catch, mientras que en caso de no ser checked, depende del programador; no dará error al compilar.

49) ¿Diferencia entre error y excepción en Java? (respuesta)

pista: estoy cansado de escribir por favor comprueba la respuesta

50) ¿Diferencia entre la condición de Race y el Deadlock en Java? (respuesta)

pista: ambos son errores que ocurren en una aplicación concurrente, uno ocurre debido a la programación de hilos, threads o subprocesos mientras que el otro ocurre debido a una codificación deficiente. Consulta Multithreading and Parallel Computing in Java (Cómputo en paralelo y subprocesos múltiples en Java) para obtener más información sobre Deadlocks, condiciones de Race y otros problemas de subprocesos múltiples (multithreading).

Notas de cierre

Gracias, Llegaste al final del artículo… ¡Buena suerte con tu entrevista de programación! Ciertamente no será fácil, pero siguiendo esta hoja de ruta y esta guía, estarás un paso más cerca de convertirte en un ingeniero de DevOps .

Recursos adicionales (en inglés)

P.D. — si necesitas algunos recursos GRATUITOS para aprender Java, puedes consultar esta lista de cursos gratuitos de Java para comenzar tu preparación.

P.S.S. — no he proporcionado la respuesta a las preguntas de la entrevista compartidas en la imagen "¿Cuántos objetos String se crean en el código?" ¿Podrías adivinar y explicar?

Una certificación en Java es muy estimada en la industria TI y provee de un reconocimiento mundial a un desarrollador Java. Te ayudará a conseguir un mejor empleo, un mejor salario o incluso, un aumento o bono en tu trabajo actual.

Por esta razón, miles de programadores Java intentan certificarse cada año, pero el éxito no es sencillo en este examen

La certificación en Java de Oracle tiene un porcentaje de aprobación cercano al 65% para OCAJP (the Oracle Certified Associate Java Programmer) y OCPJP (the Oracle Certified Professional Java Programmer).

Y necesitas un gran nivel de conocimiento en el lenguaje Java y la API para aprobar el examen.

Prepararte para el OCPJP no es muy diferente que hacerlo para el OCAJP, sin embargo, tendrás que usar recursos enfocados en OCPJP, también tendrás que abarcar más temas y tener una mayor preparación, porque OCPJP 8 es un hueso duro de roer.

Para que puedas prepararte bien y obtener una puntuación alta, compartiré algunos consejos. Estos consejos me han ayudado en el pasado a conseguir una puntuación de más del 90% en las certificaciones.

Y para no perder más tiempo, aquí están mis 5 consejos para preparar bien los exámenes OCAJP y OCPJP.

1. Escribe código diariamente

No hay un sustituto para la práctica. Debes escribir código todos los días para desarrollar una lógica de programación que te ayudara a la hora de leer el código que vendrá en los exámenes.

En el caso del OCPJP, esto será aún más importante, ya que requerirás una gran atención al detalle para entender cada pregunta antes de poder contestar.

2. Únete a un buen curso

En mi opinión, los cursos en línea son una de las mejores formas de aprender una nueva tecnología en un corto periodo de tiempo, y es lo mismo para prepararte para un examen de certificación, como las Java de Oracle.

Son la segunda mejor manera de aprender, solo después de un instructor personal, ya que de esta forma aprenderás de la mano de profesionales con experiencia en la industria, que han pasado por el mismo camino y conocen los baches y errores con los que te podrías topar.

Cuando me preparé para mi certificación en Java hace más de 10 años, solamente había libros, en especial el libro de Khalid Mughal, pero ahora tú tienes muchas más opciones en libros y cursos.

1. Curso de entrenamiento Whizlab’s OCAJP 8
2. Curso de entrenamiento Whizlab’s OCPJP 8
3. Oracle Java Certification — Pass the Associate 1Z0–808 ExamOracle Java Certification — Pass the Associate 1Z0–808 ExamOracle Java Certification — Pass the Associate 1Z0–808 ExamOracle Java Certification — Pass the Associate 1Z0–808 ExamOracle Java Certification — Pass the Associate 1Z0–808 ExamOracle Java Certification — Pass the Associate 1Z0–808 ExamOracle Java Certification — Pass the Associate 1Z0–808 ExaOracle Java Certification — Pass the Associate 1Z0–808 ExamCertificación Oracle Java — Aprueba el examen Associate 1Z0–808

3. Lee una buena guía de estudio.

No hay mejor compañera que una buena guía de estudio si te estás preparando para una certificación en Java.

Cubren todos los temas del examen, tienen preguntas de práctica al final de cada capítulo y comparten muchos consejos enfocados a exámenes que no encontraras en un libro normal de Java.

Hay diferentes guías de estudio disponibles en el mercado, pero si te estás preparando para OCAJP 7 u OCAJP 8 puedes visitar estas páginas para encontrar una buena guía de estudio.

1. OCA - Oracle Certified Associate Java SE 8 Programmer I - por Jean Boyarsky y Scott Selikoff
2. Guía de certificacion OCA Java SE 8 Programmer I (Examen 1Z0–808) (Mala Gupta)
3. Oracle Certified Professional Java SE 8 Programmer, Examen 1Z0–809 Por Ganesh, Hari y Tushar

4. Escoge un buen simulador de examen.

Después de escoger un buen libro o guía de estudio, necesitarás un simulador de examen. Esto es muy importante si quieres tener una calificación alta, pero si solo quieres pasar el examen no es tan necesario.

El simulador de examen te ayudará a desarrollar la velocidad y precisión requerida para completas todas las preguntas en 2.5 horas.

Recomiendo hacer exámenes de práctica hasta que alcances una calificación del 80% de manera constante antes de ir por el examen real.

Aquí hay algunas de mis recomendaciones de simuladores de examen:

1. Whizlab’s Exam Simulator
   Son los mejores en el mercado, probado por muchos desarrolladores, incluyéndome a mí.
2. Enthuware’s Practice Test
   La segunda mejor opción, en mi opinión y muy barato, lo puedes conseguir en menos de $10 dólares. También probado por muchos desarrolladores en java certificados.
3. David Mayer’s Practice Test
   Si quieres prepararte aún más, recomiendo resolver los más de 450 problemas del examen de David Mayer.
4. Java Certification: OCA (1Z0–808) Exam Simulation [2018]
   Más de 260 preguntas de opción múltiple con explicación para pasar la certificación "Oracle Certified Associate, Java SE 8 Programmer I preparation"
5. Java Certification — OCA (1Z0–808) Topic-wise Tests [2018]
   Preguntas de opción múltiple que cubren todos los objetivos del examen "Oracle Certified Associate, Java SE 8 Programmer I"

Por cierto, si decides comprar Whizlab’s simulator, puedes utilizar el cupón “JAVACOMBO2” para un descuento del 25%.

Ya que Whizlab, ofrece acceso de por vida a sus simuladores, recomiendo comprar ambos simuladores juntos, OCAJP y OCPJP, y aprovecha el cupón de descuento.

5. Participa en foros de forma regular

Tienes que motivarte y actualizarte respecto a los exámenes y otros detalles, por lo que no hay mejor manera de hacerlo que, participando en foros, como CodeRanch o el foro oficial de certificaciones Java de Oracle

Puedes hacer preguntas, responderlas y familiarizarte con otros usuarios que al igual que tú se preparan para sus exámenes.

Incluso podrías hacer amigos y amigas que te ayudarán a prepararte mejor para tu examen.

6. Responde tantas preguntas como sea posible

La práctica hace al maestro, practica tanto como puedas y poco a poco desarrollaras la velocidad y precisión que requiere el examen.

Hay muchos exámenes gratis disponibles y Google es tu amigo. Puedes buscarlos y comenzar a practicar.

Aquí hay una lista de algunas preguntas de práctica gratis para los exámenes OCAJP 8 y OCPJP 8:

1. http://www.java67.com/2017/05/10-free-java-8-certification-sample-questions-OCAJP8-OCPJP8-Mock-Exams.html
2. http://javarevisited.blogspot.sg/2015/11/5-free-ocajp8-ocpjp8-mock-exams-and-practice-questions.html#axzz5ACLhR0b5
3. http://javarevisited.blogspot.sg/2016/08/5-free-ocajp-7-and-ocpjp7-mock-exams.html#axzz4pXl8Axsv

Si quieres prepararte lo mejor posible para las certificaciones Java, también puedes visitar estas páginas para obtener preguntas de prueba y exámenes de práctica:

5 exámenes de prueba y preguntas de práctica para OCAJP8, OCPJP8  - 1Z0-808 809 (Certificación Java 8).

10 preguntas de muestra en Java 8 para las certificaciones - OCAJP8 y OCPJP8 - 1Z0-808 y 1Z09.

Otros recursos útiles para las certificaciones en Java 8:

Aquí puedes encontrar recursos útiles para los exámenes OCAJP8 (1Z0–808) y OCAPJP8 (1Z0–809).

Algunos recursos son gratis y otros los tendrás que comprar, pero teniendo en cuenta el precio de los exámenes, que es de 245 USD, vale la pena gastar un poco más, en lugar de no pasar el examen y tener que volver a tomarlo.

• Exámenes de prueba para OCAJP 8 y OCPJP8
• Los mejores simuladores de examen para OCAJP8 y OCPJP8
• Plan de estudio completo y especificaciones de Java SE 8 para la certificación (OCAJP 8)
• Enlace para registrarte al examen de Java 8
• Los mejores 8 libros de Java 8
• Beneficios de hacer una certificación en Java
• Consejos de preparación  para la certificación OCAJP8
• OCAJP 8 - preguntas frecuentes de desarrolladores

Notas finales

Gracias, llegaste al final del artículo... Buena suerte con tu examen de certificación en Java. Es cierto que no será fácil, pero siguiendo esta ruta de estudio y los consejos, estas un paso más cerca de ser un desarrollador certificado en Java.

P.D. — Si necesitas más recursos gratis, puedes revisar esta lista de exámenes de prueba para OCAJP 8 y OCPJP 8.

Las listas son estructuras de datos comúnmente utilizadas en todos los lenguajes de programación.

En este tutorial vamos a investigar la API List de Java. Comenzaremos con las operaciones básicas y luego nos adentraremos en cosas más avanzadas (como una comparación de diferentes tipos de listas, como ArrayList y LinkedList).

También te daré algunas pautas para ayudarte a elegir la implementación de la lista que mejor se adapte a tu situación.

Aunque el conocimiento básico de Java es suficiente para seguir el tutorial, la última sección requiere estructuras de datos básicas (Array, LinkedList) y conocimiento de Big-O. Si no estás familiarizado con ellos, no dudes en omitir esa sección.

Definición de listas

Las listas son colecciones ordenadas de objetos. Son similares a las secuencias en matemáticas en ese sentido. Sin embargo, son diferentes a los conjuntos que no tienen un cierto orden.

Un par de cosas a tener en cuenta: las listas pueden tener elementos duplicados y nulos. Son tipos de referencia o de objeto y, como todos los objetos en Java, se almacenan en las pilas.

Una lista en Java es una interfaz y hay muchos tipos de listas que implementan esta interfaz.

Usaré ArrayList en los primeros ejemplos, porque es el tipo de lista más utilizado.

ArrayList es básicamente un arreglo de tamaño variable. Casi siempre, vas a querer usar ArrayList en lugar de arreglos regulares, ya que brindan muchos métodos útiles.

La única ventaja de un arreglo solía ser su tamaño fijo (al no asignar más espacio del que necesita). Pero las listas también admiten tamaños fijos ahora.

Cómo crear una lista en Java

Basta de charlas, empecemos por crear nuestra lista.

import java.util.ArrayList;
import java.util.List;

public class CreateArrayList {
    public static void main(String[] args) {
        ArrayList<Integer> list0 = new ArrayList<>();

        // Makes use of polymorphism
        List list = new ArrayList<Integer>();

        // Local variable with "var" keyword, Java 10
        var list2 = new ArrayList<Integer>();
    }
}

En los corchetes angulares (<>) especificamos el tipo de objetos que vamos a almacenar.

Tenga en cuenta que el tipo entre paréntesis debe ser un tipo de objeto y no un tipo primitivo. Por lo tanto, tenemos que usar envoltorios de objetos, clase Integer en lugar de int, Double en lugar de double, y así sucesivamente.

Hay muchas formas de crear una ArrayList, pero presenté tres formas comunes en el fragmento anterior.

La primera forma es creando el objeto a partir de la clase ArrayList concreta, especificando ArrayList en el lado izquierdo de la asignación.

El segundo fragmento de código hace uso del polimorfismo mediante el uso de la lista en el lado izquierdo. Esto hace que la asignación se acople libremente con la clase ArrayList y nos permite asignar otros tipos de listas y cambiar fácilmente a una implementación de Lista diferente.

La tercera forma es la forma Java 10 de crear variables locales haciendo uso de la palabra clave var. El compilador interpreta el tipo de variable comprobando el lado derecho.

Podemos ver que todas las asignaciones dan como resultado el mismo tipo:

System.out.println(list0.getClass());
System.out.println(list.getClass());
System.out.println(list2.getClass());

Output:

class java.util.ArrayList
class java.util.ArrayList
class java.util.ArrayList

También podemos especificar la capacidad inicial de la lista.

List list = new ArrayList<>(20);

Esto es útil porque cada vez que la lista se llena e intenta agregar otro elemento, la lista actual se copia en una nueva lista con el doble de capacidad que la lista anterior. Todo esto sucede detrás de escena.

Esta operación hace que nuestra complejidad sea O(n), por lo que queremos evitarla. La capacidad por defecto es 10, por lo que si sabes que vas a almacenar más elementos, debes especificar la capacidad inicial.

Cómo agregar y actualizar elementos de lista en Java

Para agregar elementos a la lista podemos usar el método add. También podemos especificar el índice del nuevo elemento, pero ten cuidado al hacerlo, ya que puedes generar una excepción IndexOutOfBoundsException.

import java.util.ArrayList;

public class AddElement {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("hello");
        list.add(1, "world");
        System.out.println(list);
    }
}

Resultado:

[hello, world]

Podemos usar el método set para actualizar un elemento.

list.set(1, "from the otherside");
System.out.println(list);

Resultado:

[hello, world]
[hello, from the otherside]

Cómo recuperar y eliminar elementos de lista en Java

Para recuperar un elemento de la lista, puedes usar el método get y proporcionar el índice del elemento que desea obtener.

import java.util.ArrayList;
import java.util.List;

public class GetElement {
    public static void main(String[] args) {
        List list = new ArrayList<String>();
        list.add("hello");
        list.add("freeCodeCamp");

        System.out.println(list.get(1));
    }
}

Resultado:

freeCodeCamp

La complejidad de esta operación en ArrayList es O(1) ya que utiliza un arrelgo de acceso aleatorio regular en segundo plano.

Para eliminar un elemento de ArrayList, se utiliza el método remove.

list.remove(0);

Esto elimina el elemento en el índice 0, que es "hola" en este ejemplo.

También podemos llamar al método remove con un elemento para buscarlo y eliminarlo. Ten en cuenta que solo elimina la primera aparición del elemento si está presente.

public static void main(String[] args) {
        List list = new ArrayList();
        list.add("hello");
        list.add("freeCodeCamp");
        list.add("freeCodeCamp");

        list.remove("freeCodeCamp");
        System.out.println(list);
    }

Resultado:

[hello, freeCodeCamp]

Para eliminar todas las ocurrencias, podemos usar el método removeAll de la misma manera.

Estos métodos están dentro de la interfaz de List, por lo que todas las implementaciones de List los tienen (ya sea ArrayList, LinkedList o Vector).

Cómo obtener la longitud de una lista en Java

Para obtener la longitud de una lista, o el número de elementos, podemos usar el método size().

import java.util.ArrayList;
import java.util.List;

public class GetSize {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("Welcome");
        list.add("to my post");
        System.out.println(list.size());
    }
}

Resultado:

2

Listas bidimensionales en Java

Es posible crear listas bidimensionales, similares a los arreglos 2D.

ArrayList<ArrayList<Integer>> listOfLists = new ArrayList<>();

Usamos esta sintaxis para crear una lista de listas, y cada lista interna almacena números enteros. Pero aún no hemos inicializado las listas internas. Necesitamos crearlos y ponerlas en esta lista nosotros mismos:

int numberOfLists = 3;
for (int i = 0; i < numberOfLists; i++) {
    listOfLists.add(new ArrayList<>());
}

Estoy inicializando mis listas internas y estoy agregando 3 listas en este caso. También puedo agregar listas más adelante si es necesario.

Ahora podemos agregar elementos a nuestras listas internas. Para agregar un elemento, primero debemos obtener la referencia a la lista interna.

Por ejemplo, digamos que queremos agregar un elemento a la primera lista. Necesitamos obtener la primera lista y luego agregarla.

listOfLists.get(0).add(1);

Aquí hay un ejemplo para ti. Intenta adivinar el resultado del siguiente segmento de código:

public static void main(String[] args) {
        ArrayList<ArrayList<Integer>> listOfLists = new ArrayList<>();
        System.out.println(listOfLists);
        int numberOfLists = 3;
        for (int i = 0; i < numberOfLists; i++) {
            listOfLists.add(new ArrayList<>());
        }

        System.out.println(listOfLists);

        listOfLists.get(0).add(1);
        listOfLists.get(1).add(2);
        listOfLists.get(2).add(0,3);

        System.out.println(listOfLists);
}

Resultado:

[]
[[], [], []]
[[1], [2], [3]]

Ten en cuenta que es posible imprimir las listas directamente (a diferencia de los arreglos regulares) porque anulan el método ttoString().

Métodos útiles en Java

Existen otros métodos y atajos útiles que se utilizan con frecuencia. En esta sección quiero familiarizarte con algunos de ellos para que te resulte más fácil trabajar con listas.

Cómo crear una lista con elementos en Java

Es posible crear y completar la lista con algunos elementos en una sola línea. Hay dos maneras de hacer esto.

La siguiente es la forma de la vieja escuela:

public static void main(String[] args) {
        List<String> list = Arrays.asList(
                                "freeCodeCamp",
                                "let's",
                                "create");
 }

Debes tener cuidado con una cosa al usar este método: Arrays.asList devuelve una lista inmutable. Entonces, si intentas agregar o eliminar elementos después de crear el objeto, obtendrás una excepción UnsupportedOperationException.

Es posible que tengas la tentación de usar la palabra clave final para que la lista sea inmutable, pero no funcionará como se esperaba.

Simplemente, se asegura de que la referencia al objeto no cambie, no le importa lo que sucede dentro del objeto. Por lo que permite poner y quitar.

final List<String> list2 = new ArrayList<>();
list2.add("erinc.io is the best blog ever!");
System.out.println(list2);

Resultado:

[erinc.io is the best blog ever!]

Ahora veamos la forma moderna de hacerlo:

ArrayList<String> friends =  new ArrayList<>(List.of("Gulbike", "Sinem", "Mete"));

El método List.of se envió con Java 9. Este método también devuelve una lista inmutable, pero podemos pasarla al constructor ArrayList para crear una lista mutable con esos elementos. Podemos agregar y quitar elementos a esta lista sin ningún problema.

Cómo crear una lista con N copias de algún elemento en Java

Java proporciona un método llamado NCopies que es especialmente útil para la evaluación comparativa. Puedes llenar un arreglo con cualquier número de elementos en una sola línea.

public class NCopies {
    public static void main(String[] args) {
        List<String> list = Collections.nCopies(10, "HELLO");
        System.out.println(list);
    }
}

Resultado:

[HELLO, HELLO, HELLO, HELLO, HELLO, HELLO, HELLO, HELLO, HELLO, HELLO]

Cómo clonar una lista en Java

Como se mencionó anteriormente, las Listas son tipos de referencia, por lo que se les aplican las reglas de paso por referencia.

public static void main(String[] args) {
        List list1 = new ArrayList<String>();
        list1.add("Hello");
        List list2 = list1;
        list2.add(" World");

        System.out.println(list1);
        System.out.println(list2);
}

Resultado:

[Hello,  World]
[Hello,  World]

La variable list1 contiene una referencia a la lista. Cuando lo asignamos a list2 también apunta al mismo objeto. Si no queremos que cambie la lista original, podemos clonar la lista.

ArrayList list3 = (ArrayList) list1.clone();
list3.add(" Of Java");

System.out.println(list1);
System.out.println(list3);

Resultado:

[Hello,  World]
[Hello,  World,  Of Java]

Dado que clonamos list1, list3 contiene una referencia a su clon en este caso. Por lo tanto, list1 permanece sin cambios.

Cómo copiar una lista a un arreglo en Java

A veces necesita convertir su lista en un arreglo para pasarla a un método que acepte un arreglo. Puedes usar el siguiente código para lograrlo:

List<Integer> list = new ArrayList<>(List.of(1, 2));
Integer[] toArray = list.toArray(new Integer[0]);

Debe pasar un arreglo y el método toArray  devuelve ese arreglo después de llenarla con los elementos de la lista.

Cómo ordenar una lista en Java

Para ordenar una lista podemos usar Collections.sort. Ordena en orden ascendente de forma predeterminada, pero también puedes pasar un comparador para ordenar con lógica personalizada.

List<Integer> toBeSorted = new ArrayList<>(List.of(3,2,4,1,-2));
Collections.sort(toBeSorted);
System.out.println(toBeSorted);

Resultado:

[-2, 1, 2, 3, 4]

Cómo elejir qué tipo de lista usar?

Antes de terminar este artículo, quiero brindarte una breve comparación de rendimiento de diferentes implementaciones de listas para que puedas elegir cuál es mejor para tu caso de uso.

Vamos a comparar ArrayList, LinkedList y Vector. Todos ellos tienen sus altibajos, así que asegúrate de considerar el contexto específico antes de decidir.

Java ArrayList vs LinkedList

Aquí hay una comparación de tiempos de ejecución en términos de complejidad algorítmica.

|                       | ArrayList                  | LinkedList |
|-----------------------|----------------------------|------------|
| GET(index)            | O(1)                       | O(n)       |
| GET from Start or End | O(1)                       | O(1)       |
| ADD                   | O(1), if list is full O(n) | O(1)       |
| ADD(index)            | O(n)                       | O(1)       |
| Remove(index)         | O(n)                       | O(1)       |
| Search and Remove     | O(n)                       | O(n)       |

Generally, the get operation is much faster on ArrayList but add and remove are faster on LinkedList.

En general, la operación get (obtener) es mucho más rápida en ArrayList, pero add (agregar) y remove (eliminar) son más rápidos en LinkedList.

ArrayList usa un arreglo detrás de escena, y cada vez que se elimina un elemento, los elementos de el arreglo deben cambiarse (que es una operación O (n)).

Elegir estructuras de datos es una tarea compleja y no existe una receta que se aplique a todas las situaciones. Aún así, intentaré proporcionar algunas pautas para ayudarte a tomar esa decisión más fácilmente:

• Si planeas hacer más operaciones de obtener y agregar que no sean eliminar, usa ArrayList ya que la operación de obtener es demasiado costosa en LinkedList. Tenga en cuenta que la inserción es O(1) solo si la llamas sin especificar el índice y la agrega al final de la lista.
• Si vas a eliminar elementos y/o insertarlos en el medio (no al final) con frecuencia, puedes considerar cambiar a LinkedList porque estas operaciones son costosas en ArrayList.
• Ten en cuenta que si accedes a los elementos secuencialmente (con un iterador), no experimentarás una pérdida de rendimiento con LinkedList mientras obtienes elementos.

Java ArrayList vs Vector

Vector es muy similar a ArrayList. Si provienes de un entorno de C++, es posible que tengas la tentación de usar un Vector, pero su caso de uso es un poco diferente al de C++.

Los métodos de Vector tienen la palabra clave sincronizada, por lo que Vector garantiza la seguridad de subprocesos, mientras que ArrayList no.

Es posible que prefieras Vector sobre ArrayList en la programación de subprocesos múltiples o puedes usar ArrayList y manejar la sincronización usted mismo.

En un programa de subproceso único, es mejor quedarse con ArrayList porque la seguridad de subprocesos tiene un costo de rendimiento.

Conclusión

En esta publicación, he tratado de proporcionar una descripción general de la API de lista de Java. Hemos aprendido a usar métodos básicos y también hemos visto algunos trucos más avanzados para hacernos la vida más fácil.

También hicimos una comparación de ArrayList, LinkedList y Vector, que es un tema que se suele preguntar en las entrevistas.

Gracias por tomarse el tiempo de leer el artículo completo y espero que te  haya sido útil.

Puedes acceder a todo el código desde este repositorio.

Si estás interesado en leer más artículos como este, puede suscribirte a la lista de correo de mi blog para recibir una notificación cuando publique un nuevo artículo.

Un arreglo es una estructura de datos utilizada para almacenar datos del mismo tipo. Los arreglos almacenan sus elementos en ubicaciones de memoria contiguas.

En Java, los arreglos son objetos. Todos los métodos se pueden ser invocados en un arreglo. Podemos almacenar un número fijo de elementos en un arreglo.

Declaremos un tipo simple de arreglo primitivo:

int[] intArray = {2,5,46,12,34};

Ahora tratemos de imprimirlo con el método  System.out.println():

System.out.println(intArray);
// output: [I@74a14482

¿Por qué no imprimió Java nuestro arreglo? ¿Qué está pasando detrás de escena?

El método System.out.println()  convierte el objeto que pasamos en una cadena llamando  String.valueOf(). Sí miramos a la implementación del método String.valueOf(), veremos esto:

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

Si el objeto pasado es null retorna null, si no este llama obj.toString(). Finalmente, System.out.println() llama toString() a imprimir el resultado.

Si la clase de ese objeto anula la implementación de  Object.toString()'s, llamará al método Object.toString().

Object.toString() retorna getClass().getName()+‘@’+Integer.toHexString(hashCode()) . De modo simple, retorna: “nombre de la clase @ código hash del objeto”.

En nuestro resultado anterior [I@74a14482, el [ indica que se trata de un arreglo, y I representa int (el tipo de arreglo). 74a14482 es la representación  hexadecimal sin firma del código hash del arreglo.

Cada vez que estemos creando nuestras propias clases personalizadas, es una buena práctica anular el método Object.toString().

No podemos imprimir arreglos en Java usando el método System.out.println(). En vez de eso, estas son las formas en las que podemos imprimir un arreglo:

1. Bucles: bucle for y bucle for-each
2. método Arrays.toString()
3. método Arrays.deepToString()
4. método Arrays.asList()
5. Interfaz Java Iterator
6. Java Stream API

Veámoslos uno por uno.

1. Bucles: bucle for y bucle for-each

Aquí tenemos un ejemplo de un bucle for:

int[] intArray = {2,5,46,12,34};

for(int i=0; i<intArray.length; i++){
    System.out.print(intArray[i]);
    // output: 25461234
}

Todas las clases anulan  Object.toString() y regresan una representación de cadena de su valor.

Aquí tenemos un bucle for-each:

int[] intArray = {2,5,46,12,34};

for(int i: intArray){
    System.out.print(i);
    // output: 25461234
}

2. Método Arrays.toString()

Arrays.toString() es un método estático de la clase del arreglo que pertenece al paquete java.util. Retorna una representación de los contenidos del arreglo especificado. Podemos imprimir un arreglo unidimensional usando este método.

Los elementos del arreglo son convertidos a cadenas usando el método, String.valueOf(), de esta forma:

int[] intArray = {2,5,46,12,34};
System.out.println(Arrays.toString(intArray));
// output: [2, 5, 46, 12, 34]

Para un tipo de referencia del arreglo, tenemos que asegurarnos que la clase del tipo de referencia anula el método Object.toString().

Por ejemplo:

public class Test {
    public static void main(String[] args) {
        Estudiante[] estudiante = {new Estudiante("John"), new Estudiante("Doe")};
        
        System.out.println(Arrays.toString(estudiantes));
        // output: [Estudiante{name='John'}, Estudiante{name='Doe'}]
    }
}

class Estudiante {
    private String name;

    public Estudiante(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Estudiante{" + "name='" + name + '\'' + '}';
    }
}

Este método no es apropiado para arreglos multidimensionales. Convierte los arreglos multidimensionales a cadenas usando Object.toString() que describe sus identidades en vez de sus contenidos.

Por ejemplo:

// creating multidimensional array
int[][] multiDimensionalArr = { {2,3}, {5,9} };

System.out.println(Arrays.toString(multiDimensionalArr));
// output: [[I@74a14482, [I@1540e19d]

Con la ayuda de Arrays.deepToString(), podemos imprimir arreglos multidimensionales.

3. Método Arrays.deepToString()

Arrays.deepToString() retorna una representación de los "contenidos profundos" del arreglo especificado.

Si un elemento es un arreglo de un tipo primitivo, es convertido a una cadena invocando la sobrecarga adecuada de Arrays.toString().

Aquí tenemos un ejemplo del tipo primitivo de un arreglo multidimensional:

// creating multidimensional array
int[][] multiDimensionalArr = { {2,3}, {5,9} };

System.out.println(Arrays.deepToString(multiDimensionalArr));
// output: [[2, 3], [5, 9]]

Si un elemento es un arreglo del tipo de referencia, se convierte en una cadena invocando recursivamente Arrays.deepToString().

Profesor[][] profesores = 
{{ new Profesor("John"), new Profesor("David") }, {new Profesor("Mary")} };

System.out.println(Arrays.deepToString(teachers));
// output: 
[[Profesor{name='John'}, Profesor{name='David'}],[Profesor{name='Mary'}]]

Tenemos que anular  Object.toString() en nuestra clase Profesor.

Si tienes curiosidad de cómo lo hace recursión, aquí encuentras el código fuente para el método  Arrays.deepToString().

NOTA: Los arreglos unidimensionales de tipo de referencia también pueden ser impresos usando este método. Por ejemplo::

Integer[] oneDimensionalArr = {1,4,7};

System.out.println(Arrays.deepToString(oneDimensionalArr));
// output: [1, 4, 7]

4. Método Arrays.asList()

Este método regresa una lista de tamaño fijo respaldada por el arreglo especificado.

Integer[] intArray = {2,5,46,12,34};

System.out.println(Arrays.asList(intArray));
// output: [2, 5, 46, 12, 34]

Hemos cambiado el tipo int a un número entero, porque List es una colección que guarda una lista de objetos. Cuando estamos convirtiendo un arreglo a una lista debería ser un arreglo de tipo de referencia.

Java llama  Arrays.asList(intArray).toString(). Esta técnica usa internamente el método toString()  del tipo de los elementos dentro de la lista.

Otro ejemplo con nuestra clase personalizada Profesor:

Profesor[] profesor = { new Profesor("John"), new Profesor("Mary") };

System.out.println(Arrays.asList(profesor));
// output: [Profesor{name='John'}, Profesor{name='Mary'}]

NOTA: No podemos imprimir arreglos multidimensionales usando este método. Por ejemplo:

Teacher[][] teachers = 
{{ new Teacher("John"), new Teacher("David") }, { new Teacher("Mary") }};
        
System.out.println(Arrays.asList(teachers));

// output: [[Lcom.thano.article.printarray.Teacher;@1540e19d, [Lcom.thano.article.printarray.Teacher;@677327b6]

5. Interfaz del iterator Java

Similar a un bucle for-each, podemos usar la interfaz del iterador para recorrer los elementos del arreglo e imprimirlos.

Se puede crear un objeto iterator invocando el método iterator() sobre una colección (Collection). Ese objeto será usado para iterar sobre la Colección de elementos

Aquí tenemos un ejemplo de cómo podemos imprimir un arreglo usando la interfaz:

Integer[] intArray = {2,5,46,12,34};

// creando una lista de entero (List of Integer)
List<Integer> list = Arrays.asList(intArray);

// creando un  iterador de la lista de entero (Integer List)
Iterator<Integer> it = list.iterator();

// Si la lista tiene elementos que ser iterados
while(it.hasNext()) {
    System.out.print(it.next());
    // output: 25461234
}

6. Java Stream API

La Stream API es usa para procesar colecciones de objetos. Una corriente (stream) es una secuencia de objetos.  Las corrientes no cambian la estructura de datos original, solo proveen el resultado según las operaciones solicitadas.

Con la ayuda de a operación en el terminal forEach() podemos iterar a través de cada elemento de la corriente

Por ejemplo:

Integer[] intArray = {2,5,46,12,34};

Arrays.stream(intArray).forEach(System.out::print);
// output: 25461234

Ahora ya sabemos cómo imprimir un arreglo en Java.

Gracias por leerme.

Imagen de portada por Aziz Acharki en Unsplash.

Puedes leer mis otros artículos en Medium.

Happy Coding!

Hola a todos, hoy en día es el mundo de los cursos en línea. Todo el mundo habla de aprender en línea, Youtube, cursos gratuitos en Coursera y otros sitios web, lo cual es excelente, como cursos en línea pueden ayudar a aprender más rápido, pero creo que los libros aún deben ser una parte importante de su aprendizaje, ya que brindan el conocimiento más profundo y, a menudo, escrito por la autoridad en el tema.

Si estás aprendiendo programación Java, prepárese para conocer algunos de los libros más increíbles para aprender y dominar la programación Java en este artículo.

Cada vez que un programador comienza a aprender el lenguaje de programación Java, la primera pregunta que hacen es: "¿Qué libro debo consultar para aprender Java?" o “¿Cuál es el mejor libro para aprender Java para principiantes?” o “¿Puedes decirme algunos buenos libros para aprender Java?” Eso, en sí mismo, dice lo importante que son los libros de Java para los programadores, especialmente los principiantes.

A pesar de tener tantos recursos gratuitos disponibles en Java, como tutoriales, cursos en línea, consejos, blogs y ejemplos de código, los libros de Java tienen su propio lugar porque:

• Están escritos por programadores que son una autoridad en el tema.
• Cubren el tema con más detalles y explicaciones.

Estos libros de Java son mis favoritos personales, y cada vez que tengo tiempo, prefiero leerlos para refrescar mis conocimientos. Aunque ya he leído muchos de ellos (he leído Effective Java al menos cuatro veces hasta ahora), siempre quiero aprender algo nuevo y mi búsqueda de grandes libros nunca termina.

Estos libros son algunos de los mejores disponibles en la actualidad y son igualmente útiles para programadores de Java principiantes, intermedios y avanzados.

No importa si eres completamente nuevo en Java o si ha estado programando en Java durante algún tiempo, aprenderás muchas cosas nuevas a través de estos libros.

Habiendo dicho eso, no todos los libros son igualmente adecuados para todos los programadores. Para los principiantes, Head First Java sigue siendo el mejor libro para empezar, y para el desarrollador avanzado de Java, Effective Java es un buen libro para empezar.

Los 10 Mejores Libros para Aprender a Programar en Java

Aquí está mi colección de libros de Java que sugiero a todos los programadores que quieran aprender Java. Contiene libros para programadores principiantes y experimentados.

Estos libros cubren una variedad de áreas, incluidos los fundamentos básicos de Java, el framework de colección de Java, subprocesos múltiples y concurrencia, ajustes internos y de rendimiento de JVM, patrones de diseño, etc.

1. Head First Java

Mucha gente pensará que este es un libro anticuado, pero para ser honesto, Head First Java es el mejor libro para cualquier programador que sea nuevo tanto en programación como en Java. La manera de explicar de cabeza es fenomenal y realmente disfruté su libro.

Head First Java cubre el conocimiento esencial de programación Java sobre características de clase, objeto, subproceso, colección y lenguaje, como genéricos, enumeraciones, argumentos variables o auto-boxing.

También tienen una sección avanzada sobre Swing, redes y Java IO, lo que los convierte en un paquete completo para principiantes de Java. Este debería ser el primer libro de Java que veas si estás empezando desde cero.

Descargo de responsabilidad: recibiré una compensación si utilizas cualquier enlace de los libros enumerados aquí desde Amazon.

2. Head First Design Patterns

El Head First Design Pattern es otro libro de Java de primera clase del laboratorio de Head-First.

Cuando comencé a leer este libro en 2006, no pensé mucho en los patrones de diseño, cómo resuelven problemas comunes, cómo aplicar un patrón de diseño, qué beneficios brindan y todo tipo de cosas básicas. Pero después de leer este libro de Java, me he beneficiado inmensamente.

El primer capítulo sobre herencia y composición, que es simplemente fantástico y promueve prácticas mejoradas al presentar un problema y luego la solución.

Este libro también contiene viñetas útiles, ejercicios y mapas de memoria, que lo ayudan a comprender los patrones de diseño rápidamente.

Si desea aprender los patrones de diseño básicos de Java y los principios de diseño orientado a objetos, este es el primer libro de Java que debe consultar.

Una buena noticia sobre este libro es que la nueva edición se actualizó para Java SE 8, que le enseñará cómo desarrollar un patrón de diseño GOF clásico utilizando características de Java 8, como expresiones lambda y secuencias.

3. Effective Java

Effective Java es uno de los mejores libros de Java en mi historial y uno de los más agradables. Tengo un gran respeto por Joshua Bloch, el autor, por su contribución al framework de la colección Java y al paquete Java Concurrency.

Effective Java es mejor para un programador experimentado que esté bien versado en la programación de Java. Es excelente para los programadores que desean compartir sus habilidades siguiendo las mejores prácticas de programación y que están ansiosos por escuchar a alguien que contribuyó al kit de desarrollo de Java (JDK).

Effective Java consiste de una colección de las mejores prácticas de programación de Java, que van desde fábricas estáticas, serialización, igualdad y código hash hasta genéricos, enumeraciones, varargs y reflexión.

Este libro de programación Java cubre casi todos los aspectos de Java de una manera ligeramente diferente a la que está acostumbrado.

El año pasado se lanzó una nueva edición que introdujo funciones en JDK 7, 8 y 9, que se lanzó el año pasado en septiembre. También tiene un capítulo completo sobre lambdas.

4. Java Concurrency in Practice

Java Concurrency in Practice es otro clásico de Joshua Bloch, Doug Lea y su equipo. Este es el mejor libro de Java sobre simultaneidad y subprocesos múltiples: una de las lecturas obligadas para los desarrolladores principales de Java.

Los puntos fuertes de la práctica de concurrencia en Java incluyen:

1) Este libro es muy detallado y captura detalles menores de subprocesos múltiples y concurrencia.

2) En lugar de centrarse en las clases básicas de Java, este libro se centra en las cuestiones y los problemas de concurrencia, como interbloqueo, inanición, seguridad de subprocesos, condiciones de carrera, y presenta formas de resolverlos utilizando clases de concurrencia de Java.

Este libro es un recurso excelente para aprender y dominar los paquetes y clases de concurrencia de Java, como CountDownLatch, CyclicBarrier, BlockingQueue o Semaphore. Esta es la principal razón por la que me gusta leer este libro de Java y leerlo una y otra vez.

3) Otro punto fuerte de la práctica de concurrencia en Java son los ejemplos sensatos; los ejemplos de este libro son claros, concisos e inteligentes.

4) Este libro también es bueno para explicar lo que está mal y por qué está mal y cómo corregirlo, lo cual es esencial para que cualquier libro de Java tenga éxito.

En resumen, este es uno de los mejores libros para aprender concurrencia y subprocesos múltiples en Java. El contenido definitivamente es avanzado desde la perspectiva de un principiante, pero seguramente, este es un libro de lectura obligada para los programadores Java experimentados.

5. Java Generics and Collections

The Java Generics and Collection de Naftalin y Philip Wadler de O'Reilly es otro buen libro sobre Java, que inicialmente olvidé incluir en mi lista pero lo incluyo ahora a pedido de muchos lectores.

Me gusta este libro por su contenido sobre genéricos y colecciones, que son áreas centrales del lenguaje Java.

Se espera que un programador experimentado tenga un conocimiento sólido de las colecciones y los genéricos de Java, y estos libros ayudan en esa área.

Explica cada interfaz de colección, como Conjunto, Lista, Mapa, Cola, y su implementación, comparando qué tan bien funcionan en una situación diferente.

Realmente me encantó su tabla de comparación al final de cada capítulo, que le brinda una buena idea sobre cuándo usar una clase de colección de Java en particular, como ArrayList, HashMap o LinkedHashMap.

6. Java Performance From Binu John

Este es otro buen libro que enseña sobre los aspectos internos de JVM, la recolección de basura, el ajuste de JVM y la creación de perfiles. etc., y recomiendo encarecidamente a todos los desarrolladores senior de Java que lean este libro. Este es también uno de mis favoritos personales.

Como nos estamos moviendo gradualmente, comenzamos desde un nivel de principiantes hasta un nivel intermedio y ahora el nivel superior.

Java Performance tiene que ver con la supervisión del rendimiento, la creación de perfiles y las herramientas utilizadas para la supervisión del rendimiento de Java.

Este no es un libro de programación habitual. En su lugar, proporciona detalles sobre la JVM, la recolección de basura, la supervisión del almacenamiento dinámico de Java y la aplicación de generación de perfiles.

Me encantó su capítulo sobre la descripción general de JVM, y es una lectura obligada para obtener más información sobre JVM en un lenguaje sencillo.

Tanto los principiantes como los programadores intermedios pueden beneficiarse de este libro, pero es bueno tener algo de experiencia en Java antes de leerlo. Hasta ahora, este es el mejor libro de Java sobre monitoreo del rendimiento.

Este es otro libro de Java que debe leer si se toma en serio el rendimiento.

Hay un par de libros nuevos disponibles en Java, que cubren JDK 1.7. Para conocer el último libro sobre el rendimiento de Java, como Java Performance, The Definitive Guide de Scott Oaks, que sin duda vale la pena consultar antes de comprar este libro.

7. Java Puzzlers

Java Puzzlers es otro libro que vale la pena leer de Joshua Bloch, esta vez con Neal Gafter. Este libro trata sobre casos extremos y trampas en el lenguaje de programación Java.

Java es más seguro que C++, y la JVM hace un buen trabajo para liberar al programador de la asignación y desasignación de memoria propensa a errores. Pero aún así, Java tiene casos de esquina que pueden sorprender incluso al programador Java experimentado.

Este libro de Java presenta estos peligros de Java y los explica con más detalle. Este es un buen libro de Java si le encantan los acertijos; incluso puede incluir muchos de estos en las entrevistas básicas de Java para verificar su conocimiento de Java.

No lo califico tan alto como Effective Java y Java Concurrency in Practice, pero aún puede intentarlo, especialmente para verificar su conocimiento sobre Java y sus casos de esquina, lo que lo ayudará a responder algunas de las preguntas difíciles de Java de entrevistas.

Para entender la mayor parte de este libro de Java, intente resolver acertijos usted mismo y luego busque explicaciones para que su conocimiento sea más concreto.

8. Head First Object-Oriented Analysis and Design

Otro buen libro sobre principios de diseño y programación Java de la serie Head-First. Head First Object-Oriented Analysis and Design se puede leer junto con Head First Design Patterns.

Este libro se enfoca en los principios del diseño orientado a objetos, como favorecer la composición sobre la herencia, la programación para el interfaz en lugar de la implementación, DRY, etc.

Una parte de aprender Java es escribir un buen código y seguir las mejores prácticas, y este libro es excelente para educar a los programadores sobre ellas.

El conocimiento obtenido con este libro es aplicable a muchos lenguajes de programación orientados a objetos y, en general, mejorará su comprensión del código y los principios de diseño de programación orientada a objetos.

9. Thinking in Java

Thinking in Java está escrito por Bruce Eckel, quien también es el autor de Thinking in C++ y usa su estilo único para enseñar el concepto de Java.

Muchos estarían de acuerdo en que este es uno de los mejores libros de Java, con una fortaleza que apunta a ejemplos inteligentes. Este es uno de los libros completos en Java y también puede usarse como referencia.

Hay un capítulo sobre IO mapeada en memoria de Java de Thinking in Java, que es mi favorito.

Si no le gusta el estilo de enseñanza Head-First, pero necesita un libro de Java para principiantes con un estilo de ejemplo simple, Thinking in Java es una buena opción.

Es detallado, maduro y se actualiza con frecuencia, pero, si necesita más opciones, también puede consultar estos libros básicos de Java para principiantes.

10. Java SE 8 for the Really Impatient

Este es uno de los mejores libros para aprender Java 8. También es mi libro Java 8 de propósito general. Si tienes menos tiempo y quieres aprender todas las cosas importantes sobre Java 8, este es el libro que debes consultar.

No tengo que recordarte de la habilidad de escribir de Cay. S. Horstmann’s, uno de los mejores autores en Java y a la altura de Joshua Bloch. He encontrado que ambos son muy legibles.

No te aburrirás, lo que suelen hacer los programadores cuando leen libros técnicos. Explica sobre la expresión lambda, Streams, interfaz funcional, referencias de métodos, nueva API de fecha y hora de Java y varias otras pequeñas mejoras como unir cadenas, anotaciones repetibles, etc. En resumen, uno de los mejores libros para aprender Java sin duda.

Terminando

Esta fue mi lista de los mejores libros de programación Java. He leído todos los libros, algunos de ellos todavía los estoy leyendo y un par de ellos, como Effective Java y la serie Head-First, los he leído un par de veces. Muchos programadores me preguntan con qué libros deberían comenzar y qué libro de Java deberían leer ahora. Espero que hayas encontrado buenos libros en esta colección. ¡Feliz lectura!

Notas finales

Gracias por leer este artículo hasta ahora. Puede que estés pensando que hay tantas cosas que aprender, tantos cursos a los que unirte, pero no tienes que preocuparte.

Soy un fanático particular de los cursos de Udemy, ya que son muy asequibles y brindan muchos valores en una cantidad muy pequeña, pero eres libre de elegir el curso que deseas.

Al final del día, debe tener suficiente conocimiento y experiencia al usar los recursos mencionados aquí.

¡Buena suerte con tu viaje por Java! Ciertamente no va a ser fácil, pero siguiendo esta hoja de ruta y guía, está un paso más cerca de convertirse en el desarrollador de Java que siempre quiso ser.

Si te gusta este artículo, considera seguirme en medium (javinpaul). Si desea recibir notificaciones de cada publicación nueva, ¡no olvide seguir a javarevisited en Twitter!

Una vez más, todo lo mejor para su viaje de desarrollo de Java y muchas gracias a todos los autores por escribir libros tan increíbles. Estos libros de programación de Java son algunos de los mejores libros para aprender Java; incluso diría que algunos de ellos son los mejores libros de Java jamás publicados.

Tanto si has programado en Java como si no, seguramente habrás escuchado hablar de la Máquina Virtual de Java (en inglés Java Virtual Machine, JVM) en algún momento.

JVM es el núcleo del ecosistema Java, permitiendo al software basado en esta tecnología seguir el enfoque "escríbelo (tu programa) una sola vez, ejecútalo en cualquier parte (write once, run anywhere)". Puedes escribir código Java en un tipo de máquina concreto, y ejecutarlo en cualquier otro tipo de máquina usando la JVM.

Inicialmente, la JVM fue diseñada para admitir Java solamente. Pero, con el paso de los años, muchos otros lenguajes como Scala, Kotlin y Groovy fueron adoptados por la plataforma Java. El conjunto de estos lenguajes se conoce como lenguajes JVM.

En este artículo aprenderemos las esencias de la JVM, cómo funciona y los componentes en que se divide.

¿Qué es una máquina virtual?

Antes de entrar de lleno en la JVM, revisemos el concepto de máquina virtual (VM).

Una máquina virtual es la representación virtual de un ordenador físico. Normalmente, se llama huésped (guest) a la máquina virtual, mientras que al ordenador físico en que se ejecuta, se le suele llamar anfitrión (host).

Una sola máquina física puede ejecutar varias máquinas virtuales, cada una con su propio sistema operativo y aplicaciones a nivel de usuario; están aisladas unas de otras.

¿Qué es la Máquina Virtual de Java?

En lenguajes de programación como C o C++, el código es compilado al código máquina específico de esa platoforma en concreto: son lenguajes compilados.

Por otro lado, en lenguajes como JavaScript o Python, el ordenador ejecuta las instrucciones directamente sin tener que compilarlas: son lenguajes interpretados.

Java usa una combinación de ambas técnicas. El código es compilado a bytecode (un formato binario independiente del hardware y del sistema operativo, que representa instrucciones de la JVM) generando un fichero con formato class. Este fichero class es interpretado por la JVM en la plataforma anfitriona. Un mismo fichero class puede ser ejecutado por la JVM en cualquier plataforma y sistema operativo.

De manera similar a las máquinas virtuales, la JVM crea un espacio aislado en la máquina anfitriona. Este espacio se usa para ejecutar programas Java sea cual sea la plataforma o el sistema operativo de dicha máquina.

Arquitectura de la Máquina Virtual de Java

La JVM consta de tres componentes:

1. Cargador de clases (Class Loader)
2. Área de datos/memoria en tiempo de ejecución (Runtime Memory/Data Area)
3. Motor de ejecución (Execution Engine)

Echemos un vistazo a cada uno de ellos.

Cargador de clases

Como resultado de la compilación del código fuente almacenado en un fichero.java, se obtiene bytecode almacenado en un fichero .class . Si en un programa se va a hacer uso de esta clase, será cargado en memoria principal por el cargador de clases.

La primera clase en ser cargada en memoria es, normalmente, aquella que contiene el método main() .

El proceso de carga de clases consta de tres fases: carga (loading), enlazado (linking), e inicialización (initialization).

Carga (loading)

La fase de carga consiste en encontrar la representación binaria (bytecode) de una clase o interfaz con un nombre concreto, y crear una clase o interfaz a partir de dicha representación (crear una clase o interfaz c es construir una representación interna, específica de esa implementación de la JVM, de c).

Hay tres cargadores de clases incorporados:

• Cargador de clases de arranque (Bootstrap Class Loader) - raíz de la jerarquía de cargadores de clases, superclase de Extension Class Loader. Carga los paquetes estándar de Java como java.lang, java.net, java.util, java.io, etc. localizados en el fichero rt.jar y otras bibliotecas fundamentales presentes en el directorio $JAVA_HOME/jre/lib .
• Cargador de clases de extensión (Extension Class Loader) - subclase de Bootstrap Class Loader y superclase de Application Class Loader. Carga las extensiones de las bibliotecas estándar de Java presentes en el directorio $JAVA_HOME/jre/lib/ext .
• Cargador de clases de aplicación (Application Class Loader) - es el cargador de clases en el nivel más bajo de la jerarquía, subclase de Extension Class Loader. Carga los ficheros indicados en el classpath (variable de entorno que almacena la ruta a las clases creadas por el usuario). Por defecto, la variable classpath es establecida al directorio actual de la aplicación; puede ser modificada desde la línea de comandos con la opción -classpath o -cp (al ejecutar java o javac , por ejemplo).

La JVM usa el método ClassLoader.loadClass() para cargar una clase en memoria, haciendo uso del nombre binario de la clase.

Si un cargador de clases es incapaz de encontrar una clase, delega el trabajo en el cargador de una subclase suya. Si el último cargador de la jerarquía tampoco es capaz de encontrar la clase en cuestión, se producirá NoClassDefFoundError o ClassNotFoundException.

Enlazado (linking)

Después de que una clase haya sido cargada en memoria, se somete al proceso de enlazado. Enlazar una clase o una interfaz supone resolver las referencias externas y dependencias, integrando la clase en el conjunto del programa que hace uso de ella.

El enlazado incluye los siguientes pasos:

Verificación: esta fase verifica la corrección estructural del archivo.class contrastándolo frente a un conjunto de restricciones o reglas. Si la verificación falla, se produce VerifyException.

Por ejemplo, si el código se ha construído con Java 11, pero se va a ejecutar en un sistema con Java 8, la fase de verificación fallará.

Preparación: en esta fase, la JVM asigna memoria para los campos estáticos de una clase o interfaz, inicializándolos con valores por defecto.

Supón, como ejemplo, que has declarado en una clase la siguiente variable:

private static final boolean activado = true;

Durante la fase de preparación, la JVM asigna memoria para la variable activado y le asigna el valor por defecto para un booleano, que es false.

Resolución: es el proceso de resolver dinámicamente las referencias simbólicas presentes en el almacén de constantes de tiempo de ejecución (runtime constant pool, una estructura de datos del fichero .class).

Las referencias (simbólicas) que dentro de una clase se hacen a otras clases o a constantes presentes en otras clases, son resueltas en esta etapa asignándoles los valores reales.

Inicialización (initialization)

La inicialización consiste en ejecutar <clinit>, el método de inicialización de una clase o interfaz. En esta etapa se ejecutan los bloques de inicialización estáticos y se asignan los valores a las variables estáticas. Es el paso final del proceso de carga de clases.

Por ejemplo, cuando anteriormente hemos declarado el siguiente código:

private static final boolean activado = true;

La variable activado fue establecida con su valor por defecto, false , durante la fase de preparación. Ahora, en la fase de inicialización, se le asigna el valor real que queríamos darle, true.

Nota: la JVM es multihilo. Cabe la posibilidad de que múltiples hilos intenten inicializar la misma clase al mismo tiempo, provocando problemas de concurrencia. Hay que gestionar cada hilo de forma segura para garantizar que el programa funcione adecuadamente en un entorno multihilo.

Área de datos en tiempo de ejecución

El área de datos en tiempo de ejecución está formado por cinco componentes:

Veamos cada componente por separado.

Área de métodos

Todos los datos a nivel de clase, como el runtime constant pool, datos de los campos y los métodos, así como el código de los métodos y constructores, son almacenados en esta área.

Si la memoria disponible en el área de métodos no puede satisfacer una petición de asignación de memoria por parte de un proceso, la JVM emite un OutOfMemoryError.

Supongamos que has definido la siguiente clase:

public class Empleado {
  
  private String nombre;
  private int edad;
  
  public Empleado(String nombre, int edad) {
  
    this.nombre = nombre;
    this.edad = edad;
  }
}

Los datos de los campos nombre y edad y el código del constructor son guardados en el área de métodos.

El área de métodos se crea al arrancar la JVM y es compartida por todos los hilos de ejecución.

Area del montículo (heap)

Todos los objetos y sus correspondientes variables de instancia son almacenados en esta zona. El montículo es el área de datos de tiempo de ejecución en la que se aloja la memoria asignada a los arrelgos e instancias de clases.

Supongamos que se ha declarado la siguiente instancia:

Employee empleado = new Empleado();

En este ejemplo, se crea una instancia de la clase Empleado , que será cargada en memoria en el área del montículo.

Al igual que el área de métodos, el área del montículo es creada al arrancar la JVM, y se comparte por todos los hilos.

Nota: como las áreas del montículo y de métodos comparten la misma memoria para los diferentes hilos, habrá que gestionar cada hilo de forma segura para asegurar la integridad de los datos, como ya comentábamos en el apartado de inicialización de clases.

Area de pilas (stack)

A cada hilo creado en la JVM le corresponde en exclusiva una pila, creada al mismo tiempo que el propio hilo. Las variables locales, resultados parciales y llamadas a métodos se almacenan en esta zona de memoria conocida como pila.

Si el procesamiento que se está llevando a cabo en un hilo requiere un tamaño de pila mayor del permitido, la JVM emite un StackOverflowError.

Para cualquier llamada a método, se genera en la memoria de pila una entrada llamada marco de pila (stack frame). Cuando se completa la llamada al método, el marco de pila es destruido.

El marco de pila se divide en tres partes:

• Variables locales – cada marco contiene un arreglo donde se almacenan las variables locales y sus valores. La longitud de este arreglo se establece en tiempo de compilación.
• Pila de operandos (operand stack) – esta estructura de tipo pila es utilizada para llevar a cabo las operaciones intermedias durante la llamada al método en cuestión. La profundidad máxima de esta pila se determina también en tiempo de compilación.
• Marco de datos (frame data) – aquí se guardan todos los símbolos del método invocado, así como la información del bloque catch en caso de que se produzca alguna excepción.

Supongamos el siguiente código:

double calcularPuntuacionNormalizada(List<Respuesta> respuestas) {
  
  double puntuacion = getPuntuacion(respuestas);
  normalizarPuntuacion(puntuacion);
}

normalizarPuntuacion(double puntuacion) {
  
  return (puntuacion – minPuntuacion) / (maxPuntuacion – minPuntuacion);
}

En este ejemplo, el arreglo de variables locales contendrá las variables respuestas y puntuacion. La pila de operandos contiene las variables y operadores necesarios para realizar las operaciones de sustracción y división.

Nota: como cada pila es exclusiva de un hilo, esta área de memoria es inherentemente segura en ambiente multihilo.

Registros de contador de programa (PC, program counter)

La JVM admite múltiples hilos simultáneamente. Cada hilo tiene su propio registro contador de programa (PC) para guardar la dirección de la instrucción de la JVM ejecutándose en ese momento. Una vez ejecutada dicha instrucción, el registro PC es actualizado con la dirección de la próxima instrucción.

Pilas para métodos nativos

La JVM puede hacer uso de pilas que soporten métodos nativos, métodos escritos en lenguajes diferentes a Java, como C o C++. Cada hilo posee su propia pila de métodos nativos.

Motor de ejecución

Una vez que el bytecode se ha cargado en memoria y la información necesaria está disponible en el área de datos de tiempo de ejecución, el siguiente paso es ejecutar el programa. El motor de ejecución gestiona este proceso ejecutando el código de cada clase.

Sin embargo, antes de ejecutar el programa, hay que traducir el bytecode a instrucciones del lenguaje máquina, usando un intérprete o un compilador JIT.

Intérprete

El intérprete lee y ejecuta las instrucciones del bytecode línea a línea. Debido a esta ejecución línea por línea, el intérprete es comparativamente más lento.

Otra desventaja es la reinterpretación de un método cada vez que es llamado.

Compilador JIT

El compilador JIT salva las desventajas del intérprete. En primera instancia, el motor de ejecución usa el intérprete para ejecutar el bytecode, entrando en acción el compilador JIT cuando se encuentra código repetido.

El compilador JIT compila el bytecode traduciéndolo a código máquina nativo, que es usado directamente en las reiteradas llamadas a métodos, mejorando así el rendimiento del sistema.

El compilador JIT se divide en los siguientes componentes:

1. Generador de código intermedio
2. Optimizador de código - optimiza el código intermedio para un mejor desempeño
3. Generador de código objetivo - traduce el código intermedio en código máquina nativo
4. Perfilador (profiler) - encuentra los HotSpots (código que es ejecutado repetidamente)

Veamos el siguiente código para ilustrar la diferencia entre el intérprete y el compilador JIT:

int sum = 10;
for(int i = 0 ; i <= 10; i++) {
   sum += i;
}
System.out.println(sum);

Un intérprete busca en memoria el valor de sum en cada iteración del bucle, le suma el valor dei, y lo vuelve a almacenar en la memoria. Es una operación costosa, ya que se está accediendo a memoria en cada iteración.

Sin embargo, el compilador JIT reconoce que este código tiene un HotSpot, y realizará optimizaciones sobre él. Creará una copia local de sum en el registro PC del hilo, sumándole el valor de i en cada vuelta del bucle y, una vez concluído, llevará el nuevo valor de sum a la memoria.

Nota: un compilador JIT tarda más en compilar el código que un intérprete en interpretarlo línea por línea. Si se va a ejecutar el programa solo una vez, es mejor usar el intérprete.

Recolector de basura (GC, garbage collector)

El recolector de basura detecta y elimina objetos no referenciados en el área del heap. Es el proceso de recuperar automáticamente, en tiempo de ejecución, la memoria ocupada por objetos que ya no van a ser utilizados, mediante la destrucción de tales objetos.

La recolección de basura hace que Java sea eficiente desde el punto de vista de la gestión de memoria, ya que libera memoria del área heap eliminando objetos no referenciados, creándose así espacio para nuevos objetos. Este proceso implica dos fases:

1. Marcado - identificación de objetos no referenciados
2. Barrido - destrucción de los objetos identificados en el paso anterior

La JVM realiza automáticamente la recolección de basura a intervalos regulares, no siendo necesaria su gestión separadamente. Puede ser disparada invocando System.gc(), aunque la ejecución no está garantizada.

La JVM tiene tres tipos de recolectores de basura:

1. En serie - es la implementación más simple, diseñada para pequeñas aplicaciones ejecutándose en entornos monohilo. Usando un solo hilo, produce un evento de tipo "parar el mundo" en el que todos los hilos de aplicación son detenidos hasta que la operación se complete. El argumento de la JVM para usar recolección de basura en serie es -XX:+UseSerialGC
2. En paralelo - es la implementación por defecto en la JVM, conocido como recolector de rendimiento (throughput collector). Uitiliza múltiples hilos, pero aún necesita parar los hilos de aplicación. El argumento de la JVM es -XX:+UseParallelGC.
3. Garbage First (G1) GC - G1GC fue diseñado para aplicaciones multihilo con gran cantidad disponible de heap (más de 4GB). Particiona el heap en un conjunto de regiones de igual tamaño, utilizando múltiples hilos para explorarlas. G1GC identifica las regiones con el máximo de basura y realiza la limpieza prioritaria de esas regiones. El argumento de la JVM para G1GC es -XX:+UseG1GC

Nota: hay otro tipo de colector de basura llamado Barrido de Marcas Concurrente (Concurrent Mark Sweep (CMS) GC). Sin embargo, fue declarado obsoleto en Java 9 y completamente eliminado en Java 14 en favor de G1GC.

Interfaz nativa de Java (JNI)

En ocasiones, es necesario utilizar código nativo en lugar de Java (por ejemplo, C/C++). Esas ocasiones pueden ser cuando necesitamos interactuar con el hardware, o salvar las restricciones de Java en cuanto a gestión de memoria y rendimiento. Java admite la ejecución de código nativo a través de la Interfaz Nativa de Java (JNI).

JNI hace de puente permitiendo el uso de paquetes de apoyo para otros lenguajes, como C, C++, etc. Esto resulta de mucha ayuda en casos en que se necesita escribir código que no esté enteramente admitido por Java, como ciertas características específicas de la plataforma subyacente que solo pueden ser escritas en C.

La palabra reservada native indica que la implementación del método será proporcionada por una biblioteca nativa. Es necesario invocar System.loadLibrary() para cargar en memoria dicha biblioteca nativa compartida y tener su funcionalidad disponible en Java.

Bibliotecas de métodos nativos

Las bibliotecas de métodos nativos son bibliotecas escritas en otros lenguajes, como C, C++ y ensamblador, normalmente en archivos de extensión .dll o .so. Pueden ser cargadas a través de JNI.

Errores habituales de la JVM

• ClassNotFoundException - ocurre cuando el cargador de clases intenta cargar clases mediante Class.forName(), ClassLoader.loadClass() o ClassLoader.findSystemClass() pero no se encuentra la definición de la clase con el nombre especificado.
• NoClassDefFoundError - se produce cuando la compilación de la clase ha tenido éxito, pero el cargador de clases no es capaz de encontrar el fichero tipo class en tiempo de ejecución.
• OutOfMemoryError - la JVM no puede asignar memoria para un objeto, ya que no hay suficiente y el recolector de basura no es capaz de proporcionar más memoria.
• StackOverflowError - la JVM se queda sin espacio al crear nuevos marcos de pila.

Conclusión

En este artículo hemos discutido la arquitectura de la Máquina Virtual de Java y sus diversos componentes. Lo habitual es no preocuparse demasiado de su mecánica interna ni de su funcionamiento mientras nuestro código se ejecuta con normalidad.

Solo cuando algo va mal, y necesitamos ajustar la JVM o corregir un fallo de memoria, intentamos comprender su funcionamiento interno.

Es una cuestión muy popular en entrevistas de trabajo, tanto a nivel junior como senior para perfiles backend. Tener amplios conocimientos de la JVM te ayudará a producir mejor código y evitar trampas que conduzcan a errores de pila o de memoria.

Gracias por acompañarme hasta tan lejos. Espero que te haya gustado el artículo. Puedes encontrarme en LinkedIn, donde normalmente hablo sobre tecnología y sobre la vida. Echa también un vistazo a mis otros artículos y a mi canal de YouTube. Que disfrutes de la lectura. ?

No hace mucho tiempo, se lanzó una variante reactiva del controlador JDBC, conocida como R2DBC.  Permite que los datos se transmitan de forma asincrónica a cualquier punto final que se haya suscrito a él.  Usando un controlador reactivo como R2DBC junto con Spring, WebFlux le permite escribir una aplicación completa que maneja la recepción y el envío de datos de forma asíncrona.

En esta publicación, nos centraremos en la base de datos, desde la conexión a la base de datos hasta finalmente guardar y recuperar datos.  Para hacer esto, usaremos Spring Data.  Al igual que con todos los módulos de Spring Data, nos proporciona una configuración lista para usar.  Esto disminuye la cantidad de código repetitivo que necesitamos escribir para configurar nuestra aplicación.  Además de eso, proporciona una capa sobre el controlador de la base de datos que hace que realizar las tareas simples sea más fácil y las tareas más difíciles sean un poco menos dolorosas.

Para el contenido de esta publicación, estoy haciendo uso de una base de datos de Postgres.  En el momento de escribir este artículo, solo Postgres, H2 y Microsoft SQL Server tienen sus propias implementaciones de controladores R2DBC.

Anteriormente, escribí dos publicaciones sobre bibliotecas Spring Data reactivas, una sobre Mongo y otra sobre Cassandra.  Es posible que hayas notado que ninguna de estas bases de datos son bases de datos RDBMS.  Ahora hay otros controladores reactivos disponibles desde hace mucho tiempo (escribí la publicación de Mongo hace casi 2 años), pero al momento de escribir un controlador reactivo para una base de datos RDBMS todavía es algo bastante nuevo.  Esta publicación seguirá un formato similar a aquellos.

Además, también he escrito un post sobre el uso de Spring Web Flux que mencioné en la introducción.

Dependencias

Hay algunas cosas que señalar aquí.

Cuanto más utilices Spring Boot, más te acostumbrarás a importar una única dependencia de spring-boot-starter para la cosa que quieras hacer. Por ejemplo, esperaba que hubiera una dependencia de spring-boot-starter-r2dbc, pero lamentablemente no la hay. Todavía.

Simplemente, esta biblioteca está en el lado más nuevo y en el momento de escribir, no tiene su propio módulo de Spring Boot que contiene las dependencias que necesita junto con una configuración más rápida a través de la configuración automática. Estoy seguro de que estas cosas llegarán en algún momento y harán que la configuración de un controlador R2DBC sea aún más fácil.

Por ahora, tendremos que rellenar manualmente algunas dependencias adicionales.‌‌‌‌

Además, las librerías R2DBC solo tienen versiones Milestone (una prueba más de que son nuevas) por lo que tenemos que asegurarnos de traer el repositorio Spring Milestone. Probablemente, tendré que actualizar este post en el futuro cuando consiga una versión de lanzamiento.

Conexión a la base de datos

Gracias a que Spring Data hace gran parte del trabajo por nosotros, el único Bean que hay que crear manualmente es el ConnectionFactory que contiene los detalles de conexión de la base de datos:

Lo primero que hay que observar aquí es la extensión de AbstractR2dbcConfiguration. Esta clase contiene un montón de Beans que ya no necesitamos crear manualmente. La implementación de connectionFactory es el único requisito de la clase, ya que es necesario para crear el Bean DatabaseClient. Este tipo de estructura es típica de los módulos de Spring Data, por lo que se siente bastante familiar al probar uno diferente. Además, yo esperaría que esta configuración manual se elimine una vez que la autoconfiguración esté disponible y se dirija únicamente a través del application.properties.

He incluido la propiedad del port aquí, pero si no has jugado con la configuración de tu Postgres entonces puedes confiar en el valor por defecto de 5432.

Las cuatro propiedades: host, database, username  y password definidas por el PostgresqlConnectionFactory son lo mínimo para que funcione. Cualquier cosa menos y experimentará excepciones durante el arranque.

Usando esta configuración, Spring es capaz de conectarse a una instancia de Postgres en ejecución.

El último dato a destacar de este ejemplo es el uso de @EnableR2dbcRepositories. Esta anotación indica a Spring que busque cualquier interfaz de repositorio que extienda la interfaz Repository de Spring. Esta se utiliza como interfaz base para instrumentar los repositorios de Spring Data. Veremos esto con más detalle en la siguiente sección. La principal información que debemos extraer de aquí es que debemos utilizar la anotación @EnableR2dbcRepositories  para aprovechar al máximo las capacidades de Spring Data.

Creación de un repositorio de datos de Spring

Como se ha mencionado anteriormente, en esta sección veremos cómo añadir un repositorio de datos de Spring. Estos repositorios son una buena característica de Spring Data, lo que significa que no es necesario escribir un montón de código extra para simplemente escribir una consulta.

Desafortunadamente, al menos por ahora, Spring R2DBC no puede inferir consultas de la misma manera que lo hacen actualmente otros módulos de Spring Data (estoy seguro de que esto se añadirá en algún momento). Esto significa que tendrá que utilizar la anotación @Query y escribir el SQL a mano. Echemos un vistazo:

Esta interfaz extiende R2dbcRepository. Este a su vez extiende ReactiveCrudRepository  y luego baja a Repository. ReactiveCrudRepository proporciona las funciones CRUD estándar y, por lo que tengo entendido, R2dbcRepository no proporciona ninguna función extra y es, en cambio, una interfaz creada para una mejor denominación de la situación.

R2dbcRepository toma dos parámetros genéricos, uno es la clase de entidad que toma como entrada y produce como salida. El segundo es el tipo de la clave primaria. Por lo tanto, en esta situación, la clase Person está siendo gestionada por el PersonRepository (tiene sentido) y el campo de la clave primaria dentro de Person es un Int.

Los tipos de retorno de las funciones de esta clase y los proporcionados por ReactiveCrudRepository son Flux y Mono (no se ven aquí). Estos son tipos del Proyecto Reactor que Spring utiliza como tipos de flujo reactivo por defecto. Flux representa un flujo de múltiples elementos mientras que Mono es un único resultado.

Finalmente, como mencioné antes del ejemplo, cada función está anotada con @Query. La sintaxis es bastante sencilla, siendo el SQL una cadena dentro de la anotación. El $1 ($2, $3, etc ... para más entradas) representa el valor introducido en la función. Una vez hecho esto, Spring se encargará del resto y pasará la(s) entrada(s) a su respectivo parámetro de entrada, recogerá los resultados y los asignará a la clase de entidad designada del repositorio.

Una mirada muy rápida a la entidad

No voy a decir mucho aquí, sino simplemente mostrar la clase Person utilizada por el PersonRepository.

En realidad, hay un punto que hacer aquí. id se ha hecho anulable y se ha proporcionado un valor por defecto de null para permitir que Postgres genere el siguiente valor adecuado por sí mismo. Si no es anulable y se proporciona un valor de id, Spring intentará ejecutar una actualización en lugar de una inserción al guardar. Hay otras formas de evitar esto, pero creo que esto es suficiente.

Esta entidad se asignará a la tabla de personas definida a continuación:

Ver todo en acción

Ahora veamos cómo se hace realmente. A continuación se muestra un código que inserta algunos registros y los recupera de diferentes maneras:

Una cosa que mencionaré sobre este código. Hay una posibilidad muy real de que se ejecute sin realmente insertar o leer algunos de los registros. Pero, si lo piensas, tiene sentido. Las aplicaciones reactivas están pensadas para hacer cosas de forma asíncrona y, por tanto, esta aplicación ha comenzado a procesar las llamadas a funciones en diferentes hilos. Sin bloquear el hilo principal, estos procesos asíncronos podrían no ejecutarse nunca completamente. Por esta razón, hay algunas llamadas a Thread.sleep en este código, pero las he eliminado del ejemplo para mantener todo ordenado.

El resultado de la ejecución del código anterior sería algo parecido a lo siguiente:

[ main] onSubscribe(FluxConcatMap.ConcatMapImmediate)[ main] request(unbounded)[actor-tcp-nio-1] onNext(Person(id=35, name=Dan Newton, age=25))[actor-tcp-nio-1] onNext(Person(id=36, name=Laura So, age=23))[actor-tcp-nio-1] onComplete()[actor-tcp-nio-2] findAll - Person(id=35, name=Dan Newton, age=25)[actor-tcp-nio-2] findAll - Person(id=36, name=Laura So, age=23)[actor-tcp-nio-4] findAllByName - Person(id=36, name=Laura So, age=23)[actor-tcp-nio-5] findAllByAge - Person(id=35, name=Dan Newton, age=25)

Hay que tener en cuenta algunas cosas:

• onSubscribe y request ocurren en el hilo principal desde el que se llamó al Flux. Solo saveAll  produce esto, ya que ha incluido la función de log. Añadir esto a las otras llamadas habría llevado al mismo resultado de registro en el hilo principal.
• La ejecución contenida en la función de suscripción y los pasos internos del Flux se ejecutan en hilos separados.

Esto no es ni de lejos una representación real de cómo usarías los Streams Reactivos en una aplicación real, pero esperamos que demuestre cómo usarlos y dé una idea de cómo se ejecutan.

Conclusión

En conclusión, los Reactive Streams han llegado a algunas bases de datos RDBMS gracias al driver R2DBC y a Spring Data que construye una capa encima para hacer todo un poco más ordenado. Usando Spring Data R2DBC somos capaces de crear una conexión a una base de datos y empezar a consultarla sin necesidad de demasiado código.

Aunque Spring ya está haciendo mucho por nosotros, podría hacer más. Actualmente, no tiene soporte para la autoconfiguración de Spring Boot. Lo cual es un poco molesto. Pero, estoy seguro de que alguien se pondrá a hacerlo pronto y hará que todo sea aún mejor de lo que ya es.

El código utilizado en este post se puede encontrar en mi GitHub.

Si te ha resultado útil este post, puedes seguirme en Twitter en @LankyDanDev para estar al día de mis nuevas publicaciones.

Publicado originalmente en lankydanblog.com el 16 de febrero de 2019.

Los objetos de cadena son representados como una cadena de caracteres.

Si has trabajado en Java Swing, tiene componentes como JTextField y JTextArea que utilizamos para obtener nuestra entrada de la GUI. Toma nuestra entrada como una cadena de caracteres.

Si queremos hacer una calculadora simple usando Swing, tenemos que averiguar cómo convertir una cadena en un número entero. Esto nos lleva a la pregunta: ¿cómo podemos convertir una cadena en un número entero?

En Java, podemos utilizar Integer.valueOf() e Integer.parseInt() para convertir una cadena en un entero.

1. Utiliza Integer.parseInt() para convertir una cadena en un número entero

Este método devuelve la cadena como un tipo primitivo int. Si la cadena no contiene un entero válido, lanzará una NumberFormatException.

Por lo tanto, cada vez que convirtamos una cadena en un int, tenemos que ocuparnos de esta excepción colocando el código dentro del bloque try-catch.

Consideremos un ejemplo de conversión de una cadena a un int utilizando Integer.parseInt():

        String str = "25";
        try {
            int number = Integer.parseInt(str);
            System.out.println(number); // output = 25
        }
        catch (NumberFormatException ex){
            ex.printStackTrace();
        }

Intentemos romper este código introduciendo un entero no válido:

     	String str = "25T";
        try{
            int number = Integer.parseInt(str);
            System.out.println(number);
        }
        catch (NumberFormatException ex){
            ex.printStackTrace();
        }

Como puedes ver en el código anterior, hemos intentado convertir 25T en un número entero. Esto no es una entrada válida. Por lo tanto, debes lanzar una NumberFormatException.

Este es el resultado del código anterior:

java.lang.NumberFormatException: For input string: "25T"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:580)
	at java.lang.Integer.parseInt(Integer.java:615)
	at OOP.StringTest.main(StringTest.java:51)

A continuación, veremos cómo convertir una cadena de caracteres en un número entero utilizando el método Integer.valueOf().

2. Utiliza Integer.valueOf() para convertir una cadena en un número entero

Este método devuelve la cadena como un objeto entero. Si miras la documentación de Java, Integer.valueOf() devuelve un objeto entero que equivale a un nuevo Integer(Integer.parseInt(s)).

Colocaremos nuestro código dentro del bloque try-catch cuando utilicemos este método. Consideremos un ejemplo utilizando el método Integer.valueOf():

        String str = "25";
        try{
            Integer number = Integer.valueOf(str);
            System.out.println(number); // output = 25
        }
        catch (NumberFormatException ex){
            ex.printStackTrace();
        }

Ahora, intentemos romper el código anterior introduciendo un número entero no válido:

        String str = "25TA";
        try{
            Integer number = Integer.valueOf(str);
            System.out.println(number); 
        }
        catch (NumberFormatException ex){
            ex.printStackTrace();
        }

Al igual que en el ejemplo anterior, el código anterior lanzará una excepción.

Este es el resultado del código anterior:

java.lang.NumberFormatException: For input string: "25TA"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:580)
	at java.lang.Integer.valueOf(Integer.java:766)
	at OOP.StringTest.main(StringTest.java:42)

También podemos crear un método para comprobar si la cadena pasada es numérica o no antes de utilizar los métodos mencionados.

He creado un método sencillo para comprobar si la cadena pasada es numérica o no.

public class StringTest {
    public static void main(String[] args) {
        String str = "25";
        String str1 = "25.06";
        System.out.println(isNumeric(str));
        System.out.println(isNumeric(str1));
    }

    private static boolean isNumeric(String str){
        return str != null && str.matches("[0-9.]+");
    }
}

La salida es:

true
true

El método isNumeric() toma una cadena como argumento. Primero comprueba si es null o no. Después utilizamos el método matches() para comprobar si contiene dígitos del 0 al 9 y un carácter de punto.

Esta es una forma sencilla de comprobar los valores numéricos. Puedes escribir o buscar en Google expresiones regulares más avanzadas para capturar valores numéricos dependiendo de tu caso de uso.

Es una buena práctica comprobar si la cadena pasada es numérica o no antes de intentar convertirla a entero.

Gracias por leer.

Imagen por ?? Janko Ferlič en Unsplash

Puedes conectarte conmigo en Medium.

¡Feliz codificación!