├── .gitignore ├── Arrays ├── Ejercicio1.java ├── Ejercicio2.java ├── Ejercicio3.java ├── Ejercicio4.java └── Enunciados.md ├── Exercises ├── MatrizEnEspiral.java ├── SentidoDeLaVida.java ├── SumaDeEnteros.java └── TablasConSumas.java ├── Lambda ├── ExpresionesFuncionales │ ├── BusquedaEnCadena │ │ ├── CadenaTest.java │ │ └── Main.java │ ├── NumeroMayor │ │ ├── Main.java │ │ └── TestNum.java │ ├── Operadores │ │ ├── Main.java │ │ └── NumTest.java │ └── ParametrosGenericos │ │ ├── TestGeneric.java │ │ └── main4.java └── ExpresionesFuncionalesEnBloque │ ├── Main.java │ └── TestPrimos.java ├── Matrix ├── Ejercicio1.java ├── Ejercicio2.java ├── Ejercicio3.java ├── Ejercicio4.java ├── Ejercicio5 │ ├── Ejercicio5.java │ └── fichero1.txt └── Enunciados.md ├── OOP ├── Constructores │ ├── Auto.java │ └── Main.java ├── Encapsulamiento │ ├── AutoMovil.java │ └── Main.java ├── Herencia │ ├── Vampiro │ │ ├── Dracula.java │ │ ├── Main.java │ │ └── Vampiro.java │ └── Zombie │ │ ├── Main.java │ │ ├── Nemesis.java │ │ └── Zombie.java └── Practice │ ├── Ejer1 │ ├── Alumno.java │ └── Asignatura.java │ ├── Orni │ ├── Anfibio.java │ ├── Main.java │ ├── Mamifero.java │ ├── Ornitorrinco.java │ ├── Oviparo.java │ └── Venenoso.java │ └── Trabajo_practico_POO.pdf ├── README.md ├── Regex ├── Validate_Date.java ├── Validate_Email.java ├── Validate_IP.java ├── Validate_Pwd.java └── Validate_Twitter.java ├── Riwence ├── day_1 │ ├── ATM │ │ ├── ATM.pdf │ │ ├── ATMachine.java │ │ ├── BankAccount.java │ │ ├── Main.java │ │ └── UserInterface.java │ └── FitProGym │ │ ├── GymQuoteService.java │ │ ├── Main.java │ │ ├── Member.java │ │ ├── PriceCalculator.java │ │ └── README.md └── day_2 │ ├── investigation │ ├── Main.java │ └── README.md │ └── loops │ ├── Main.java │ └── README.md └── VariableArguments └── ArgumentosVariables.java /.gitignore: -------------------------------------------------------------------------------- 1 | ### IntelliJ IDEA ### 2 | out/ 3 | !**/src/main/**/out/ 4 | !**/src/test/**/out/ 5 | 6 | ### Eclipse ### 7 | .apt_generated 8 | .classpath 9 | .factorypath 10 | .project 11 | .settings 12 | .springBeans 13 | .sts4-cache 14 | bin/ 15 | !**/src/main/**/bin/ 16 | !**/src/test/**/bin/ 17 | 18 | ### NetBeans ### 19 | /nbproject/private/ 20 | /nbbuild/ 21 | /dist/ 22 | /nbdist/ 23 | /.nb-gradle/ 24 | 25 | ### VS Code ### 26 | .vscode/ 27 | 28 | ### Mac OS ### 29 | .DS_Store -------------------------------------------------------------------------------- /Arrays/Ejercicio1.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class Ejercicio1 { 4 | public static void main(String[] args) { 5 | 6 | //Se crea El Array 7 | int[] numeros = new int[100]; 8 | 9 | //Se recorre y se le asignan los valores 10 | for (int i = 0; i < numeros.length; i++) { 11 | numeros[i] = i + 1; 12 | //Se imprimen los datos 13 | System.out.println(numeros[i]); 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Arrays/Ejercicio2.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class Ejercicio2 { 4 | public static void main(String[] args) { 5 | 6 | //Se crea el Array 7 | int[] numeros = new int[100]; 8 | 9 | //Declaro las variables necesarias 10 | int suma = 0; 11 | double media; 12 | 13 | //Recorro el array, se asignan los valores y se suman los numeros 14 | for (int i = 0; i < numeros.length; i++) { 15 | numeros[i] = i + 1; 16 | suma += numeros[i]; 17 | } 18 | 19 | //imprimo la suma, se calcula la media y se imprime 20 | System.out.println("La suma es: " + suma); 21 | 22 | media = (double) suma / numeros.length; 23 | System.out.println("La media es: " + media); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /Arrays/Ejercicio3.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Ejercicio3 { 6 | public static void main(String[] args) { 7 | 8 | Scanner sc = new Scanner(System.in); 9 | 10 | //Se pide la longitud 11 | System.out.println("Inserte una longitud: "); 12 | int longitud = sc.nextInt(); 13 | 14 | //Creo un array con esa longitud 15 | int[] numeros = new int[longitud]; 16 | 17 | int num; 18 | 19 | //Se recorre el array 20 | for (int i = 0; i < numeros.length; i++) { 21 | System.out.println("Inserte un numero para la posicion " + i); 22 | 23 | do { 24 | 25 | //Se pide el numero para la pisicion especifica 26 | num = sc.nextInt(); 27 | 28 | if (!(num >= 0 && num <= 10)) { 29 | System.out.println("Error. Solo numeros desde el 0 al 10" + 30 | "Inserte un numero para la posicion " + i); 31 | } 32 | } while (!(num >= 0 && num <= 10)); 33 | 34 | //Se asigna el valor, ya que el numero pasa los parametros 35 | numeros[i] = num; 36 | 37 | } 38 | //Se imprimen los datos ingresados por el usuario 39 | System.out.println("Estos son los numeros elegidos por el usuario: "); 40 | for (int i : numeros) { 41 | System.out.print(i + "|"); 42 | } 43 | 44 | } 45 | } 46 | 47 | -------------------------------------------------------------------------------- /Arrays/Ejercicio4.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Ejercicio4 { 6 | public static void main(String[] args) { 7 | 8 | 9 | Scanner sn = new Scanner(System.in); 10 | 11 | //Se pide la longitud 12 | System.out.println("Inserte una longitud"); 13 | int longitud = sn.nextInt(); 14 | 15 | //Creo un array con esa longitud 16 | int[] numeros = new int[longitud]; 17 | 18 | //Se recorre el array y se asignan los valores con la funcion para generar numeros aleatorios 19 | for (int i = 0; i < numeros.length; i++) { 20 | numeros[i] = generaNumeroAleatorio(0, 10); 21 | System.out.println("En la posicion " + i + " esta el valor: " + numeros[i]); 22 | } 23 | 24 | } 25 | 26 | //Función para generar números aleatorios con un rango específico 27 | public static int generaNumeroAleatorio(int minimo, int maximo) { 28 | 29 | return (int) Math.floor(Math.random() * (minimo - (maximo + 1)) + (maximo + 1)); 30 | 31 | } 32 | } -------------------------------------------------------------------------------- /Arrays/Enunciados.md: -------------------------------------------------------------------------------- 1 | Ejercicio 1: 2 | Crea un array que contenga los numeros del 1 al 100. Muestralos por pantalla. 3 | 4 | 5 | Ejercicio 2: 6 | Con el array creado anteriormente, calcula la suma y la media de todos sus valores. 7 | 8 | 9 | Ejercicio 3: 10 | Crea un array de una longitud que determine el usuario y que le permita insertar numeros entre 0 y 10 11 | 12 | 13 | Ejercicio 4: 14 | Crea un array insertando números aleatorios entre 0 y 10. Muestralos por pantalla. 15 | -------------------------------------------------------------------------------- /Exercises/MatrizEnEspiral.java: -------------------------------------------------------------------------------- 1 | package Exercises;/*Se desea llenar una matriz cuadrada de n x n, con los valores de 1 a n x n ordenandolos de forma de 2 | espiral dentro de la matriz 3 | */ 4 | 5 | //CODIGO 6 | 7 | import java.util.Scanner; 8 | 9 | public class MatrizEnEspiral { 10 | public static void main(String[] args) { 11 | Scanner sc = new Scanner(System.in); 12 | System.out.println("Digite el valor maximo del espiral: "); 13 | int n = sc.nextInt(); 14 | String[][] matriz = new String[n][n]; 15 | int a = 0; 16 | int b = n - 1; 17 | int valor = 1; 18 | 19 | for (int j = 0; j < matriz.length; j++) { 20 | //Se Llena la fila superior 21 | for (int i = a; i <= b; i++) { 22 | matriz[a][i] = valor++ + "|"; 23 | } 24 | //Se llena la columna del extremo derecho 25 | for (int i = a + 1; i <= b; i++) { 26 | matriz[i][b] = valor++ + "|"; 27 | } 28 | //Se llena la fila inferior de derecha a izquierda 29 | for (int i = b - 1; i >= a; i--) { 30 | matriz[b][i] = valor++ + "|"; 31 | } 32 | //Se llega la columna del extremo izquierdo de abajo hacia arriba 33 | for (int i = b - 1; i >= a + 1; i--) { 34 | matriz[i][a] = valor++ + "|"; 35 | } 36 | a++; 37 | b--; 38 | } 39 | //Se muestra la matriz 40 | for (String[] strings : matriz) {//Se usa for mejorado para imprimir la matriz 41 | for (String string : strings) { 42 | System.out.print(string); 43 | } 44 | System.out.println(); 45 | } 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /Exercises/SentidoDeLaVida.java: -------------------------------------------------------------------------------- 1 | package Exercises;/*Su programa es utilizar el enfoque de fuerza bruta para encontrar la respuesta a la vida, el universo y 2 | todo. Más precisamente... reescribir números pequeños de entrada a salida. Deje de procesar la entrada después de leer 3 | el número 42. Todos los números en la entrada son enteros de uno o dos dígitos. 4 | */ 5 | 6 | import java.util.Scanner; 7 | 8 | public class SentidoDeLaVida { 9 | public static void main(String[] args) { 10 | Scanner sc = new Scanner(System.in); 11 | String cadena = ""; 12 | int valor = 0; 13 | 14 | do { 15 | valor = sc.nextInt(); 16 | cadena += valor + ","; 17 | 18 | } while (valor != 42); 19 | 20 | String[] arreglo = cadena.split(","); 21 | 22 | for (int i = 0; i < arreglo.length - 1; i++) { 23 | System.out.println(arreglo[i]); 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /Exercises/SumaDeEnteros.java: -------------------------------------------------------------------------------- 1 | package Exercises;/*Dados dos números naturales (ambos no mayores de 200), cada número en una línea separada, imprima la suma 2 | ellos. 3 | */ 4 | import java.util.Scanner; 5 | public class SumaDeEnteros { 6 | 7 | public static void main(String[] args) { 8 | int a,b,suma; 9 | 10 | Scanner sc = new Scanner(System.in); 11 | //Entrada 12 | a = sc.nextInt(); 13 | b = sc.nextInt(); 14 | //Proceso 15 | suma = a+b; 16 | 17 | //Salida 18 | System.out.println(suma); 19 | 20 | } 21 | } -------------------------------------------------------------------------------- /Exercises/TablasConSumas.java: -------------------------------------------------------------------------------- 1 | package Exercises; 2 | 3 | public class TablasConSumas { 4 | 5 | 6 | public static void main(String[] args) { 7 | 8 | for (int tabla = 1; tabla <= 10; tabla++) { 9 | int resultado = 0; 10 | System.out.println("\nTabla del " + tabla + "\n"); 11 | for (int numero = 1; numero <= 10; numero++) { 12 | resultado += tabla; 13 | System.out.println(tabla + " x " + numero + " = " + resultado); 14 | } 15 | } 16 | } 17 | } -------------------------------------------------------------------------------- /Lambda/ExpresionesFuncionales/BusquedaEnCadena/CadenaTest.java: -------------------------------------------------------------------------------- 1 | package Lambda.ExpresionesFuncionales.BusquedaEnCadena; 2 | 3 | public interface CadenaTest { 4 | boolean test(String s1, String s2); 5 | 6 | } 7 | -------------------------------------------------------------------------------- /Lambda/ExpresionesFuncionales/BusquedaEnCadena/Main.java: -------------------------------------------------------------------------------- 1 | package Lambda.ExpresionesFuncionales.BusquedaEnCadena; 2 | 3 | public class Main { 4 | public static void main(String[] args) { 5 | 6 | CadenaTest t = (cad1, cad2) -> (cad1.indexOf(cad2) != -1); 7 | if (t.test("Hola", "la")) 8 | System.out.println("La cadena contiene la subcadena"); 9 | else 10 | System.out.println("La cadena no contiene la subcadena"); 11 | } 12 | } -------------------------------------------------------------------------------- /Lambda/ExpresionesFuncionales/NumeroMayor/Main.java: -------------------------------------------------------------------------------- 1 | package Lambda.ExpresionesFuncionales.NumeroMayor; 2 | 3 | public class Main { 4 | public static void main(String[] args) { 5 | TestNum t = (a, b) -> (a > b); 6 | if (t.test(10, 12)) 7 | System.out.println("10 es mayor que 12"); 8 | else 9 | System.out.println("10 no es mayor que 12"); 10 | 11 | TestNum t2 = (a,b) -> (a % b == 0); 12 | if (t2.test(10, 2)) 13 | System.out.println("A es factor de B"); 14 | else 15 | System.out.println("A no es factor de B"); 16 | } 17 | } -------------------------------------------------------------------------------- /Lambda/ExpresionesFuncionales/NumeroMayor/TestNum.java: -------------------------------------------------------------------------------- 1 | package Lambda.ExpresionesFuncionales.NumeroMayor; 2 | 3 | public interface TestNum { 4 | boolean test(int n1, int n2); 5 | } 6 | -------------------------------------------------------------------------------- /Lambda/ExpresionesFuncionales/Operadores/Main.java: -------------------------------------------------------------------------------- 1 | package Lambda.ExpresionesFuncionales.Operadores; 2 | 3 | public class Main { 4 | public static void main(String[] args) { 5 | NumTest t = (a, b) -> (a + b); 6 | System.out.println("Suma: " + t.test(10, 12)); 7 | 8 | NumTest t2 = (a,b) -> (a - b); 9 | System.out.println("Resta: " + t2.test(10, 12)); 10 | 11 | NumTest t3 = (a,b) -> (a * b); 12 | System.out.println("Multiplicacion: " + t3.test(10, 12)); 13 | 14 | NumTest t4 = (a,b) -> ( b != 0? a/b : 0); 15 | System.out.println("Division: " + t4.test(10, 12)); 16 | 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Lambda/ExpresionesFuncionales/Operadores/NumTest.java: -------------------------------------------------------------------------------- 1 | package Lambda.ExpresionesFuncionales.Operadores; 2 | 3 | public interface NumTest { 4 | double test(int n1, int n2); 5 | } 6 | -------------------------------------------------------------------------------- /Lambda/ExpresionesFuncionales/ParametrosGenericos/TestGeneric.java: -------------------------------------------------------------------------------- 1 | package Lambda.ExpresionesFuncionales.ParametrosGenericos; 2 | 3 | public interface TestGeneric { 4 | boolean test(T t1, T t2); 5 | } 6 | -------------------------------------------------------------------------------- /Lambda/ExpresionesFuncionales/ParametrosGenericos/main4.java: -------------------------------------------------------------------------------- 1 | package Lambda.ExpresionesFuncionales.ParametrosGenericos; 2 | 3 | public class main4 { 4 | public static void main(String[] args) { 5 | TestGeneric t = (a,b) -> (a % b == 0); 6 | if (t.test(10, 2)) 7 | System.out.println("A es factor de B"); 8 | else 9 | System.out.println("A no es factor de B"); 10 | 11 | TestGeneric t2 = (a,b) -> a.indexOf(b) != -1; 12 | if (t2.test("Hola", "la")) 13 | System.out.println("La cadena contiene la subcadena"); 14 | else 15 | System.out.println("La cadena no contiene la subcadena"); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Lambda/ExpresionesFuncionalesEnBloque/Main.java: -------------------------------------------------------------------------------- 1 | package Lambda.ExpresionesFuncionalesEnBloque; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class Main { 6 | public static void main(String[] args) { 7 | 8 | TestPrimos t = (a, b) -> { 9 | if (a == 1 || a == 0){ 10 | a = 2; 11 | } 12 | 13 | ArrayList primos = new ArrayList<>(); 14 | for (int i = a; i <= b; i++) { 15 | boolean esPrimo = true; 16 | for (int j = 2; j < Math.sqrt(i); j++) { 17 | if (i % j == 0) { 18 | esPrimo = false; 19 | break; 20 | } 21 | } 22 | if (esPrimo) 23 | primos.add(i); 24 | } 25 | return primos; 26 | 27 | }; 28 | System.out.println("Números Primos: " + t.test(1, 100)); 29 | } 30 | } 31 | 32 | -------------------------------------------------------------------------------- /Lambda/ExpresionesFuncionalesEnBloque/TestPrimos.java: -------------------------------------------------------------------------------- 1 | package Lambda.ExpresionesFuncionalesEnBloque; 2 | 3 | import java.util.ArrayList; 4 | 5 | public interface TestPrimos { 6 | 7 | ArrayList test(int n1, int n2); 8 | } 9 | -------------------------------------------------------------------------------- /Matrix/Ejercicio1.java: -------------------------------------------------------------------------------- 1 | package Matrix; 2 | 3 | public class Ejercicio1 { 4 | 5 | public static void main(String[] args) { 6 | int[][] matriz = new int[3][3]; 7 | 8 | for (int i = 0; i < matriz.length; i++) { 9 | for (int j = 0; j < matriz.length; j++) { 10 | matriz[i][j] = (i * matriz.length) + j + 1; 11 | System.out.print(matriz[i][j] + "|"); 12 | } 13 | System.out.println(); 14 | } 15 | 16 | } 17 | } 18 | 19 | -------------------------------------------------------------------------------- /Matrix/Ejercicio2.java: -------------------------------------------------------------------------------- 1 | package Matrix; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Ejercicio2 { 6 | public static void main(String[] args) { 7 | 8 | Scanner sc = new Scanner(System.in); 9 | System.out.println("Ingrese un numero de columnas: "); 10 | int c = sc.nextInt();//Se ingresa la longitud de las columnas 11 | 12 | int[][] matriz = new int[5][c];//Se define la matriz 13 | 14 | //Se recorre la matriz 15 | for (int i = 0; i < matriz.length; i++) { 16 | for (c = 0; c < matriz[0].length; c++) { 17 | matriz[i][c] = generaNumAleatorio(0, 9); 18 | System.out.print(matriz[i][c] + "|");//Se imprime la matriz 19 | } 20 | System.out.println(); 21 | } 22 | } 23 | 24 | //Función para generar números aleatorios en un rango específico 25 | public static int generaNumAleatorio(int minimo, int maximo) { 26 | 27 | return (int) Math.floor(Math.random() * (minimo - (maximo + 1)) + (maximo + 1)); 28 | } 29 | } 30 | 31 | -------------------------------------------------------------------------------- /Matrix/Ejercicio3.java: -------------------------------------------------------------------------------- 1 | package Matrix; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Ejercicio3 { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Ingrese la longitud de la matriz: "); 9 | int longitud = sc.nextInt();//Se ingresa la longitud 10 | 11 | int[][] matriz1 = new int[longitud][longitud]; 12 | int[][] matriz2 = new int[longitud][longitud];//Se definen las matrices 13 | int[][] resultado = new int[longitud][longitud]; 14 | 15 | for (int i = 0; i < matriz1.length; i++) {//Se recorren las matrices para darle sus valores 16 | for (int j = 0; j < matriz1[0].length; j++) { 17 | System.out.println("Escriba el valor para la fila " + i + " y la columna " + j + " de la matriz 1"); 18 | matriz1[i][j] = sc.nextInt(); 19 | 20 | System.out.println("Escriba el valor para la fila " + i + " y la columna " + j + " de la matriz 2"); 21 | matriz2[i][j] = sc.nextInt(); 22 | 23 | resultado[i][j] = matriz1[i][j] + matriz2[i][j];//Se le dan los valores de la suma a la matriz resultado 24 | } 25 | } 26 | //Se imprimen las matrices 27 | System.out.println("Matriz 1"); 28 | imprimirMatriz(matriz1); 29 | System.out.println(); 30 | 31 | System.out.println("Matriz 2"); 32 | imprimirMatriz(matriz2); 33 | System.out.println(); 34 | 35 | System.out.println("Matriz resultante"); 36 | imprimirMatriz(resultado); 37 | 38 | 39 | } 40 | 41 | //Funcion para imprimir matrices 42 | public static void imprimirMatriz(int[][] matriz) { 43 | for (int[] ints : matriz) { 44 | for (int j = 0; j < matriz[0].length; j++) { 45 | 46 | System.out.print(ints[j] + "|"); 47 | } 48 | System.out.println(""); 49 | } 50 | } 51 | } -------------------------------------------------------------------------------- /Matrix/Ejercicio4.java: -------------------------------------------------------------------------------- 1 | package Matrix; 2 | 3 | public class Ejercicio4 { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[][] m = { 8 | {0, 0, 0, 0}, 9 | {0, 0, 0, 0}, 10 | {0, 0, 0, 0}, 11 | {0, 0, 0, 0} 12 | }; 13 | 14 | int resultado[][] = adyacentesA(m.length, m[0].length, 1, 1); 15 | 16 | for (int i = 0; i < resultado.length; i++) { 17 | for (int j = 0; j < resultado[0].length; j++) { 18 | System.out.print(resultado[i][j] + " "); 19 | } 20 | System.out.println(""); 21 | } 22 | 23 | } 24 | 25 | public static int[][] adyacentesA(int filas, int columnas, int filaOrigen, int columnaOrigen) { 26 | 27 | if (!(filaOrigen >= 0 && filaOrigen <= (filas - 1) && columnaOrigen >= 0 && columnaOrigen <= (columnas - 1))) { 28 | return null; 29 | } 30 | 31 | int numPosiciones; 32 | 33 | if (filaOrigen == 0 || filaOrigen == (filas - 1)) { 34 | if (columnaOrigen == 0 || columnaOrigen == (columnas - 1)) { 35 | numPosiciones = 3; 36 | } else { 37 | numPosiciones = 5; 38 | } 39 | } else { 40 | if (columnaOrigen == 0 || columnaOrigen == (columnas - 1)) { 41 | numPosiciones = 5; 42 | } else { 43 | numPosiciones = 8; 44 | } 45 | } 46 | 47 | int posiciones[][] = new int[numPosiciones][2]; 48 | 49 | int indicePosicion = 0; 50 | for (int i = -1; i <= 1; i++) { 51 | for (int j = -1; j <= 1; j++) { 52 | 53 | if ((i != 0 || j != 0) 54 | && (filaOrigen + i) >= 0 55 | && (filaOrigen + i) <= (filas - 1) 56 | && (columnaOrigen + j) >= 0 57 | && (columnaOrigen + j) <= (columnas - 1)) { 58 | posiciones[indicePosicion][0] = filaOrigen + i; 59 | posiciones[indicePosicion][1] = columnaOrigen + j; 60 | indicePosicion++; 61 | } 62 | 63 | } 64 | } 65 | 66 | 67 | return posiciones; 68 | } 69 | 70 | 71 | } -------------------------------------------------------------------------------- /Matrix/Ejercicio5/Ejercicio5.java: -------------------------------------------------------------------------------- 1 | package Matrix.Ejercicio5; 2 | 3 | import java.io.File; 4 | import java.io.FileNotFoundException; 5 | import java.io.PrintWriter; 6 | import java.util.Scanner; 7 | import java.util.logging.Level; 8 | import java.util.logging.Logger; 9 | 10 | public class Ejercicio5 { 11 | 12 | public static void main(String[] args) { 13 | 14 | //Pido el nombre de un fichero 15 | File f = pedirNombreFichero(); 16 | 17 | //Si no es nulo, seguimos 18 | if (f != null) { 19 | 20 | //leo el fichero y paso los datos a una matriz 21 | int[][] matriz = leerFichero(f); 22 | 23 | //Si no es nulo seigo 24 | if (matriz != null) { 25 | 26 | //Si la matriz es simetrica lo hacemos de una manera y sino de otra 27 | if (esMatrizSimetrica(matriz)) { 28 | trasponerMatrizSimetrica(matriz); 29 | } else { 30 | matriz = trasponerMatrizNoSimetrica(matriz); 31 | } 32 | 33 | //Guardo el fichero donde se guardara 34 | File f_guardar = new File((f.getName().split("\\."))[0] + "_T.txt"); 35 | 36 | //guardo la matriz en el fichero 37 | guardarMatrizFichero(f_guardar, matriz); 38 | 39 | System.out.println("Fichero guardado"); 40 | 41 | } else { 42 | System.out.println("Error, comprueba el fichero"); 43 | } 44 | 45 | } else { 46 | System.out.println("El fichero no existe"); 47 | } 48 | 49 | } 50 | 51 | /** 52 | * Pide el nombre del fichero 53 | * 54 | * @return 55 | */ 56 | public static File pedirNombreFichero() { 57 | 58 | Scanner sn = new Scanner(System.in); 59 | 60 | System.out.println("Escribe el nombre de un fichero"); 61 | String nombre = sn.next(); 62 | 63 | File f = new File(nombre); 64 | 65 | //si exsite el fichero, lo devuelvo 66 | if (f.exists()) { 67 | return f; 68 | } else { 69 | return null; 70 | } 71 | 72 | } 73 | 74 | /** 75 | * @param f 76 | * @return 77 | */ 78 | public static int[][] leerFichero(File f) { 79 | 80 | int[][] matriz = null; 81 | try { 82 | Scanner sn = new Scanner(f); 83 | 84 | int filas = 0, columnas = 0, contador = 0; 85 | //Mientras haya numeros continuo 86 | while (sn.hasNextInt()) { 87 | 88 | //Segun el contador, hago una u otra 89 | switch (contador) { 90 | case 0: 91 | //Cojo las filas 92 | filas = sn.nextInt(); 93 | break; 94 | case 1: 95 | //Cojo las columnas y creo la matriz 96 | columnas = sn.nextInt(); 97 | matriz = new int[filas][columnas]; 98 | 99 | break; 100 | default: 101 | //obtengo la fila y la columna 102 | matriz[(contador - 2) / columnas][(contador - 2) % columnas] = sn.nextInt(); 103 | } 104 | 105 | contador++; 106 | } 107 | 108 | } catch (FileNotFoundException ex) { 109 | Logger.getLogger(Ejercicio5.class.getName()).log(Level.SEVERE, null, ex); 110 | } 111 | 112 | return matriz; 113 | 114 | } 115 | 116 | /** 117 | * Indico si es o no simetrica la matriz 118 | * 119 | * @param matriz 120 | * @return 121 | */ 122 | public static boolean esMatrizSimetrica(int[][] matriz) { 123 | 124 | return matriz.length == matriz[0].length; 125 | 126 | } 127 | 128 | /** 129 | * Traspongo una matriz 130 | * 131 | * @param matriz 132 | */ 133 | public static void trasponerMatrizSimetrica(int[][] matriz) { 134 | 135 | //Creo una matriz de booleanos para indicar los indices que se hicieron cambios 136 | boolean[][] cambios = new boolean[matriz.length][matriz[0].length]; 137 | for (int i = 0; i < matriz.length; i++) { 138 | for (int j = 0; j < matriz[0].length; j++) { 139 | //Sino hay continuo 140 | if (!cambios[i][j]) { 141 | intercambio(matriz, i, j); 142 | //marco el cambio 143 | cambios[i][j] = true; 144 | cambios[j][i] = true; 145 | } 146 | } 147 | } 148 | 149 | } 150 | 151 | /** 152 | * Trapongo una matriz no simetrica 153 | * 154 | * @param matriz 155 | * @return 156 | */ 157 | public static int[][] trasponerMatrizNoSimetrica(int[][] matriz) { 158 | 159 | //Creo una nueva matriz 160 | int[][] matrizTraspuesta = new int[matriz[0].length][matriz.length]; 161 | for (int i = 0; i < matriz.length; i++) { 162 | for (int j = 0; j < matriz[0].length; j++) { 163 | intercambio(matriz, matrizTraspuesta, i, j); 164 | } 165 | } 166 | 167 | return matrizTraspuesta; 168 | 169 | } 170 | 171 | /** 172 | * Intercambia una posicion por otra 173 | * 174 | * @param matriz 175 | * @param i 176 | * @param j 177 | */ 178 | public static void intercambio(int[][] matriz, int i, int j) { 179 | 180 | int aux = matriz[i][j]; 181 | matriz[i][j] = matriz[j][i]; 182 | matriz[j][i] = aux; 183 | 184 | } 185 | 186 | /** 187 | * Intercambio de valores en dos matrices 188 | * 189 | * @param matriz 190 | * @param matrizT 191 | * @param i 192 | * @param j 193 | */ 194 | public static void intercambio(int[][] matriz, int[][] matrizT, int i, int j) { 195 | 196 | matrizT[j][i] = matriz[i][j]; 197 | 198 | } 199 | 200 | /** 201 | * Guarda la matriz en un fichero 202 | * 203 | * @param f 204 | * @param matriz 205 | */ 206 | public static void guardarMatrizFichero(File f, int[][] matriz) { 207 | 208 | try { 209 | PrintWriter pw = new PrintWriter(f); 210 | 211 | //guardo las filas y columnas 212 | pw.print(matriz.length + " "); 213 | pw.print(matriz[0].length + " "); 214 | 215 | //Guardo los datos 216 | for (int i = 0; i < matriz.length; i++) { 217 | for (int j = 0; j < matriz[0].length; j++) { 218 | pw.print(matriz[i][j] + " "); 219 | } 220 | } 221 | 222 | pw.close(); 223 | 224 | } catch (FileNotFoundException ex) { 225 | Logger.getLogger(Ejercicio5.class.getName()).log(Level.SEVERE, null, ex); 226 | } 227 | 228 | } 229 | 230 | } 231 | -------------------------------------------------------------------------------- /Matrix/Ejercicio5/fichero1.txt: -------------------------------------------------------------------------------- 1 | 4 2 1 2 3 4 5 6 7 8 -------------------------------------------------------------------------------- /Matrix/Enunciados.md: -------------------------------------------------------------------------------- 1 | Ejercicio 1: 2 | Crear una matriz de 3x3 con los números del 1 al 9. Mostrar por pantalla, tal como aparece en la matriz 3 | 4 | 5 | Ejercicio 2: 6 | Crear una matriz de 5 filas y n columnas (se pide al usuario). Rellenarlo con números aleatorios entre 0 y 10. 7 | 8 | 9 | Ejercicio 3: 10 | Crear dos matrices de n x n y sumar sus valores, los resultados se deben almacenar en otra matriz. Los valores y la longitud, serán insertados por el usuario. Mostrar las matrices originales y el resultado. 11 | 12 | 13 | Ejercicio 4: 14 | Obtener las posiciones adyacentes de una matriz según una posición concreta. 15 | 16 | 17 | Ejercicio 5: 18 | Realizar un programa Java que genere una matriz de dos dimensiones de valores enteros a partir de los datos leídos 19 | de un fichero de texto, cuyo nombre se introducirá por teclado. 20 | 21 | Los dos primeros valores del fichero serán números enteros y definirán el número de filas y de columnas de la matriz. 22 | 23 | El programa debe indicar si la matriz leída es simétrica. 24 | 25 | Finalmente, tanto las dimensiones como los valores de la matriz traspuesta se guardarán en un fichero, 26 | cuyo nombre será el de la matriz original seguido de “_T”. 27 | 28 | Ejemplo de transponer: 29 | 30 | 1 2 3 1 4 7 31 | 4 5 6 = 2 5 8 32 | 7 8 9 3 6 9 33 | 34 | 35 | 1 2 3 4 1 5 36 | 5 6 7 8 = 2 6 37 | 3 7 38 | 4 8 39 | -------------------------------------------------------------------------------- /OOP/Constructores/Auto.java: -------------------------------------------------------------------------------- 1 | package OOP.Constructores; 2 | 3 | public class Auto { 4 | static private String marca, modelo, color; 5 | static private int cfuerza; //Caballos de fuerza del motor 6 | 7 | public Auto(String marca, String modelo, String color) { 8 | this.marca = marca; 9 | this.modelo = modelo; 10 | this.color = color; 11 | System.out.println("Se ha creado un objeto de la clase AutoMovil Marca: " + this.marca + " Modelo: " + this.modelo + " y es de color " + this.color); 12 | } 13 | 14 | public Auto(int cfuerza) { 15 | this.cfuerza = cfuerza; 16 | System.out.println("Se ha creado un objeto de la clase AutoMovil con " + this.cfuerza + " caballos de fuerza"); 17 | } 18 | 19 | //Metodos 20 | 21 | void arrancar() { 22 | System.out.println("-El vehiculo se Enciende.."); 23 | } 24 | 25 | String acelerar(int km) { 26 | km *= 3;//km =km *3 27 | 28 | return ("-El Vehiculo va a " + km + " km por hora.."); 29 | } 30 | 31 | String girar(int dir) { 32 | return (dir == 1 ? " Derecha.." : "Izquierda..");//Si la direccion es 1 se girara a la derecha, de lo contrario izquierda 33 | } 34 | 35 | void frenar() { 36 | System.out.println("-El vehiculo Frena.."); 37 | } 38 | 39 | void reversar() { 40 | System.out.println("-El vehiculo Retrocede.."); 41 | } 42 | 43 | 44 | } 45 | -------------------------------------------------------------------------------- /OOP/Constructores/Main.java: -------------------------------------------------------------------------------- 1 | package OOP.Constructores; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | Auto ferrari = new Auto("Ferrari", "296 GTB 2021", "Amarillo"); 10 | new Auto(800); 11 | Scanner sc = new Scanner(System.in); 12 | System.out.println("Ingrese los kilometros por hora: "); 13 | int km = sc.nextInt(); 14 | 15 | 16 | //Metodos 17 | System.out.println(); 18 | System.out.println("Los Metodos del Vehiculo son:"); 19 | System.out.println(); 20 | ferrari.arrancar(); 21 | System.out.println(ferrari.acelerar(km)); 22 | System.out.println("-El vehiculo esta girando a la:" + ferrari.girar(1)); 23 | ferrari.frenar(); 24 | ferrari.reversar(); 25 | } 26 | 27 | 28 | } -------------------------------------------------------------------------------- /OOP/Encapsulamiento/AutoMovil.java: -------------------------------------------------------------------------------- 1 | package OOP.Encapsulamiento; 2 | 3 | public class AutoMovil { 4 | 5 | private String marca, modelo; 6 | public AutoMovil(String marca, String modelo) { 7 | this.marca = marca; 8 | this.modelo = modelo; 9 | } 10 | 11 | public String getMarca() { 12 | return marca; 13 | } 14 | 15 | public void setMarca(String marca) { 16 | this.marca = marca; 17 | } 18 | 19 | public String getModelo() { 20 | return modelo; 21 | } 22 | 23 | public void setModelo(String modelo) { 24 | this.modelo = modelo; 25 | } 26 | 27 | @Override 28 | public String toString() { 29 | return "Soy un AutoMovil" + 30 | " mi marca es = " + marca + "" + 31 | " y mi modelo es = " + modelo + "" + 32 | ""; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /OOP/Encapsulamiento/Main.java: -------------------------------------------------------------------------------- 1 | package OOP.Encapsulamiento; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | AutoMovil obj = new AutoMovil("Ferrari", "2021"); 7 | 8 | System.out.println(obj); 9 | obj.setModelo("2022"); 10 | 11 | System.out.println("Se ha modificado el modelo a: "+obj.getModelo()); 12 | 13 | } 14 | 15 | 16 | } 17 | -------------------------------------------------------------------------------- /OOP/Herencia/Vampiro/Dracula.java: -------------------------------------------------------------------------------- 1 | package OOP.Herencia.Vampiro; 2 | 3 | public class Dracula extends Vampiro{ 4 | 5 | private String apellido; 6 | 7 | public Dracula(String nombre, int edad, String apellido) { 8 | super(nombre, edad); 9 | this.apellido=apellido; 10 | } 11 | 12 | public void hipnotizar(){ 13 | System.out.println("Tus ojos te pesan..ya eres mio.."); 14 | 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /OOP/Herencia/Vampiro/Main.java: -------------------------------------------------------------------------------- 1 | package OOP.Herencia.Vampiro; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | Dracula vladimir = new Dracula("Vladimir", 666, "Black"); 7 | vladimir.hipnotizar(); 8 | vladimir.morder(); 9 | vladimir.chuparSangre(); 10 | //vladimir.aguantarSol(); 11 | 12 | Vampiro edward = new Vampiro("Eduardo", 83); 13 | edward.morder(); 14 | edward.chuparSangre(); 15 | //edward.hipnotizar(); 16 | //edward.aguantarSol(); 17 | 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /OOP/Herencia/Vampiro/Vampiro.java: -------------------------------------------------------------------------------- 1 | package OOP.Herencia.Vampiro; 2 | 3 | public class Vampiro { 4 | private String nombre; 5 | private int edad; 6 | 7 | public Vampiro(String name, int age) { 8 | this.nombre = name; 9 | this.edad = age; 10 | } 11 | 12 | public void morder(){ 13 | System.out.println("Lleve lo suyo pa'.."); 14 | } 15 | 16 | void chuparSangre(){ 17 | System.out.println("Chimba de sangre pai.."); 18 | } 19 | private void aguantarSol(){ 20 | System.out.println("Sol, solecito, no me calientas ni un poquito"); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /OOP/Herencia/Zombie/Main.java: -------------------------------------------------------------------------------- 1 | package OOP.Herencia.Zombie; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | Nemesis nemesio = new Nemesis("nemesio", 2.20, "Azul"); 7 | nemesio.superFuerza(); 8 | nemesio.noSentirDolor(); 9 | nemesio.controlarZombies(); 10 | nemesio.latigoTentaculo(); 11 | //nemesio.comerCerebros(); 12 | 13 | Zombie chasqueador = new Zombie("amarillo",1.80); 14 | chasqueador.noSentirDolor(); 15 | chasqueador.superFuerza(); 16 | //chasqueador.controlarZombies(); 17 | //chasqueador.latigoTentaculo(); 18 | //chasqueador.comercerebros(); 19 | 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /OOP/Herencia/Zombie/Nemesis.java: -------------------------------------------------------------------------------- 1 | package OOP.Herencia.Zombie; 2 | 3 | public class Nemesis extends Zombie{ 4 | private String apellido; 5 | 6 | public Nemesis(String apellido, double altura, String color) { 7 | super(color, altura); 8 | this.apellido=apellido; 9 | } 10 | 11 | public void controlarZombies(){ 12 | System.out.println("Ya eres miooo.."); 13 | } 14 | 15 | public void latigoTentaculo(){ 16 | System.out.println("juapaa"); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /OOP/Herencia/Zombie/Zombie.java: -------------------------------------------------------------------------------- 1 | package OOP.Herencia.Zombie; 2 | 3 | public class Zombie { 4 | private String color; 5 | private double altura; 6 | 7 | public Zombie(String color, double altura) { 8 | this.color = color; 9 | this.altura = altura; 10 | } 11 | 12 | public void superFuerza(){ 13 | System.out.println("BLAA!!,BLA!..BlAAA!!.."); 14 | } 15 | void noSentirDolor(){ 16 | System.out.println("Hahaha.. Ni cosquillas.."); 17 | } 18 | private void comerCerebros(){ 19 | System.out.println("Rico..Rico.."); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /OOP/Practice/Ejer1/Alumno.java: -------------------------------------------------------------------------------- 1 | package OOP.Practice.Ejer1; 2 | 3 | public class Alumno { 4 | 5 | 6 | private String nombre; 7 | private int edad; 8 | private Asignatura[] asignaturas; 9 | 10 | public Alumno(String nombre, int edad) { 11 | this.nombre = nombre; 12 | this.edad = edad; 13 | asignaturas = new Asignatura[0]; 14 | } 15 | 16 | public void setNombre(String nombre) { 17 | this.nombre = nombre; 18 | } 19 | 20 | public String getNombre() { 21 | return nombre; 22 | } 23 | 24 | public void setEdad(int edad) { 25 | this.edad = edad; 26 | } 27 | 28 | public int getEdad() { 29 | return edad; 30 | } 31 | 32 | public double promedio() { 33 | double promedio = 0; 34 | for (Asignatura asignatura : asignaturas) { 35 | promedio += asignatura.getNota(); 36 | } 37 | return promedio / asignaturas.length; 38 | } 39 | 40 | public void agregarAsignatura(Asignatura asignatura) { 41 | //Pero hacer que si son mas de 4 asignaturas no se puede agregar mas 42 | if (asignaturas.length < 4) { 43 | Asignatura[] asignaturasTemp = new Asignatura[asignaturas.length + 1]; 44 | for (int i = 0; i < asignaturas.length; i++) { 45 | asignaturasTemp[i] = asignaturas[i]; 46 | } 47 | asignaturasTemp[asignaturas.length] = asignatura; 48 | asignaturas = asignaturasTemp; 49 | } else { 50 | System.out.println("No se puede agregar mas de 4 asignaturas para " + nombre); 51 | } 52 | 53 | } 54 | 55 | public static void main(String[] args) { 56 | //Generar 3 instancias de alumno con 4 asignaturas cada uno 57 | Alumno alumno1 = new Alumno("Juan", 20); 58 | alumno1.agregarAsignatura(new Asignatura("Matematicas", 3.5)); 59 | alumno1.agregarAsignatura(new Asignatura("Fisica", 5.0)); 60 | alumno1.agregarAsignatura(new Asignatura("Quimica", 3.0)); 61 | alumno1.agregarAsignatura(new Asignatura("Edu.fisica", 3.2)); 62 | alumno1.agregarAsignatura(new Asignatura("Programming", 3.0)); 63 | System.out.println("Nombre: " + alumno1.getNombre()); 64 | System.out.println("Edad: " + alumno1.getEdad()); 65 | System.out.println("Promedio: " + alumno1.promedio()); 66 | System.out.println("------------------------------------------"); 67 | for (Asignatura asignatura : alumno1.asignaturas) { 68 | System.out.println("Asignatura: " + asignatura.getNombre()); 69 | System.out.println("Nota: " + asignatura.getNota()); 70 | System.out.println("Estado: " + asignatura.estado()); 71 | System.out.println("------------------------------------------"); 72 | } 73 | System.out.println("------------------------------------------"); 74 | 75 | 76 | Alumno alumno2 = new Alumno("Pedro", 21); 77 | alumno2.agregarAsignatura(new Asignatura("Matematicas", 3.5)); 78 | alumno2.agregarAsignatura(new Asignatura("Fisica", 5.0)); 79 | alumno2.agregarAsignatura(new Asignatura("Quimica", 3.0)); 80 | System.out.println("Nombre: " + alumno2.getNombre()); 81 | System.out.println("Edad: " + alumno2.getEdad()); 82 | System.out.println("Promedio: " + alumno2.promedio()); 83 | System.out.println("------------------------------------------"); 84 | for (Asignatura asignatura : alumno2.asignaturas) { 85 | System.out.println("Asignatura: " + asignatura.getNombre()); 86 | System.out.println("Nota: " + asignatura.getNota()); 87 | System.out.println("Estado: " + asignatura.estado()); 88 | System.out.println("------------------------------------------"); 89 | } 90 | System.out.println("------------------------------------------"); 91 | 92 | 93 | Alumno alumno3 = new Alumno("Maria", 22); 94 | alumno3.agregarAsignatura(new Asignatura("Matematicas", 3.5)); 95 | alumno3.agregarAsignatura(new Asignatura("Fisica", 5.0)); 96 | alumno3.agregarAsignatura(new Asignatura("Quimica", 3.0)); 97 | System.out.println("Nombre: " + alumno3.getNombre()); 98 | System.out.println("Edad: " + alumno3.getEdad()); 99 | System.out.println("Promedio: " + alumno3.promedio()); 100 | System.out.println("------------------------------------------"); 101 | for (Asignatura asignatura : alumno3.asignaturas) { 102 | System.out.println("Asignatura: " + asignatura.getNombre()); 103 | System.out.println("Nota: " + asignatura.getNota()); 104 | System.out.println("Estado: " + asignatura.estado()); 105 | System.out.println("------------------------------------------"); 106 | 107 | } 108 | System.out.println("------------------------------------------"); 109 | 110 | 111 | } 112 | 113 | } 114 | -------------------------------------------------------------------------------- /OOP/Practice/Ejer1/Asignatura.java: -------------------------------------------------------------------------------- 1 | package OOP.Practice.Ejer1; 2 | 3 | public class Asignatura { 4 | private String nombre; 5 | private double nota; 6 | 7 | public Asignatura(String nombre, double nota) { 8 | this.nombre = nombre; 9 | this.nota = nota; 10 | } 11 | 12 | public void setNota(double nota) { 13 | this.nota = nota; 14 | } 15 | 16 | public double getNota() { 17 | return nota; 18 | } 19 | 20 | public String estado() { 21 | return nota >= 3.5 ? "Aprobado" : "Reprobado"; 22 | } 23 | 24 | public String getNombre() { 25 | return nombre; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /OOP/Practice/Orni/Anfibio.java: -------------------------------------------------------------------------------- 1 | package OOP.Practice.Orni; 2 | 3 | public interface Anfibio { 4 | void respirarBajoElAgua(); 5 | void respirarPulmonar(); 6 | } 7 | -------------------------------------------------------------------------------- /OOP/Practice/Orni/Main.java: -------------------------------------------------------------------------------- 1 | package OOP.Practice.Orni; 2 | 3 | public class Main { 4 | public static void main(String[] args) { 5 | 6 | Ornitorrinco orni = new Ornitorrinco(); 7 | 8 | System.out.println("El ornitorrinco pone " + orni.ponerHuevos() + " huevos."); 9 | orni.respirarBajoElAgua(); 10 | orni.respirarPulmonar(); 11 | orni.envenenar(); 12 | orni.amamantar(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /OOP/Practice/Orni/Mamifero.java: -------------------------------------------------------------------------------- 1 | package OOP.Practice.Orni; 2 | 3 | public abstract class Mamifero { 4 | abstract void amamantar(); 5 | } 6 | -------------------------------------------------------------------------------- /OOP/Practice/Orni/Ornitorrinco.java: -------------------------------------------------------------------------------- 1 | package OOP.Practice.Orni; 2 | 3 | public class Ornitorrinco extends Mamifero implements Anfibio, Oviparo, Venenoso { 4 | @Override 5 | public void amamantar() { 6 | System.out.println("Amamantando"); 7 | } 8 | 9 | @Override 10 | public void respirarBajoElAgua() { 11 | System.out.println("Respirando bajo el agua"); 12 | } 13 | 14 | @Override 15 | public void respirarPulmonar() { 16 | System.out.println("Respirando fuera del agua"); 17 | } 18 | 19 | @Override 20 | public int ponerHuevos() { 21 | return (int) (Math.random() * 10); 22 | } 23 | 24 | @Override 25 | public void envenenar() { 26 | System.out.println("Envenenando"); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /OOP/Practice/Orni/Oviparo.java: -------------------------------------------------------------------------------- 1 | package OOP.Practice.Orni; 2 | 3 | public interface Oviparo { 4 | int ponerHuevos(); 5 | } 6 | -------------------------------------------------------------------------------- /OOP/Practice/Orni/Venenoso.java: -------------------------------------------------------------------------------- 1 | package OOP.Practice.Orni; 2 | 3 | public interface Venenoso { 4 | void envenenar(); 5 | } 6 | -------------------------------------------------------------------------------- /OOP/Practice/Trabajo_practico_POO.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sam-SSD/Java/841038a747b95fb4b084f0a883383834cd530db7/OOP/Practice/Trabajo_practico_POO.pdf -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Java exercises 2 | Variety of exercises in Java language 3 | -------------------------------------------------------------------------------- /Regex/Validate_Date.java: -------------------------------------------------------------------------------- 1 | package Regex; 2 | 3 | public class Validate_Date { 4 | 5 | public static void main(String[] args) { 6 | 7 | String date = "22/05/2005"; 8 | String pattern = "(0?[1-9]|[12][0-9]|3[01])[- /.](0?[1-9]|1[012])[- /.](19|20)\\d\\d$"; 9 | 10 | if (date.matches(pattern)) { 11 | System.out.println("La fecha es válida"); 12 | } else { 13 | System.out.println("La fecha no es válida"); 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Regex/Validate_Email.java: -------------------------------------------------------------------------------- 1 | package Regex; 2 | 3 | public class Validate_Email { 4 | 5 | public static void main(String[] args) { 6 | 7 | String email = "Samuserna2005@gmail.com"; 8 | String pattern = "^[a-zA-Z0-9_-]+\\w[.]?[a-z0-9]+[@]\\w+[.]\\w{2,3}\\w$"; 9 | 10 | if (email.matches(pattern)) { 11 | System.out.println("El email es válido"); 12 | } else { 13 | System.out.println("El email no es válido"); 14 | } 15 | 16 | 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Regex/Validate_IP.java: -------------------------------------------------------------------------------- 1 | package Regex; 2 | 3 | public class Validate_IP { 4 | 5 | public static void main(String[] args) { 6 | 7 | String ip = "201.221.176.43"; 8 | String pattern = "(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})"; 9 | 10 | if (ip.matches(pattern)) { 11 | System.out.println("La IP es válida"); 12 | } else { 13 | System.out.println("La IP no es válida"); 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Regex/Validate_Pwd.java: -------------------------------------------------------------------------------- 1 | package Regex; 2 | 3 | public class Validate_Pwd { 4 | 5 | public static void main(String[] args) { 6 | 7 | String pwd = "Password1#"; 8 | 9 | String pattern = "^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[#?!@$%^&*-]).{8,}$"; 10 | 11 | if (pwd.matches(pattern)) { 12 | System.out.println("La contraseña es segura"); 13 | } else { 14 | System.out.println("La contraseña no es segura"); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Regex/Validate_Twitter.java: -------------------------------------------------------------------------------- 1 | package Regex; 2 | 3 | public class Validate_Twitter { 4 | 5 | public static void main(String[] args) { 6 | System.out.println(validarUsuarioTwitter("@samlsd_")); 7 | System.out.println(validarUsuarioTwitter("@burigang")); 8 | System.out.println(validarUsuarioTwitter("@samlsd_@samlsd_@samlsd_@samlsd_")); 9 | System.out.println(validarUsuarioTwitter("@")); 10 | } 11 | 12 | 13 | public static String validarUsuarioTwitter(String usuario) { 14 | String patron = "^@([A-Za-z0-9_-]){1,30}$"; 15 | 16 | if (usuario.matches(patron)) { 17 | return "El usuario es válido"; 18 | } else { 19 | return "El usuario no es válido"; 20 | } 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /Riwence/day_1/ATM/ATM.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sam-SSD/Java/841038a747b95fb4b084f0a883383834cd530db7/Riwence/day_1/ATM/ATM.pdf -------------------------------------------------------------------------------- /Riwence/day_1/ATM/ATMachine.java: -------------------------------------------------------------------------------- 1 | package Riwence.day_1.ATM; 2 | 3 | public class ATMachine { 4 | private final BankAccount account; 5 | private final UserInterface ui; 6 | 7 | public ATMachine() { 8 | this.account = new BankAccount(1000000.0); // Initial balance $1,000,000 COP 9 | this.ui = new UserInterface(); 10 | } 11 | 12 | public void run() { 13 | ui.showWelcome(); 14 | 15 | boolean continueRunning = true; 16 | while (continueRunning) { 17 | ui.showMenu(); 18 | int option = ui.readOption(); 19 | 20 | switch (option) { 21 | case 1: 22 | checkBalance(); 23 | break; 24 | case 2: 25 | depositMoney(); 26 | break; 27 | case 3: 28 | withdrawMoney(); 29 | break; 30 | case 4: 31 | continueRunning = false; 32 | showFarewell(); 33 | break; 34 | case 5: 35 | cashAdvance(); 36 | break; 37 | default: 38 | ui.showMessage("Invalid option. Please select an option from 1 to 5."); 39 | } 40 | 41 | checkDebtorStatus(); 42 | ui.showBlankLine(); 43 | } 44 | 45 | ui.close(); 46 | } 47 | 48 | private void checkBalance() { 49 | ui.showTitle("BALANCE INQUIRY"); 50 | ui.showMessage("Your current balance is: " + account.getFormattedBalance()); 51 | } 52 | 53 | private void depositMoney() { 54 | ui.showTitle("MONEY DEPOSIT"); 55 | double amount = ui.readAmount("Enter the amount to deposit: $"); 56 | 57 | if (amount == -1) { 58 | ui.showMessage("Invalid amount. Please enter a valid number."); 59 | return; 60 | } 61 | 62 | if (account.deposit(amount)) { 63 | ui.showMessage("Deposit successful."); 64 | ui.showMessage("Amount deposited: " + account.formatAmount(amount)); 65 | ui.showMessage("Your new balance is: " + account.getFormattedBalance()); 66 | } else { 67 | ui.showMessage("The amount must be greater than zero."); 68 | } 69 | } 70 | 71 | private void withdrawMoney() { 72 | ui.showTitle("MONEY WITHDRAWAL"); 73 | double amount = ui.readAmount("Enter the amount to withdraw: $"); 74 | 75 | if (amount == -1) { 76 | ui.showMessage("Invalid amount. Please enter a valid number."); 77 | return; 78 | } 79 | 80 | if (account.withdraw(amount)) { 81 | ui.showMessage("Withdrawal successful."); 82 | ui.showMessage("Amount withdrawn: " + account.formatAmount(amount)); 83 | ui.showMessage("Your new balance is: " + account.getFormattedBalance()); 84 | } else { 85 | if (amount <= 0) { 86 | ui.showMessage("The amount must be greater than zero."); 87 | } else { 88 | ui.showMessage("Insufficient funds. Your current balance is: " + account.getFormattedBalance()); 89 | } 90 | } 91 | } 92 | 93 | private void cashAdvance() { 94 | ui.showTitle("CASH ADVANCE"); 95 | ui.showMessage("WARNING: This operation may leave your balance negative."); 96 | double amount = ui.readAmount("Enter the advance amount: $"); 97 | 98 | if (amount == -1) { 99 | ui.showMessage("Invalid amount. Please enter a valid number."); 100 | return; 101 | } 102 | 103 | if (account.cashAdvance(amount)) { 104 | ui.showMessage("Cash advance processed successfully."); 105 | ui.showMessage("Advance amount: " + account.formatAmount(amount)); 106 | ui.showMessage("Your new balance is: " + account.getFormattedBalance()); 107 | 108 | if (account.hasDebt()) { 109 | ui.showMessage("NOTE: Your account now has a negative balance."); 110 | } 111 | } else { 112 | ui.showMessage("The amount must be greater than zero."); 113 | } 114 | } 115 | 116 | private void checkDebtorStatus() { 117 | if (account.hasDebt()) { 118 | ui.showMessage("⚠️ Negative balance, remember to pay the previously made advance"); 119 | } 120 | } 121 | 122 | private void showFarewell() { 123 | ui.showFarewell(account.getFormattedBalance()); 124 | } 125 | } 126 | 127 | -------------------------------------------------------------------------------- /Riwence/day_1/ATM/BankAccount.java: -------------------------------------------------------------------------------- 1 | package Riwence.day_1.ATM; 2 | 3 | import java.text.NumberFormat; 4 | import java.util.Locale; 5 | 6 | public class BankAccount { 7 | private double balance; 8 | private final NumberFormat currencyFormat; 9 | 10 | public BankAccount(double initialBalance) { 11 | this.balance = initialBalance; 12 | this.currencyFormat = NumberFormat.getCurrencyInstance(Locale.of("es", "CO")); 13 | } 14 | 15 | public String getFormattedBalance() { 16 | return currencyFormat.format(balance); 17 | } 18 | 19 | public boolean deposit(double amount) { 20 | if (amount <= 0) { 21 | return false; 22 | } 23 | balance += amount; 24 | return true; 25 | } 26 | 27 | public boolean withdraw(double amount) { 28 | if (amount <= 0 || amount > balance) { 29 | return false; 30 | } 31 | balance -= amount; 32 | return true; 33 | } 34 | 35 | public boolean cashAdvance(double amount) { 36 | if (amount <= 0) { 37 | return false; 38 | } 39 | balance -= amount; // Subtract amount to simulate withdrawal with advance 40 | return true; 41 | } 42 | 43 | public boolean hasDebt() { 44 | return balance < 0; 45 | } 46 | 47 | public String formatAmount(double amount) { 48 | return currencyFormat.format(amount); 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /Riwence/day_1/ATM/Main.java: -------------------------------------------------------------------------------- 1 | package Riwence.day_1.ATM; 2 | 3 | public class Main { 4 | public static void main(String[] args) { 5 | ATMachine atm = new ATMachine(); 6 | atm.run(); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /Riwence/day_1/ATM/UserInterface.java: -------------------------------------------------------------------------------- 1 | package Riwence.day_1.ATM; 2 | 3 | import java.util.Scanner; 4 | 5 | public class UserInterface { 6 | private final Scanner scanner; 7 | 8 | public UserInterface() { 9 | this.scanner = new Scanner(System.in); 10 | } 11 | 12 | public void showWelcome() { 13 | System.out.println("=== WELCOME TO THE ATM ==="); 14 | } 15 | 16 | public void showMenu() { 17 | System.out.println("=== MAIN MENU ==="); 18 | System.out.println("1. Check balance"); 19 | System.out.println("2. Deposit money"); 20 | System.out.println("3. Withdraw money"); 21 | System.out.println("4. Exit"); 22 | System.out.println("5. Cash advance"); 23 | System.out.print("Select an option: "); 24 | } 25 | 26 | public int readOption() { 27 | try { 28 | return scanner.nextInt(); 29 | } catch (Exception e) { 30 | scanner.nextLine(); // Clear buffer 31 | return -1; // Invalid option 32 | } 33 | } 34 | 35 | public double readAmount(String message) { 36 | System.out.print(message); 37 | try { 38 | return scanner.nextDouble(); 39 | } catch (Exception e) { 40 | scanner.nextLine(); // Clear buffer 41 | return -1; // Invalid amount 42 | } 43 | } 44 | 45 | public void showMessage(String message) { 46 | System.out.println(message); 47 | } 48 | 49 | public void showTitle(String title) { 50 | System.out.println("=== " + title + " ==="); 51 | } 52 | 53 | public void showBlankLine() { 54 | System.out.println(); 55 | } 56 | 57 | public void showFarewell(String finalBalance) { 58 | System.out.println("=== THANK YOU FOR USING OUR ATM ==="); 59 | System.out.println("Your final balance is: " + finalBalance); 60 | System.out.println("Have an excellent day!"); 61 | } 62 | 63 | public void close() { 64 | scanner.close(); 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /Riwence/day_1/FitProGym/GymQuoteService.java: -------------------------------------------------------------------------------- 1 | package Riwence.day_1.FitProGym; 2 | 3 | import java.util.Scanner; 4 | 5 | public class GymQuoteService { 6 | private final Scanner scanner; 7 | 8 | public GymQuoteService() { 9 | this.scanner = new Scanner(System.in); 10 | } 11 | 12 | public void processQuote() { 13 | // Input data 14 | System.out.print("Enter your name: "); 15 | String name = scanner.nextLine(); 16 | 17 | System.out.print("Enter your age: "); 18 | int age = scanner.nextInt(); 19 | 20 | System.out.print("Enter your height (in meters): "); 21 | double height = scanner.nextDouble(); 22 | 23 | System.out.print("Enter your weight (in kg): "); 24 | double weight = scanner.nextDouble(); 25 | 26 | scanner.nextLine(); // Clear buffer 27 | System.out.print("Enter the plan (BASIC, PLUS, PREMIUM): "); 28 | String plan = scanner.nextLine().toUpperCase(); 29 | 30 | System.out.print("Is this your first time? (true/false): "); 31 | boolean firstTime = scanner.nextBoolean(); 32 | 33 | // Create member 34 | Member member = new Member(name, age, height, weight, plan, firstTime); 35 | 36 | // Age validation 37 | if (!member.isEligible()) { 38 | System.out.println("Not eligible - Minimum age requirement not met."); 39 | return; 40 | } 41 | 42 | if (member.requiresGuardianAuthorization()) { 43 | System.out.println("Requires guardian authorization."); 44 | } 45 | 46 | // Calculate prices 47 | double basePrice = PriceCalculator.getPlanPrice(member.plan()); 48 | if (basePrice == -1) { 49 | System.out.println("Invalid plan selected."); 50 | return; 51 | } 52 | 53 | double discount = PriceCalculator.calculateDiscount(member); 54 | double finalPrice = PriceCalculator.calculateFinalPrice(member); 55 | 56 | // Display results 57 | displayResults(member, basePrice, discount, finalPrice); 58 | } 59 | 60 | private void displayResults(Member member, double basePrice, 61 | double discount, double finalPrice) { 62 | System.out.println("\n=== FITPRO GYM QUOTE ==="); 63 | System.out.println("Name: " + member.name()); 64 | System.out.println("Selected plan: " + member.plan()); 65 | System.out.println("Base price: $" + String.format("%.2f", basePrice)); 66 | System.out.println("Discount applied: " + String.format("%.0f%%", discount * 100)); 67 | System.out.println("Final price: $" + String.format("%.2f", finalPrice)); 68 | System.out.println("BMI category: " + member.getBMICategory()); 69 | } 70 | } 71 | -------------------------------------------------------------------------------- /Riwence/day_1/FitProGym/Main.java: -------------------------------------------------------------------------------- 1 | package Riwence.day_1.FitProGym; 2 | 3 | public class Main { 4 | public static void main(String[] args) { 5 | GymQuoteService quoteService = new GymQuoteService(); 6 | quoteService.processQuote(); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /Riwence/day_1/FitProGym/Member.java: -------------------------------------------------------------------------------- 1 | package Riwence.day_1.FitProGym; 2 | 3 | public record Member(String name, int age, double height, double weight, String plan, boolean firstTime) { 4 | 5 | public double calculateBMI() { 6 | return weight / (height * height); 7 | } 8 | 9 | public String getBMICategory() { 10 | double bmi = calculateBMI(); 11 | if (bmi < 18.5) { 12 | return "Underweight"; 13 | } else if (bmi >= 18.5 && bmi <= 24.9) { 14 | return "Normal"; 15 | } else if (bmi >= 25 && bmi <= 29.9) { 16 | return "Overweight"; 17 | } else { 18 | return "Obesity"; 19 | } 20 | } 21 | 22 | public boolean isEligible() { 23 | return age >= 14; 24 | } 25 | 26 | public boolean requiresGuardianAuthorization() { 27 | return age >= 14 && age < 18; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /Riwence/day_1/FitProGym/PriceCalculator.java: -------------------------------------------------------------------------------- 1 | package Riwence.day_1.FitProGym; 2 | 3 | public class PriceCalculator { 4 | private static final double BASIC_PRICE = 80.0; 5 | private static final double PLUS_PRICE = 120.0; 6 | private static final double PREMIUM_PRICE = 180.0; 7 | 8 | private static final double FIRST_TIME_DISCOUNT = 0.10; 9 | private static final double YOUNG_DISCOUNT = 0.10; 10 | private static final double MAX_DISCOUNT = 0.20; 11 | 12 | public static double getPlanPrice(String plan) { 13 | return switch (plan) { 14 | case "BASIC" -> BASIC_PRICE; 15 | case "PLUS" -> PLUS_PRICE; 16 | case "PREMIUM" -> PREMIUM_PRICE; 17 | default -> -1; 18 | }; 19 | } 20 | 21 | public static double calculateDiscount(Member member) { 22 | double discount = 0.0; 23 | 24 | if (member.firstTime()) { 25 | discount += FIRST_TIME_DISCOUNT; 26 | } 27 | 28 | if (member.age() >= 16 && member.age() <= 25) { 29 | discount += YOUNG_DISCOUNT; 30 | } 31 | 32 | // Apply maximum discount limit 33 | if (discount > MAX_DISCOUNT) { 34 | discount = MAX_DISCOUNT; 35 | } 36 | 37 | return discount; 38 | } 39 | 40 | public static double calculateFinalPrice(Member member) { 41 | double basePrice = getPlanPrice(member.plan()); 42 | if (basePrice == -1) { 43 | return -1; // Invalid plan 44 | } 45 | 46 | double discount = calculateDiscount(member); 47 | return basePrice * (1 - discount); 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /Riwence/day_1/FitProGym/README.md: -------------------------------------------------------------------------------- 1 | # Ejercicio: Cotizador Simple – FitPro Gym 2 | 3 | ## Objetivo 4 | Aplicar **variables**, **operadores** y **condicionales** en un caso realista de cotización de membresías. 5 | 6 | --- 7 | 8 | ## Entradas (con `Scanner`) 9 | 1. `String nombre` 10 | 2. `int edad` 11 | 3. `double altura` (en metros) 12 | 4. `double peso` (en kg) 13 | 5. `String plan` (`BASICO`, `PLUS`, `PREMIUM`) 14 | 6. `boolean primeraVez` 15 | 16 | --- 17 | 18 | ## Reglas de negocio 19 | 20 | 1. **Precio base del plan (mensual)** 21 | - `BASICO` → 80.0 22 | - `PLUS` → 120.0 23 | - `PREMIUM` → 180.0 24 | 25 | 2. **Descuentos** 26 | - Primera vez → 10% 27 | - Joven (16–25 años) → 10% 28 | - El total de descuentos no puede superar el **20%**. 29 | 30 | 3. **Edad mínima** 31 | - Si es menor de 14 → mostrar ` No elegible`. 32 | - Si es menor de 18 → mostrar ` Requiere autorización de acudiente`. 33 | 34 | 4. **Cálculo de BMI** 35 | - `bmi = peso / (altura * altura)` 36 | - Solo imprimir la categoría: 37 | - `<18.5` → Bajo peso 38 | - `18.5–24.9` → Normal 39 | - `25–29.9` → Sobrepeso 40 | - `>=30` → Obesidad 41 | 42 | 5. **Resultado final** 43 | - Mostrar **nombre**, **plan elegido**, **precio base**, **descuento aplicado**, **precio final** y **categoría de BMI**. 44 | 45 | --- 46 | 47 | 48 | -------------------------------------------------------------------------------- /Riwence/day_2/investigation/Main.java: -------------------------------------------------------------------------------- 1 | package Riwence.day_2.investigation; 2 | 3 | import java.util.ArrayList; 4 | import java.util.HashMap; 5 | 6 | public class Main { 7 | 8 | public static void main(String[] args) { 9 | //Array 10 | int[] gold = {11, 22, 44, 55, 14}; 11 | 12 | System.out.println("First Element: " + gold[0]); 13 | System.out.println("Last Element: " + gold[gold.length - 1]); 14 | 15 | //ArrayList 16 | 17 | ArrayList mochila = new ArrayList<>(); 18 | mochila.add("Espada"); 19 | mochila.add("Mapa"); 20 | mochila.add("Poción"); 21 | 22 | System.out.println(mochila.get(1)); 23 | mochila.remove(1); 24 | 25 | //HashMap 26 | 27 | HashMap tesoros = new HashMap<>(); 28 | tesoros.put("Oro", 100); 29 | tesoros.put("Plata", 50); 30 | tesoros.put("Diamantes", 5); 31 | 32 | tesoros.put("Oro", 200); 33 | 34 | System.out.println("Hay: "+ tesoros.get("Diamantes") + " diamantes" ); 35 | 36 | System.out.println(tesoros); 37 | 38 | //Final 39 | 40 | int [] goldQuantity = {1122, 2233, 4455}; 41 | 42 | ArrayList names = new ArrayList<>(); 43 | names.add("John"); 44 | names.add("Jane"); 45 | names.add("Jessica"); 46 | 47 | HashMap studentNames = new HashMap<>(); 48 | studentNames.put(goldQuantity[0], names.getFirst()); 49 | studentNames.put(goldQuantity[1], names.get(1)); 50 | studentNames.put(goldQuantity[2], names.getLast()); 51 | 52 | System.out.println(studentNames); 53 | int maxGold = 0; 54 | for (int key : studentNames.keySet()) { 55 | if (key > maxGold) { 56 | maxGold = key; 57 | } 58 | } 59 | System.out.println("The student with the highest gold quantity is " + studentNames.get(maxGold) + " with: " + maxGold + " goldCuantity."); 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /Riwence/day_2/investigation/README.md: -------------------------------------------------------------------------------- 1 | # Misión de Investigación: Exploradores de Datos en Java 2 | 3 | ## Objetivo 4 | Descubrir cómo **acceder y manipular** tres estructuras muy usadas en Java: 5 | - `Array` 6 | - `ArrayList` 7 | - `HashMap` 8 | 9 | --- 10 | 11 | ## Contexto 12 | Imagina que eres un **explorador digital** que ha encontrado tres cofres mágicos en una mazmorra de programación: 13 | - El **Cofre de Array** → guarda elementos ordenados en posiciones fijas. 14 | - El **Cofre de ArrayList** → una mochila mágica que se expande para guardar más cosas. 15 | - El **Cofre de HashMap** → un mapa secreto con **claves** y **tesoros** (valores). 16 | 17 | Tu misión es **investigar cómo abrir cada cofre** y obtener sus tesoros. 18 | 19 | --- 20 | 21 | ## 1. Array – El Cofre Ordenado 22 | ### Pista 23 | - Los elementos están guardados en **celdas numeradas** que comienzan desde el **índice 0**. 24 | - Para entrar a una celda, usas **corchetes `[]`** con el número de índice. 25 | 26 | ### Reto 27 | 1. Declara un `Array` de 5 enteros con tus números favoritos. 28 | 2. Accede al primer y al último número. 29 | 3. Cambia el valor de la posición 2 y vuelve a mostrarlo. 30 | 31 | --- 32 | 33 | ## 2. ArrayList – La Mochila Mágica 34 | ### Pista 35 | - No tiene límite fijo, **se agranda sola** cuando agregas más cosas. 36 | - Usa el método `.add()` para guardar, `.get()` para sacar y `.remove()` para eliminar. 37 | 38 | ### Reto 39 | 1. Crea un `ArrayList` llamado `mochila`. 40 | 2. Guarda 3 objetos que llevarías a una aventura (ej: "Espada", "Mapa", "Poción"). 41 | 3. Muestra el segundo objeto usando `.get(1)`. 42 | 4. Quita un objeto con `.remove()` y muestra la mochila actualizada. 43 | 44 | --- 45 | 46 | ## 3. HashMap – El Mapa del Tesoro 47 | ### Pista 48 | - Cada tesoro se guarda con una **clave**. 49 | - Para guardar usas `.put(clave, valor)`. 50 | - Para buscar un tesoro, usas `.get(clave)`. 51 | 52 | ### Reto 53 | 1. Crea un `HashMap` llamado `tesoros`. 54 | 2. Guarda 3 pares clave-valor: ("Oro", 100), ("Plata", 50), ("Diamantes", 5). 55 | 3. Muestra cuántos diamantes tienes usando la clave `"Diamantes"`. 56 | 4. Actualiza el valor de `"Oro"` a 200 y vuelve a imprimirlo. 57 | 58 | --- 59 | 60 | ## 4. Desafío Final 61 | Con lo que investigaste: 62 | 1. Usa un `Array` para guardar **3 códigos secretos** (ej: 123, 456, 789). 63 | 2. Usa un `ArrayList` para guardar los nombres de **3 exploradores**. 64 | 3. Usa un `HashMap` para asignar a cada explorador la cantidad de oro que encontró. 65 | 4. Muestra el explorador con más oro. 66 | 67 | --- 68 | 69 | Con esta misión, aprenderás a **acceder y manipular** `Array`, `ArrayList` y `HashMap` mientras juegas a ser un explorador de datos en Java. -------------------------------------------------------------------------------- /Riwence/day_2/loops/Main.java: -------------------------------------------------------------------------------- 1 | package Riwence.day_2.loops; 2 | 3 | 4 | import java.util.ArrayList; 5 | import java.util.HashMap; 6 | import java.util.Scanner; 7 | 8 | public class Main { 9 | 10 | public static void main(String[] args) { 11 | //Array 12 | Scanner sc = new Scanner(System.in); 13 | 14 | int [] numbers = {22,43,54,67,11}; 15 | 16 | for (int num : numbers){ 17 | System.out.println(num*2); 18 | } 19 | 20 | int [] numbers2 = new int[6]; 21 | 22 | for (int i = 0; i < numbers2.length; i++){ 23 | System.out.println("Insert "+ (i+1) + " number:"); 24 | numbers2[i] = sc.nextInt(); 25 | } 26 | 27 | for (int num : numbers2){ 28 | System.out.println(num); 29 | } 30 | 31 | //ArrayList 32 | ArrayList studentNames = new ArrayList<>(); 33 | studentNames.add("John"); 34 | studentNames.add("Jane"); 35 | studentNames.add("Jessica"); 36 | studentNames.add("Joseph"); 37 | studentNames.add("Jose"); 38 | 39 | for (String name : studentNames){ 40 | System.out.println(name); 41 | } 42 | 43 | //HashMap 44 | HashMap studentNames2 = new HashMap<>(); 45 | studentNames2.put(1038928372, "John"); 46 | studentNames2.put(1038928373, "Jane"); 47 | studentNames2.put(1038928374, "Jessica"); 48 | studentNames2.put(1038928375, "Joseph"); 49 | studentNames2.put(1038928376, "Jose"); 50 | 51 | for (int key : studentNames2.keySet()){ 52 | System.out.println(key + " -> " + studentNames2.get(key)); 53 | } 54 | 55 | 56 | //Exercises 57 | System.out.println("---Exercise 1---"); 58 | System.out.println("Enter the number to see the factorial:"); 59 | int number = sc.nextInt(); 60 | int factorial = 1; 61 | for (int i = 1; i <= number; i++) { 62 | factorial *= i; 63 | } 64 | System.out.println("The factorial of " + number + " is " + factorial); 65 | 66 | System.out.println("---Exercise 2---"); 67 | 68 | int randomNumber = (int) (Math.random() * 100) + 1; 69 | System.out.println("The random number is " + randomNumber); 70 | int tryCount = 10; 71 | int attempts = 0; 72 | int numberIngresed; 73 | do { 74 | if (attempts == tryCount) { 75 | System.out.println("You dont guessed the number, you are out of tries the random number was: " + randomNumber); 76 | break; 77 | } 78 | System.out.println("Insert a number between 1 and 100 (You have " + (tryCount - attempts) + " tries left):"); 79 | numberIngresed = sc.nextInt(); 80 | if (numberIngresed == randomNumber) { 81 | System.out.println("You guessed the number in " + attempts + " tries"); 82 | break; 83 | } else if (numberIngresed < randomNumber) { 84 | System.out.println("The number is lower than the guessed number"); 85 | attempts++; 86 | } else{ 87 | System.out.println("The number is higher than the guessed number"); 88 | attempts++; 89 | } 90 | 91 | }while (numberIngresed != randomNumber); 92 | 93 | System.out.println("---Exercise 3---"); 94 | int number2; 95 | int sum = 0; 96 | int count = 0; 97 | 98 | System.out.println("Insert numbers (0 to stop):"); 99 | 100 | do { 101 | number2 = sc.nextInt(); 102 | if (number2 != 0) { 103 | sum += number2; 104 | count++; 105 | } 106 | 107 | }while (number2 != 0); 108 | 109 | System.out.println("The sum is: " + sum + " and the average is: " + (double) sum / count); 110 | 111 | System.out.println("---Exercise 4---"); 112 | System.out.println("No exercise"); 113 | 114 | 115 | System.out.println("Insert a number:"); 116 | int number5 = sc.nextInt(); 117 | 118 | for (int i = 1; i < 11; i++) { 119 | 120 | System.out.println(number5 + " x " + i + " = " + (number5 * i)); 121 | 122 | } 123 | 124 | } 125 | } 126 | -------------------------------------------------------------------------------- /Riwence/day_2/loops/README.md: -------------------------------------------------------------------------------- 1 | ### Recorriendo Arrays, ArrayList y HashMap en Java 2 | 3 | Cuando trabajamos con colecciones de datos en Java, es muy común tener que recorrer todos los elementos. Como ya conoces los bucles (for, while, for-each), ahora aprenderás la sintaxis en Java para recorrer: 4 | 5 | - Arrays 6 | - ArrayList 7 | - HashMap 8 | 9 | ## 1. Arrays 10 | 11 | Un array es una colección de elementos del mismo tipo, con tamaño fijo. 12 | 13 | Ejemplo: 14 | ```java 15 | int[] numeros = {10, 20, 30, 40}; 16 | 17 | // Recorriendo con for tradicional 18 | for (int i = 0; i < numeros.length; i++) { 19 | System.out.println("Elemento en posición " + i + ": " + numeros[i]); 20 | } 21 | 22 | // Recorriendo con for-each 23 | for (int num : numeros) { 24 | System.out.println("Número: " + num); 25 | } 26 | ``` 27 | ## 2. ArrayList 28 | 29 | Un ArrayList es como un array dinámico: puedes agregar o quitar elementos sin preocuparte por el tamaño. 30 | 31 | Ejemplo: 32 | ```java 33 | import java.util.ArrayList; 34 | 35 | ArrayList frutas = new ArrayList<>(); 36 | frutas.add("Manzana"); 37 | frutas.add("Banana"); 38 | frutas.add("Mango"); 39 | 40 | // Recorriendo con for tradicional 41 | for (int i = 0; i < frutas.size(); i++) { 42 | System.out.println("Fruta en posición " + i + ": " + frutas.get(i)); 43 | } 44 | 45 | // Recorriendo con for-each 46 | for (String fruta : frutas) { 47 | System.out.println("Fruta: " + fruta); 48 | } 49 | ``` 50 | ## 3. HashMap 51 | 52 | Un HashMap almacena datos en pares clave → valor. 53 | 54 | Ejemplo: 55 | ```java 56 | import java.util.HashMap; 57 | 58 | HashMap estudiantes = new HashMap<>(); 59 | estudiantes.put(1, "Ana"); 60 | estudiantes.put(2, "Luis"); 61 | estudiantes.put(3, "Maria"); 62 | 63 | // Recorriendo solo las claves 64 | for (Integer clave : estudiantes.keySet()) { 65 | System.out.println("Clave: " + clave); 66 | } 67 | 68 | // Recorriendo solo los valores 69 | for (String nombre : estudiantes.values()) { 70 | System.out.println("Nombre: " + nombre); 71 | } 72 | 73 | // Recorriendo clave → valor 74 | for (var entry : estudiantes.entrySet()) { 75 | System.out.println("Clave: " + entry.getKey() + " → Valor: " + entry.getValue()); 76 | } 77 | ``` 78 | 79 | ## Taller de práctica 80 | 81 | Ahora que ya sabes cómo recorrer cada estructura, resuelve los siguientes ejercicios. 82 | 83 | Arrays: 84 | 85 | - Crea un array de 5 números enteros. 86 | - Recorre el array con un for y muestra cada número multiplicado por 2. 87 | - Luego crea un array sobre numeros con 6 posiciones de espacio y luego llenalo pidiendole al usuario 88 | por consola los numeros uno a uno 89 | 90 | ArrayList: 91 | 92 | - Crea un ArrayList con al menos 4 nombres de tus compañeros. 93 | - Recorre el ArrayList e imprime: "Hola, ". 94 | 95 | HashMap: 96 | 97 | - Crea un HashMap que guarde el número de documento como clave y el nombre como valor. 98 | - Recorre el mapa e imprime un mensaje así: 99 | 100 | Documento: → Nombre: 101 | 102 | 103 | ## Ejercicios de bucles 104 | 105 | 1. Crea una aplicación que pida un número y calcule su factorial (El factorial de un número es el producto de todos los enteros entre 1 y el propio número y se representa por el número seguido de un signo de exclamación. Por ejemplo 5! = 1x2x3x4x5=120), 106 | 107 | 2. Crea una aplicación que permita adivinar un número. La aplicación genera un número aleatorio del 1 al 100. A continuación va pidiendo números y va respondiendo si el número a adivinar es mayor o menor que el introducido,a demás de los intentos que te quedan (tienes 10 intentos para acertarlo). El programa termina cuando se acierta el número (además te dice en cuantos intentos lo has acertado), si se llega al limite de intentos te muestra el número que había generado. 108 | 109 | 3. Algoritmo que pida números hasta que se introduzca un cero. Debe imprimir la suma y la media de todos los números introducidos. 110 | 111 | 4. Realizar un algoritmo que pida números (se pedirá por teclado la cantidad de números a introducir). El programa debe informar de cuantos números introducidos son mayores que 0, menores que 0 e iguales a 0. 112 | 113 | 5. Algoritmo que pida caracteres e imprima ‘VOCAL’ si son vocales y ‘NO VOCAL’ en caso contrario, el programa termina cuando se introduce un espacio. 114 | 115 | 6. Escribir un programa que imprima todos los números pares entre dos números que se le pidan al usuario. 116 | 117 | 7. Realizar una algoritmo que muestre la tabla de multiplicar de un número introducido por teclado. 118 | 119 | 8. Escribe un programa que pida el limite inferior y superior de un intervalo. Si el límite inferior es mayor que el superior lo tiene que volver a pedir. A continuación se van introduciendo números hasta que introduzcamos el 0. Cuando termine el programa dará las siguientes informaciones: 120 | 121 | La suma de los números que están dentro del intervalo (intervalo abierto). 122 | Cuantos números están fuera del intervalo. 123 | He informa si hemos introducido algún número igual a los límites del intervalo. 124 | 125 | 9. Escribe un programa que dados dos números, uno real (base) y un entero positivo (exponente), saque por pantalla el resultado de la potencia. No se puede utilizar el operador de potencia. 126 | 127 | 10. Algoritmo que muestre la tabla de multiplicar de los números 1,2,3,4 y 5. 128 | -------------------------------------------------------------------------------- /VariableArguments/ArgumentosVariables.java: -------------------------------------------------------------------------------- 1 | package VariableArguments; 2 | 3 | public class ArgumentosVariables { 4 | 5 | static int sumatoria(int... valores) { 6 | int suma = 0; 7 | for (int i : valores) { 8 | suma += i; 9 | } 10 | System.out.println("Ingresaron " + valores.length + " valores"); 11 | return suma; 12 | } 13 | 14 | public static void main(String[] args) { 15 | int resul1 = sumatoria(10, 15); 16 | int resul2 = sumatoria(444, 18, 80); 17 | int resul3 = sumatoria(20, 100, 33, 53, 144); 18 | System.out.println(); 19 | System.out.println("La suma del primer resultados es: " + resul1); 20 | System.out.println("La suma del segundo resultados es: " + resul2); 21 | System.out.println("La suma del tercer resultados es: " + resul3); 22 | } 23 | } --------------------------------------------------------------------------------