From 310c48e8dcc9f3ab533cdd9ae40134422b380d70 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 24 Nov 2025 17:11:24 -0500 Subject: [PATCH 1/3] #22 - Java --- .../java/JimsimroDev.java | 162 ++++++++++++++++++ 1 file changed, 162 insertions(+) create mode 100644 Roadmap/22 - FUNCIONES DE ORDEN SUPERIOR/java/JimsimroDev.java diff --git a/Roadmap/22 - FUNCIONES DE ORDEN SUPERIOR/java/JimsimroDev.java b/Roadmap/22 - FUNCIONES DE ORDEN SUPERIOR/java/JimsimroDev.java new file mode 100644 index 0000000000..b3ef03f7de --- /dev/null +++ b/Roadmap/22 - FUNCIONES DE ORDEN SUPERIOR/java/JimsimroDev.java @@ -0,0 +1,162 @@ +/* + * EJERCICIO: + * Explora el concepto de funciones de orden superior en tu lenguaje + * creando ejemplos simples (a tu elección) que muestren su funcionamiento. + * + * DIFICULTAD EXTRA (opcional): + * Dada una lista de estudiantes (con sus nombres, fecha de nacimiento y + * lista de calificaciones), utiliza funciones de orden superior para + * realizar las siguientes operaciones de procesamiento y análisis: + * - Promedio calificaciones: Obtiene una lista de estudiantes por nombre + * y promedio de sus calificaciones. + * - Mejores estudiantes: Obtiene una lista con el nombre de los estudiantes + * que tienen calificaciones con un 9 o más de promedio. + * - Nacimiento: Obtiene una lista de estudiantes ordenada desde el más joven. + * - Mayor calificación: Obtiene la calificación más alta de entre todas las + * de los alumnos. + * - Una calificación debe estar comprendida entre 0 y 10 (admite decimales). + */ + +import java.time.LocalDate; +import java.time.format.DateTimeFormatter; +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; + +public class JimsimroDev { + // Filtra por pares imprime solo los numeros pares + private static List filtrarPares(List numeros) { + var pares = numeros.stream().filter(n -> n % 2 == 0).toList(); + return pares; + } + + // Ordena de mayor a menor + private static List ordenardeMayorAmenor(List numeros) { + var numerosOrdenadosDescendente = numeros.stream().sorted(Comparator.reverseOrder()).toList(); + return numerosOrdenadosDescendente; + } + + // Multiplicar * 2 + private static List multiplicarPorDos(List numeros) { + var numerosMultiplicados = numeros.stream().map(n -> n * 2).toList(); + return numerosMultiplicados; + } + + // Extra + static class Alumno { + private String nombre; + private String fechaNacimiento; + private List calificacion; + + Alumno(String nombre, String fechaNacimientos, List calificacion) { + this.nombre = nombre; + this.fechaNacimiento = fechaNacimientos; + this.calificacion = calificacion; + } + + // Inicializa la lista de esutiantes + private static List obtenerAlumnos() { + List estudiantes = Arrays.asList( + new Alumno("Jhoan", "28/07/1995", Arrays.asList(7.7, 4.1, 3.9)), + new Alumno("Juan", "05/08/1994", Arrays.asList(9.7, 9.1, 9.0)), + new Alumno("Mario", "07/11/1990", Arrays.asList(8.0, 9.1, 9.9)), + new Alumno("Keren", "20/12/2016", Arrays.asList(9.8, 9.9, 10.0))); + return estudiantes; + } + + @Override + public String toString() { + return String.format("{ Nombre: %s - Fecha Nacimiento: %s }", nombre, fechaNacimiento); + } + } + + static void print(Object... args) { + for (Object s : args) { + System.out.print(s + "\n"); + } + } + + // Promedio calificaciones: Obtiene una lista de estudiantes por nombre y + // promedio de sus calificaciones. + private static void mostrarPromedioPorAlumnos() { + List promedioEstudiante = Alumno.obtenerAlumnos().stream() + .map(s -> { + double promedio = s.calificacion.stream() + .mapToDouble(d -> d).average().getAsDouble(); + return String.format("Nombre: %s - Fecha Nacimiento: %s - Promedio: %.2f%n ", s.nombre, s.fechaNacimiento, + promedio); + }).toList(); + print(promedioEstudiante); + } + + // Mejores estudiantes: Obtiene una lista con el nombre de los estudiantes que + // tienen calificaciones con un 9 o más de promedio. + private static void getMayorPromedio() { + print("Estudiantes con Promedio >= 9"); + print(Alumno.obtenerAlumnos().stream() + .filter(s -> s.calificacion.stream() + .mapToDouble(d -> d).average().getAsDouble() >= 9) + .map(estudiante -> { + double promedio = estudiante.calificacion.stream() + .mapToDouble(d -> d).average().getAsDouble(); + return String.format("Nombre: %s - Promedio: %.2f%n ", estudiante.nombre, promedio); + }).toList()); + } + + // Obtiene una lista de estudiantes ordenada desde el más joven. + private static void mostrarAlumnoPorEdadDescendente() { + print("Estudiantes ordenado por fecha nacimiento"); + Alumno.obtenerAlumnos().stream() + .sorted(Comparator + .comparing((Alumno e) -> LocalDate.parse(e.fechaNacimiento, DateTimeFormatter.ofPattern("dd/MM/yyyy"))) + .reversed()) + .forEach(System.out::println); + } + + // Mayor calificación: Obtiene la calificación más alta de entre todas las de + // los alumnos. + private static void mostrarCalificacionMasAltaPorEstudiante() { + print("La notas mas alta entre todos"); + Alumno.obtenerAlumnos().stream() + .mapToDouble(d -> d.calificacion.stream() + .mapToDouble(n -> n) + .max().getAsDouble()) + .max().ifPresent(System.out::println); + + } + + // Mayor calificación: Obtiene la calificación más alta de entre todas las de + // los alumnos. + private static void mostrarCalificacionMasAltaGlobal() { + double notaMaxima = Alumno.obtenerAlumnos().stream() + .flatMapToDouble(e -> e.calificacion.stream() + .mapToDouble(d -> d)) + .max().getAsDouble(); + print(notaMaxima); + } + + public static void main(String[] args) { + List listaNumeros = Arrays.asList(8, 9, 12, 1, 4, 6, 7, 11, 5, 10, 2, 3); + print("Números ordenados de > a < " + ordenardeMayorAmenor(listaNumeros)); + print("Ordena e imprime solo los pares " + filtrarPares(ordenardeMayorAmenor(listaNumeros))); + print("Multiplicar el resultado * 2 " + multiplicarPorDos(filtrarPares(ordenardeMayorAmenor(listaNumeros)))); + print("Numeros Impares " + listaNumeros.stream().filter(n -> n % 2 == 1).toList()); + print("Mayor " + listaNumeros.stream().max(Integer::compare).get()); + print("Menor " + listaNumeros.stream().min(Integer::compare).get()); + + // Extra + mostrarPromedioPorAlumnos(); + getMayorPromedio(); + mostrarAlumnoPorEdadDescendente(); + mostrarCalificacionMasAltaPorEstudiante(); + mostrarCalificacionMasAltaGlobal(); + + List average = Alumno.obtenerAlumnos().stream() + .map(estudiante -> estudiante.calificacion + .stream() + .mapToDouble(d -> d) + .average().getAsDouble()) + .toList(); + print("Average " + average); + } +} From 67f175a537027ebc05fa2a743bae472bea50b7e4 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 24 Nov 2025 22:35:58 -0500 Subject: [PATCH 2/3] #23 - Java --- Roadmap/23 - SINGLETON/java/JimsimroDev.java | 96 ++++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 Roadmap/23 - SINGLETON/java/JimsimroDev.java diff --git a/Roadmap/23 - SINGLETON/java/JimsimroDev.java b/Roadmap/23 - SINGLETON/java/JimsimroDev.java new file mode 100644 index 0000000000..724aef0306 --- /dev/null +++ b/Roadmap/23 - SINGLETON/java/JimsimroDev.java @@ -0,0 +1,96 @@ +/* + * EJERCICIO: + * Explora el patrón de diseño "singleton" y muestra cómo crearlo + * con un ejemplo genérico. + * + * DIFICULTAD EXTRA (opcional): + * Utiliza el patrón de diseño "singleton" para representar una clase que + * haga referencia a la sesión de usuario de una aplicación ficticia. + * La sesión debe permitir asignar un usuario (id, username, nombre y email), + * recuperar los datos del usuario y borrar los datos de la sesión. + */ + +public class JimsimroDev { + + public static class ConfiguracionGlobal { + + private static ConfiguracionGlobal config; + + private ConfiguracionGlobal() { + } + + public static ConfiguracionGlobal getConfig() { + return (config == null) ? config = new ConfiguracionGlobal() : config; + } + } + + // Extra + public static class SesionUsuario { + private static SesionUsuario instancia; + private Long id; + private String username; + private String nombre; + private String email; + + private SesionUsuario() { + } + + public static SesionUsuario getInstancia() { + return instancia == null ? instancia = new SesionUsuario() : instancia; + } + + public void registrarUsuario(Long id, String username, String nombre, String email) { + this.id = id; + this.username = username; + this.nombre = nombre; + this.email = email; + } + + public String mostrarDatosUsuario() { + if (this.id == null) { + return "No hay usuario registrado."; + } + return String.format("ID: %d - Username: %s - Nombre: %s - Email: %s", this.id, this.username, this.nombre, + this.email); + } + + public void cerrarSesion() { + this.id = null; + this.username = null; + this.nombre = null; + this.email = null; + } + } + + public static void main(String[] args) { + ConfiguracionGlobal config1 = ConfiguracionGlobal.getConfig(); + ConfiguracionGlobal config2 = ConfiguracionGlobal.getConfig(); + System.out.println(config1 == config2); + + // Extra + System.out.println("Creando una nueva instancia de SesionUsuario..."); + var sesion1 = SesionUsuario.getInstancia(); + sesion1.registrarUsuario(1L, "jimsimro", "Jim Simro", "prueba@gmail.com"); + + var sesion2 = SesionUsuario.getInstancia(); + + System.out.println(sesion2.mostrarDatosUsuario()); + System.out.println(sesion1.mostrarDatosUsuario()); + + System.out.println("Creando una nueva instancia de SesionUsuario..."); + sesion2.registrarUsuario(2L, "jhoans", "Jhoan", "prueba2@gmail.com"); + System.out.println(sesion2.mostrarDatosUsuario()); + System.out.println(sesion1.mostrarDatosUsuario()); + + System.out.println("Creando una nueva instancia de SesionUsuario..."); + var sesion3 = SesionUsuario.getInstancia(); + System.out.println(sesion3.mostrarDatosUsuario()); + System.out.println(sesion2.mostrarDatosUsuario()); + System.out.println(sesion1.mostrarDatosUsuario()); + + sesion2.cerrarSesion(); + + System.out.println(sesion2.mostrarDatosUsuario()); + System.out.println(sesion1.mostrarDatosUsuario()); + } +} From 5ebb9ae5c4695a8e1e8c4632d112dc04a89501f1 Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 27 Nov 2025 20:59:28 -0500 Subject: [PATCH 3/3] # 24 - Java --- .../24 - DECORADORES/java/JimsimroDev.java | 61 +++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 Roadmap/24 - DECORADORES/java/JimsimroDev.java diff --git a/Roadmap/24 - DECORADORES/java/JimsimroDev.java b/Roadmap/24 - DECORADORES/java/JimsimroDev.java new file mode 100644 index 0000000000..72eb9311be --- /dev/null +++ b/Roadmap/24 - DECORADORES/java/JimsimroDev.java @@ -0,0 +1,61 @@ +/* + * EJERCICIO: + * Explora el concepto de "decorador" y muestra cómo crearlo + * con un ejemplo genérico. + * + * DIFICULTAD EXTRA (opcional): + * Crea un decorador que sea capaz de contabilizar cuántas veces + * se ha llamado a una función y aplícalo a una función de tu elección. + */ +public class JimsimroDev { + public static interface EncenderAutomovil { + void encender(String mensaje); + } + + // Clase concreta que implementa la interfaz + public static class Automovil implements EncenderAutomovil { + @Override + public void encender(String mensaje) { + System.out.println("El automóvil se ha encendido: " + mensaje); + } + + } + + public static class DecoradorAutomovil implements EncenderAutomovil { + private EncenderAutomovil wrappee; + private String nombreMetodo; + private int contadorLlamadas = 0; + + private DecoradorAutomovil(EncenderAutomovil wrappee, String nombreMetodo) { + this.wrappee = wrappee; + this.nombreMetodo = nombreMetodo; + } + + @Override + public void encender(String mensaje) { + contadorLlamadas++; + System.out.printf("función %s ha sido llamda %d veces \n", nombreMetodo, getContadorLlamadas()); + wrappee.encender(mensaje); + } + + public int getContadorLlamadas() { + return contadorLlamadas; + } + } + + public static void main(String[] args) { + var automóvilPrueba = new Automovil(); + var testlaModelY = new DecoradorAutomovil(automóvilPrueba, "testlaModelY"); + var testlaModelS = new DecoradorAutomovil(automóvilPrueba, "testlaModelS"); + + testlaModelY.encender("Arrancando el motor V8"); + testlaModelY.encender("Arrancando el motor V8"); + testlaModelY.encender("Arrancando el motor V8"); + + testlaModelS.encender("Arrancando el motor V6"); + testlaModelS.encender("Arrancando el motor V6"); + testlaModelS.encender("Arrancando el motor V6"); + + testlaModelY.encender("Arrancando el motor V8"); + } +}