From f551fbd5afd1ef7c70c02a5abbdca59715fb881b Mon Sep 17 00:00:00 2001 From: Ramon Bernabe Munoz Navarrete Date: Fri, 7 Jun 2024 22:42:07 -0400 Subject: [PATCH] M4 - Documentar D15 --- Vinceto/src/D15/ArrayListMethods.java | 20 ++++++- Vinceto/src/D15/ArrayListOperations.java | 26 ++++++++- Vinceto/src/D15/ArrayListSearch.java | 26 ++++++++- Vinceto/src/D15/ArraysIntro.java | 29 +++++++++- Vinceto/src/D15/MultiplosDeTres.java | 35 +++++++++++- .../src/D15/MultiplosDeTresConPromedio.java | 49 ++++++++++++++++- Vinceto/src/D15/SmartWatch.java | 53 +++++++++++++++++-- Vinceto/src/D15/Visitas.java | 35 ++++++++++-- 8 files changed, 257 insertions(+), 16 deletions(-) diff --git a/Vinceto/src/D15/ArrayListMethods.java b/Vinceto/src/D15/ArrayListMethods.java index 1dafbab..e16a177 100644 --- a/Vinceto/src/D15/ArrayListMethods.java +++ b/Vinceto/src/D15/ArrayListMethods.java @@ -3,8 +3,20 @@ import java.util.ArrayList; import java.util.Collections; +/** + * La clase ArrayListMethods proporciona una aplicación que + * maneja una lista de notas y muestra la nota máxima y mínima. + */ public class ArrayListMethods { + + /** + * El método principal que ejecuta la aplicación. + * Inicializa una lista de notas y muestra la nota máxima y mínima. + * + * @param args Un arreglo de cadenas que representa los argumentos de línea de comandos. + */ public static void main(String[] args) { + // Inicializa una lista de notas con valores predeterminados ArrayList notas = new ArrayList(); notas.add(4.7); notas.add(2.2); @@ -13,13 +25,19 @@ public static void main(String[] args) { notas.add(4.4); notas.add(2.6); + // Muestra la nota máxima y mínima de la lista mostrarNotaMaximaYMinima(notas); } + /** + * Muestra la nota máxima y mínima de una lista de notas. + * + * @param notas Una lista de números decimales que representan las notas. + */ public static void mostrarNotaMaximaYMinima(ArrayList notas) { double maxNota = Collections.max(notas); double minNota = Collections.min(notas); System.out.println("Nota máxima: " + maxNota); System.out.println("Nota mínima: " + minNota); } -} +} \ No newline at end of file diff --git a/Vinceto/src/D15/ArrayListOperations.java b/Vinceto/src/D15/ArrayListOperations.java index 85980cb..56e06f7 100644 --- a/Vinceto/src/D15/ArrayListOperations.java +++ b/Vinceto/src/D15/ArrayListOperations.java @@ -2,24 +2,46 @@ import java.util.ArrayList; +/** + * La clase ArrayListOperations proporciona una aplicación que + * agrega elementos a una lista de cadenas, verificando si el elemento + * ya existe antes de agregarlo. + */ public class ArrayListOperations { + + /** + * El método principal que ejecuta la aplicación. + * Inicializa una lista de elementos, intenta agregar nuevos elementos + * y muestra mensajes correspondientes. + * + * @param args Un arreglo de cadenas que representa los argumentos de línea de comandos. + */ public static void main(String[] args) { + // Inicializa una lista de elementos con valores predeterminados ArrayList elementos = new ArrayList(); elementos.add("mesa"); elementos.add("Refrigerador"); elementos.add("Cocina"); elementos.add("lavadora"); + // Intenta agregar nuevos elementos a la lista agregarElemento(elementos, "Silla"); agregarElemento(elementos, "Cocina"); // Este elemento ya existe } + /** + * Agrega un elemento a la lista si no existe ya en la lista. + * Muestra un mensaje si el elemento ya existe o si se ha agregado exitosamente. + * + * @param lista Una lista de cadenas que representa los elementos. + * @param elemento El elemento a agregar a la lista. + */ public static void agregarElemento(ArrayList lista, String elemento) { if (lista.contains(elemento)) { - System.out.println("Elemento "+elemento+" ya existe"); + System.out.println("Elemento " + elemento + " ya existe"); } else { lista.add(elemento); System.out.println("Elemento agregado: " + elemento); } } -} +} \ No newline at end of file diff --git a/Vinceto/src/D15/ArrayListSearch.java b/Vinceto/src/D15/ArrayListSearch.java index 63f8edd..b6dd4a3 100644 --- a/Vinceto/src/D15/ArrayListSearch.java +++ b/Vinceto/src/D15/ArrayListSearch.java @@ -2,8 +2,21 @@ import java.util.ArrayList; +/** + * La clase ArrayListSearch proporciona una aplicación que + * busca y elimina elementos en una lista de nombres. + */ public class ArrayListSearch { + + /** + * El método principal que ejecuta la aplicación. + * Inicializa una lista de nombres, busca y elimina nombres específicos, + * y muestra mensajes correspondientes. + * + * @param args Un arreglo de cadenas que representa los argumentos de línea de comandos. + */ public static void main(String[] args) { + // Inicializa una lista de nombres con valores predeterminados ArrayList nombres = new ArrayList(); nombres.add("Pedro"); nombres.add("Juan"); @@ -11,17 +24,28 @@ public static void main(String[] args) { nombres.add("Ana"); nombres.add("Luis"); + // Busca y elimina los nombres especificados buscarYEliminar(nombres, "Maria"); buscarYEliminar(nombres, "Carlos"); } + /** + * Busca un nombre en la lista y lo elimina si está presente. + * Muestra un mensaje si el nombre se encuentra o no, y muestra la lista después de la eliminación. + * + * @param lista Una lista de cadenas que representa los nombres. + * @param nombre El nombre a buscar y eliminar en la lista. + */ public static void buscarYEliminar(ArrayList lista, String nombre) { if (lista.contains(nombre)) { System.out.println("Elemento encontrado: " + nombre); + lista.remove(nombre); // Elimina el nombre si se encuentra } else { System.out.println("Elemento no encontrado: " + nombre); lista.removeIf(n -> n.equals(nombre)); System.out.println("Lista después de la eliminación: " + lista); } + // Muestra la lista después de la eliminación + System.out.println("Lista después de la eliminación: " + lista); } -} +} \ No newline at end of file diff --git a/Vinceto/src/D15/ArraysIntro.java b/Vinceto/src/D15/ArraysIntro.java index b4ac858..17b95f3 100644 --- a/Vinceto/src/D15/ArraysIntro.java +++ b/Vinceto/src/D15/ArraysIntro.java @@ -1,21 +1,48 @@ package D15; +/** + * La clase ArraysIntro proporciona una aplicación que calcula + * el promedio de los sueldos que son mayores a 500000. + */ public class ArraysIntro { + + /** + * El método principal que ejecuta la aplicación. + * Inicializa un arreglo de sueldos y calcula el promedio de + * aquellos sueldos que son mayores a 500000, luego muestra este valor. + * + * @param args Un arreglo de cadenas que representa los argumentos de línea de comandos. + */ public static void main(String[] args) { + // Inicializa un arreglo de sueldos con valores predeterminados int[] sueldos = {400000, 760000, 1100000, 650000, 654980, 987300, 700450, 442300}; + + // Calcula el promedio de los sueldos mayores a 500000 double promedio = calcularPromedioSueldos(sueldos); + + // Muestra el promedio de los sueldos mayores a 500000 System.out.println("El promedio de los sueldos mayores a 500000 es: " + promedio); } + /** + * Calcula el promedio de los sueldos que son mayores a 500000. + * + * @param sueldos Un arreglo de enteros que representa los sueldos. + * @return El promedio de los sueldos mayores a 500000 como un valor de tipo double. + */ public static double calcularPromedioSueldos(int[] sueldos) { int suma = 0; int contador = 0; + + // Suma y cuenta los sueldos que son mayores a 500000 for (int sueldo : sueldos) { if (sueldo > 500000) { suma += sueldo; contador++; } } + + // Retorna el promedio de los sueldos mayores a 500000. Si no hay sueldos mayores a 500000, retorna 0. return contador == 0 ? 0 : (double) suma / contador; } -} +} \ No newline at end of file diff --git a/Vinceto/src/D15/MultiplosDeTres.java b/Vinceto/src/D15/MultiplosDeTres.java index 052e7f6..7806dc9 100644 --- a/Vinceto/src/D15/MultiplosDeTres.java +++ b/Vinceto/src/D15/MultiplosDeTres.java @@ -1,22 +1,53 @@ package D15; +/** + * La clase MultiplosDeTres proporciona una aplicación que + * calcula la suma de los números múltiplos de tres dados + * como argumentos de línea de comandos. + */ public class MultiplosDeTres { + + /** + * El método principal que ejecuta la aplicación. + * Convierte los argumentos de línea de comandos en un arreglo de enteros, + * calcula la suma de los números que son múltiplos de tres, + * y muestra este valor. + * + * @param args Un arreglo de cadenas que representa los argumentos de línea de comandos. + */ public static void main(String[] args) { + // Inicializa un arreglo de enteros del mismo tamaño que los argumentos de línea de comandos int[] numeros = new int[args.length]; + + // Convierte cada argumento de cadena en un entero y lo guarda en el arreglo numeros for (int i = 0; i < args.length; i++) { numeros[i] = Integer.parseInt(args[i]); } + + // Calcula la suma de los múltiplos de tres int sumaMultiplos = suma(numeros); - System.out.println("sumaMultiplos : "+sumaMultiplos); + + // Muestra la suma de los múltiplos de tres + System.out.println("Suma de múltiplos de tres: " + sumaMultiplos); } + /** + * Calcula la suma de los números múltiplos de tres en un arreglo de enteros. + * + * @param numeros Un arreglo de enteros. + * @return La suma de los números múltiplos de tres. + */ public static int suma(int[] numeros) { int suma = 0; + + // Suma los números que son múltiplos de tres for (int numero : numeros) { if (numero % 3 == 0) { suma += numero; } } + + // Retorna la suma de los múltiplos de tres return suma; } -} +} \ No newline at end of file diff --git a/Vinceto/src/D15/MultiplosDeTresConPromedio.java b/Vinceto/src/D15/MultiplosDeTresConPromedio.java index 6ff8f04..e53bea5 100644 --- a/Vinceto/src/D15/MultiplosDeTresConPromedio.java +++ b/Vinceto/src/D15/MultiplosDeTresConPromedio.java @@ -1,36 +1,81 @@ package D15; +/** + * La clase MultiplosDeTresConPromedio proporciona una aplicación que + * calcula la suma y el promedio de los números múltiplos de tres dados + * como argumentos de línea de comandos. + */ public class MultiplosDeTresConPromedio { + + /** + * El método principal que ejecuta la aplicación. + * Convierte los argumentos de línea de comandos en un arreglo de enteros, + * calcula la suma y el promedio de los números que son múltiplos de tres, + * y muestra estos valores. + * + * @param args Un arreglo de cadenas que representa los argumentos de línea de comandos. + */ public static void main(String[] args) { + // Inicializa un arreglo de enteros del mismo tamaño que los argumentos de línea de comandos int[] numeros = new int[args.length]; + + // Convierte cada argumento de cadena en un entero y lo guarda en el arreglo numeros for (int i = 0; i < args.length; i++) { numeros[i] = Integer.parseInt(args[i]); } + + // Calcula la suma de los múltiplos de tres int sumaMultiplos = suma(numeros); + + // Calcula el promedio de los múltiplos de tres double promedioMultiplos = promedio(numeros); - System.out.println("sumaMultiplos : "+sumaMultiplos); - System.out.println("promedioMultiplos : "+promedioMultiplos); + + // Muestra la suma de los múltiplos de tres + System.out.println("Suma de múltiplos de tres: " + sumaMultiplos); + + // Muestra el promedio de los múltiplos de tres + System.out.println("Promedio de múltiplos de tres: " + promedioMultiplos); } + /** + * Calcula la suma de los números múltiplos de tres en un arreglo de enteros. + * + * @param numeros Un arreglo de enteros. + * @return La suma de los números múltiplos de tres. + */ public static int suma(int[] numeros) { int suma = 0; + + // Suma los números que son múltiplos de tres for (int numero : numeros) { if (numero % 3 == 0) { suma += numero; } } + + // Retorna la suma de los múltiplos de tres return suma; } + /** + * Calcula el promedio de los números múltiplos de tres en un arreglo de enteros. + * + * @param numeros Un arreglo de enteros. + * @return El promedio de los números múltiplos de tres como un valor de tipo double. + */ public static double promedio(int[] numeros) { int suma = 0; int contador = 0; + + // Suma y cuenta los números que son múltiplos de tres for (int numero : numeros) { if (numero % 3 == 0) { suma += numero; contador++; } } + + // Retorna el promedio de los múltiplos de tres. Si no hay múltiplos de tres, retorna 0. return contador == 0 ? 0 : (double) suma / contador; } } diff --git a/Vinceto/src/D15/SmartWatch.java b/Vinceto/src/D15/SmartWatch.java index 4f92d9d..cecadce 100644 --- a/Vinceto/src/D15/SmartWatch.java +++ b/Vinceto/src/D15/SmartWatch.java @@ -1,35 +1,80 @@ package D15; + import java.util.ArrayList; import java.util.List; + +/** + * La clase SmartWatch proporciona una aplicación que filtra y calcula + * el promedio de los pasos dados como argumentos de línea de comandos. + */ public class SmartWatch { + + /** + * El método principal que ejecuta la aplicación. + * Convierte los argumentos de línea de comandos en una lista de enteros, + * filtra los valores no válidos y luego calcula y muestra el promedio de los pasos. + * + * @param args Un arreglo de cadenas que representa los argumentos de línea de comandos. + */ public static void main(String[] args) { + // Inicializa una lista para almacenar los pasos dados como argumentos de línea de comandos List pasos = new ArrayList<>(); + + // Convierte cada argumento de cadena en un entero y lo agrega a la lista pasos for (String arg : args) { pasos.add(Integer.parseInt(arg)); } + + // Filtra los valores no válidos de la lista pasos List pasosFiltrados = clearSteps(pasos); + + // Calcula el promedio de los pasos filtrados double promedioPasos = promedio(pasosFiltrados); - System.out.println("Promedio de pasos : "+promedioPasos); + + // Muestra el promedio de pasos + System.out.println("Promedio de pasos: " + promedioPasos); } + /** + * Filtra una lista de pasos eliminando los valores fuera del rango [200, 100000]. + * + * @param pasos Una lista de enteros que representa los pasos. + * @return Una lista de enteros con los pasos filtrados. + */ public static List clearSteps(List pasos) { + // Inicializa una lista para almacenar los pasos filtrados List filtrados = new ArrayList<>(); + + // Itera a través de cada paso y agrega los que están dentro del rango válido a la lista filtrados for (int paso : pasos) { if (paso >= 200 && paso <= 100000) { filtrados.add(paso); - }else{ - System.out.println("valor descartado : "+paso); + } else { + // Muestra el valor descartado que no está en el rango válido + System.out.println("Valor descartado: " + paso); } } + + // Retorna la lista de pasos filtrados return filtrados; } + /** + * Calcula el promedio de una lista de enteros. + * + * @param pasos Una lista de enteros que representa los pasos. + * @return El promedio de los pasos como un valor de tipo double. + */ public static double promedio(List pasos) { int suma = 0; + + // Suma todos los valores de la lista pasos for (int paso : pasos) { suma += paso; - System.out.println("pasos a sumar : "+paso); + System.out.println("Pasos a sumar: " + paso); } + + // Retorna el promedio de los pasos. Si la lista está vacía, retorna 0. return pasos.size() == 0 ? 0 : (double) suma / pasos.size(); } } diff --git a/Vinceto/src/D15/Visitas.java b/Vinceto/src/D15/Visitas.java index 53d6ea4..3e5b834 100644 --- a/Vinceto/src/D15/Visitas.java +++ b/Vinceto/src/D15/Visitas.java @@ -1,21 +1,50 @@ package D15; - +/** + * La clase Visitas proporciona una aplicación que calcula y muestra + * el promedio de visitas dadas como argumentos de línea de comandos. + */ public class Visitas { + + /** + * El método principal que ejecuta la aplicación. + * Convierte los argumentos de línea de comandos en un arreglo de enteros, + * imprime cada valor, y luego calcula y muestra el promedio de las visitas. + * + * @param args Un arreglo de cadenas que representa los argumentos de línea de comandos. + */ public static void main(String[] args) { + // Inicializa un arreglo de enteros del mismo tamaño que los argumentos de línea de comandos int[] visitas = new int[args.length]; + + // Convierte cada argumento de cadena en un entero y lo guarda en el arreglo visitas for (int i = 0; i < args.length; i++) { visitas[i] = Integer.parseInt(args[i]); - System.out.println("visita "+i+" : "+visitas[i]); + System.out.println("visita " + i + " : " + visitas[i]); } + + // Calcula el promedio de las visitas double promedioVisitas = promedio(visitas); - System.out.println("El promedio de visitas es: "+promedioVisitas); + + // Muestra el promedio de visitas + System.out.println("El promedio de visitas es: " + promedioVisitas); } + /** + * Calcula el promedio de un arreglo de enteros. + * + * @param visitas Un arreglo de enteros que representa las visitas. + * @return El promedio de las visitas como un valor de tipo double. + */ public static double promedio(int[] visitas) { int suma = 0; + + // Suma todos los valores del arreglo visitas for (int visita : visitas) { suma += visita; } + + // Devuelve el promedio de las visitas. Si el arreglo está vacío, devuelve 0. return visitas.length == 0 ? 0 : (double) suma / visitas.length; } } +