JAVA - Clases contenedoras, Excepciones try...catch, Expresiones lambda, Expresiones regulares, Hilos, Iterador

Signed-off-by: Alejandro Alfaro Sánchez <alejandro@alejandroalsa.es>

Author: alejandroalsa

_posts/2023-12-15-java-metodos-clase.md

@@ -1,5 +1,5 @@
 ---
-title: métodos de clase
+title: Métodos de clase
 date: 2023-12-15 12:00:00 +0800
 categories: [Programación, Java]
 tags: [Java]

_posts/2024-01-07-java-clases-contenedoras .md

@@ -0,0 +1,87 @@
+---
+title: Clases contenedoras 
+date: 2024-01-07 9:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+# Clases contenedoras 
+
+Las clases Wrapper permiten utilizar tipos de datos primitivos (`int`, `boolean`, etc.) como objetos.
+
+La siguiente tabla muestra el tipo primitivo y la clase contenedora equivalente: 
+
+| Tipo de Datos Primitivo | Clase Envolvente |
+|-------------------------|------------------|
+| byte                    | Byte             |
+| short                   | Short            |
+| int                     | Integer          |
+| long                    | Long             |
+| float                   | Float            |
+| double                  | Double           |
+| boolean                 | Boolean          |
+| char                    | Character        |
+
+A veces es necesario utilizar clases envoltorio, por ejemplo cuando se trabaja con objetos `Collection`, como `ArrayList`, donde no se pueden utilizar tipos primitivos (la lista sólo puede almacenar objetos):
+
+```java
+ArrayList<int> misNumeros = new ArrayList<int>(); // Error
+
+ArrayList<Integer> misNumeros = new ArrayList<Integer>(); // Correcto
+```
+
+## Crear objetos envolventes 
+
+Para crear un objeto envoltorio, puedes utilizar la clase envoltorio en lugar del tipo primitivo. Para obtener el valor, basta con imprimir el objeto:
+
+```java
+public class main {
+  public static void main(String[] args) {
+    Integer miInt = 5;
+    Double miDoble = 5.99;
+    Character miCaracter = 'A';
+    System.out.println(miInt);
+    System.out.println(miDoble);
+    System.out.println(miCaracter);
+  }
+}
+```
+
+Como ahora trabajas con objetos, puedes utilizar ciertos métodos para obtener información sobre el objeto específico.
+
+Por ejemplo, los siguientes métodos se utilizan para obtener el valor asociado al objeto envoltorio correspondiente: `intValue()`, `byteValue()`, `shortValue()`, `longValue()`, `floatValue()`, `doubleValue()`, `charValue()`, `booleanValue()`.
+
+Este ejemplo devolverá el mismo resultado que el ejemplo anterior:
+
+```java
+public class main {
+  public static void main(String[] args) {
+    Integer miInt = 5;
+    Double miDoble = 5.99;
+    Character miCaracter = 'A';
+    System.out.println(miInt.intValue());
+    System.out.println(miDoble.doubleValue());
+    System.out.println(miCaracter.charValue());
+  }
+}
+```
+
+Otro método útil es el método `toString()`, que se utiliza para convertir objetos envolventes en cadenas.
+
+En el siguiente ejemplo, convertimos un entero en una cadena y utilizamos el método `length()` de la clase `String` para obtener la longitud de la "cadena":
+
+```java
+public class main {
+  public static void main(String[] args) {
+    Integer miInt = 100;
+    String miString = miInt.toString();
+    System.out.println(miString.length());
+  }
+}
+```
+
+Salida:
+
+```txt
+3
+```

_posts/2024-01-07-java-excepciones-try-catch.md

@@ -0,0 +1,121 @@
+---
+title: Excepciones Try...Catch
+date: 2024-01-07 10:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+# Excepciones Try...Catch
+
+Al ejecutar código Java pueden ocurrir diferentes errores: errores de codificación cometidos por el programador, errores por entrada incorrecta, u otras cosas imprevisibles. 
+
+Cuando se produce un error, Java normalmente se detiene y genera un mensaje de error. El término técnico para esto es: excepción.
+
+La sentencia try le permite definir un bloque de código para que se compruebe si hay errores mientras se ejecuta.
+
+La sentencia `catch` permite definir un bloque de código que se ejecutará si se produce un error en el bloque try.
+
+Las palabras clave `try` y `catch` vienen en pares:
+
+```java
+try {
+  // Bloque de código para probar
+}
+catch(Exception e) {
+  // Bloque de código para gestionar errores
+}
+```
+
+Veamos el siguiente ejemplo: 
+
+```java
+// Esto generará un error porque misNumeros[10] no existe.
+
+public class main {
+  public static void main(String[ ] args) {
+    int[] misNumeros = {1, 2, 3};
+    System.out.println(misNumeros[10]); // error
+  }
+}
+```
+
+Salida:
+
+```txt
+Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 3 
+        at datosBasicos.main.main(main.java:6)
+```
+
+Si ocurre un error, podemos usar `try...catch` para detectar el error y ejecutar algún código para manejarlo: 
+
+```java
+public class main {
+  public static void main(String[ ] args) {
+    try {
+      int[] misNumeros = {1, 2, 3};
+      System.out.println(misNumeros[10]);
+    } catch (Exception e) {
+      System.out.println("Algo salió mal.");
+    }
+  }
+}
+```
+
+Salida:
+
+```txt
+Algo salió mal.
+```
+
+La sentencia `finally` permite ejecutar código, después de `try...catch`, independientemente del resultado:
+
+```java
+public class main {
+  public static void main(String[ ] args) {
+    try {
+      int[] misNumeros = {1, 2, 3};
+      System.out.println(misNumeros[10]);
+    } catch (Exception e) {
+      System.out.println("Algo salió mal.");
+    } finally {
+      System.out.println("El 'try catch' ha terminado.");
+    }
+  }
+}
+```
+
+Salida:
+
+```txt
+Algo salió mal.
+El 'try catch' ha terminado.
+```
+
+La sentencia `throw` permite crear un error personalizado.
+
+La sentencia `throw` se utiliza junto con un tipo de excepción. Hay muchos tipos de excepción disponibles en Java: `ArithmeticException`, `FileNotFoundException`, `ArrayIndexOutOfBoundsException`, `SecurityException`, etc:
+
+```java
+public class main {
+  static void comprobarEdad(int edad) {
+    if (edad < 18) {
+      throw new ArithmeticException("Acceso denegado - Debes tener al menos 18 años".);
+    }
+    else {
+      System.out.println("Acceso concedido - ¡Ya eres mayor!");
+    }
+  }
+
+  public static void main(String[] args) {
+    comprobarEdad(15); // Establecer la edad en 15 (que es inferior a 18...)
+  }
+}
+```
+
+Salida:
+
+```txt
+Exception in thread "main" java.lang.ArithmeticException: Acceso denegado - Debes tener al menos 18 años
+        at datosBasicos.main.comprobarEdad(main.java:6)
+        at datosBasicos.main.main(main.java:14)
+```

_posts/2024-01-07-java-expresiones-lambda.md

@@ -0,0 +1,93 @@
+---
+title: Expresiones Lambda
+date: 2024-01-07 13:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+# Expresiones Lambda
+
+Las expresiones Lambda se agregaron en Java 8.
+
+Una expresión lambda es un bloque corto de código que toma parámetros y devuelve un valor. Las expresiones lambda son similares a los métodos, pero no necesitan un nombre y se puede implementar directamente en el cuerpo de un método. 
+
+La expresión lambda más simple contiene un único parámetro y una expresión: 
+
+```txt
+parámetro -> expresión
+```
+
+Para utilizar más de un parámetro, los envolvemos entre paréntesis: 
+
+```txt
+(parámetro1, parámetro2) -> expresión
+```
+
+Las expresiones son limitadas. Tienen que devolver inmediatamente un valor y no pueden contener variables, asignaciones o declaraciones tales como `if` o `for`. Para hacer operaciones algo más complejas, se puede utilizar bloques de código con llaves. Si la expresión lambda necesita devolver un valor, entonces el bloque de código debe tener una declaración `return`. 
+
+```txt
+(parámetro1, parámetro2) -> { bloque de código }
+```
+
+Las expresiones lambda normalmente se pasan como parámetros a una función
+
+```java
+// Utiliza una expresión lambda en el método forEach() de ArrayList para imprimir cada elemento de la lista
+
+import java.util.ArrayList;
+
+public class main {
+  public static void main(String[] args) {
+    ArrayList<Integer> numeros = new ArrayList<Integer>();
+    numeros.add(3);
+    numeros.add(1);
+    numeros.add(7);
+    numeros.add(4);
+    numeros.forEach( (n) -> { System.out.println(n); } );
+  }
+}
+```
+
+Las expresiones lambda se pueden almacenar en variables si el tipo de variable es una interfaz que tiene un solo método. La expresión lambda debe tener el mismo número de parámetros y el mismo tipo de retorno que ese método. Java tiene muchos de estos tipos de interfaces integradas, como la `Consumer` interfaz (que se encuentra en el paquete `java.util`) utilizada para las listas
+
+```java
+// Utiliza la interfaz Consumer de Java para almacenar una expresión lambda en una variable
+
+import java.util.ArrayList;
+import java.util.function.Consumer;
+
+public class main {
+  public static void main(String[] args) {
+    ArrayList<Integer> numeros = new ArrayList<Integer>();
+    numeros.add(3);
+    numeros.add(1);
+    numeros.add(7);
+    numeros.add(4);
+    Consumer<Integer> metodo = (n) -> { System.out.println(n); };
+    numeros.forEach( metodo );
+  }
+}
+```
+
+Para utilizar una expresión lambda en un método, éste debe tener un parámetro cuyo tipo sea una interfaz de método único. Al llamar al método de la interfaz se ejecutará la expresión lambda:
+
+```java
+// Método que toma una expresión lambda como parámetro
+
+interface funcionCadena {
+  String run(String str);
+}
+
+public class main {
+  public static void main(String[] args) {
+    funcionCadena exclamacion = (s) -> s + "!";
+    funcionCadena pregunta = (s) -> s + "?";
+    funcionCadena("Hola", exclamacion);
+    funcionCadena("Hola", pregunta);
+  }
+  public static void funcionCadena(String str, funcionCadena formato) {
+    String resultado = formato.run(str);
+    System.out.println(resultado);
+  }
+}
+```