Semana 4 - Conversión de tipos en Java

La conversión de tipos de datos en Java es un proceso mediante el cual se convierte un valor de un tipo de dato en otro. Java tiene dos tipos de conversión de datos: la conversión implícita y la conversión explícita.

La conversión implícita se produce automáticamente cuando se asigna un valor de un tipo de dato a una variable de otro tipo de datos compatible. Por ejemplo, si se asigna un valor de tipo "int" a una variable de tipo "double", Java realiza la conversión automáticamente.

int x = 5;
double y = x; // Conversión implícita de int a double

La conversión explícita, también conocida como "casting", se utiliza cuando se desea convertir un valor de un tipo de dato a otro tipo de datos que no es compatible de forma implícita. Para hacer una conversión explícita, se debe utilizar una sintaxis especial que indica al compilador que se desea convertir el valor a otro tipo de datos.

double x = 3.14;
int y = (int) x; // Conversión explícita de double a int

En este ejemplo, se utiliza la sintaxis "(int)" para indicar que se desea convertir el valor "x" de tipo "double" a un valor de tipo "int". Es importante tener en cuenta que la conversión explícita puede provocar la pérdida de información si se intenta convertir un valor a un tipo de datos con menos precisión.

Además de las conversiones implícitas y explícitas, Java también proporciona métodos para convertir valores entre diferentes tipos de datos, como los métodos "valueOf()" y "parseXxx()" de la clase "String". Estos métodos se utilizan para convertir valores de tipo "String" a otros tipos de datos, como "int" o "double".

Método parseXxx()

En Java, los métodos parseXxx() se utilizan para convertir una representación de cadena (String) en un valor de tipo primitivo o un objeto de clase envolvente. Aquí tienes algunos ejemplos de métodos parseXxx() para diferentes tipos de datos:

parseInt() - Convierte una cadena en un valor entero (int):

String numberStr = "123";
int number = Integer.parseInt(numberStr);
System.out.println(number); // Salida: 123

parseDouble() - Convierte una cadena en un valor de punto flotante (double):

String decimalStr = "3.14";
double decimal = Double.parseDouble(decimalStr);
System.out.println(decimal); // Salida: 3.14

parseBoolean() - Convierte una cadena en un valor booleano (boolean):

String boolStr = "true";
boolean boolValue = Boolean.parseBoolean(boolStr);
System.out.println(boolValue); // Salida: true

parseLong() - Convierte una cadena en un valor entero largo (long):

String floatStr = "2.71828";
float floatValue = Float.parseFloat(floatStr);
System.out.println(floatValue); // Salida: 2.71828

parseFloat() - Convierte una cadena en un valor de punto flotante de precisión simple (float):

String longStr = "9876543210";
long longValue = Long.parseLong(longStr);
System.out.println(longValue); // Salida: 9876543210

Método valueOf()

El método valueOf() en Java se utiliza para convertir un tipo de dato primitivo o una cadena en un objeto de clase envolvente (wrapper class). Aquí tienes un ejemplo de cómo se puede utilizar el método valueOf():

// Ejemplo 1: Converting a String to Integer object
String numberStr = "123";
Integer numberObj = Integer.valueOf(numberStr);
System.out.println(numberObj); // Salida: 123

// Ejemplo 2: Converting a String to Double object
String decimalStr = "3.14";
Double decimalObj = Double.valueOf(decimalStr);
System.out.println(decimalObj); // Salida: 3.14

// Ejemplo 3: Converting an int to Integer object
int intValue = 42;
Integer intObj = Integer.valueOf(intValue);
System.out.println(intObj); // Salida: 42

// Ejemplo 4: Converting a boolean to Boolean object
boolean boolValue = true;
Boolean boolObj = Boolean.valueOf(boolValue);
System.out.println(boolObj); // Salida: true

Clase Math en Java

Math es una clase en Java que proporciona métodos para realizar operaciones matemáticas comunes. No es necesario crear un objeto de la clase Math para usar sus métodos, ya que son estáticos.

Explicación:

La clase Math contiene una amplia variedad de métodos para realizar operaciones matemáticas como:

Operaciones básicas: suma, resta, multiplicación, división, potenciación y radicación.
Funciones trigonométricas: seno, coseno, tangente, arco seno, arco coseno y arco tangente.
Funciones logarítmicas: logaritmo natural (ln) y logaritmo en base 10 (log10).
Funciones exponenciales: exponenciación natural (exp) y exponenciación en base 10 (pow10).
Funciones de redondeo: floor, ceil y round.
Funciones de comparación: min, max y abs.
Generación de números aleatorios: random.

Ejemplos:

1. Operaciones básicas:

int suma = Math.add(1, 2); // Suma 1 y 2, resultado: 3
int resta = Math.subtract(5, 3); // Resta 3 de 5, resultado: 2
int producto = Math.multiply(4, 5); // Multiplica 4 por 5, resultado: 20
int division = Math.divide(10, 2); // Divide 10 entre 2, resultado: 5
double potencia = Math.pow(2, 3); // Eleva 2 a la potencia 3, resultado: 8
double raizCuadrada = Math.sqrt(9); // Calcula la raíz cuadrada de 9, resultado: 3

2. Funciones trigonométricas:

double seno = Math.sin(Math.PI / 2); // Calcula el seno de 90 grados, resultado: 1
double coseno = Math.cos(Math.PI); // Calcula el coseno de 180 grados, resultado: -1
double tangente = Math.tan(Math.PI / 4); // Calcula la tangente de 45 grados, resultado: 1

3. Funciones logarítmicas:

double ln = Math.log(Math.E); // Calcula el logaritmo natural de e, resultado: 1
double log10 = Math.log10(100); // Calcula el logaritmo en base 10 de 100, resultado: 2

4. Funciones exponenciales:

double exp = Math.exp(1); // Calcula la exponenciación natural de 1, resultado: 2.71828...
double pow10 = Math.pow(10,2); // Calcula 10 elevado a la potencia 2, resultado: 100

5. Funciones de redondeo:

double floor = Math.floor(3.14); // Redondea 3.14 hacia abajo, resultado: 3
double ceil = Math.ceil(3.14); // Redondea 3.14 hacia arriba, resultado: 4
double round = Math.round(3.5); // Redondea 3.5 al entero más cercano, resultado: 4

6. Funciones de comparación:

int min = Math.min(1, 2); // Devuelve el mínimo entre 1 y 2, resultado: 1
int max = Math.max(1, 2); // Devuelve el máximo entre 1 y 2, resultado: 2
int abs = Math.abs(-5); // Devuelve el valor absoluto de -5, resultado: 5

7. Generación de números aleatorios:

double numeroAleatorio = Math.random(); // Genera un número aleatorio entre 0.0 y 1.0

8. Generación de un número aleatorio entre 10 y 20:

int min = 10;
int max = 20;
int amplitud = max - min;

double numeroAleatorio = Math.random();
int numeroFinal = (int) (numeroAleatorio * amplitud) + min;

System.out.println("Número aleatorio entre " + min + " y " + max + ": " + numeroFinal);

Clase String en Java

La clase String en Java es una de las más utilizadas para trabajar con cadenas de caracteres. Ofrece una amplia gama de métodos para manipular, transformar y obtener información de las cadenas.

En esta guía completa, exploraremos en detalle todos los métodos de la clase String con ejemplos prácticos:

1. Métodos de comparación:

equals(Object anObject): Compara dos cadenas para verificar si son iguales.
equalsIgnoreCase(String anotherString): Compara dos cadenas ignorando las mayúsculas y minúsculas.
compareTo(String anotherString): Compara dos cadenas lexicográficamente.
compareToIgnoreCase(String anotherString): Compara dos cadenas lexicográficamente ignorando las mayúsculas y minúsculas.

String s1 = "Hola Mundo";
String s2 = "Hola Mundo";
String s3 = "hola mundo";

System.out.println(s1.equals(s2)); // true
System.out.println(s1.equalsIgnoreCase(s3)); // true
System.out.println(s1.compareTo(s2)); // 0
System.out.println(s1.compareToIgnoreCase(s3)); // 0

2. Métodos de búsqueda:

charAt(int index): Obtiene el carácter en la posición indicada.
indexOf(int ch): Obtiene la primera aparición del carácter especificado.
lastIndexOf(int ch): Obtiene la última aparición del carácter especificado.
contains(String str): Verifica si la cadena contiene la subcadena especificada.

String s = "Hola Mundo";

System.out.println(s.charAt(0)); // H
System.out.println(s.indexOf('o')); // 4
System.out.println(s.lastIndexOf('o')); // 7
System.out.println(s.contains("Mundo")); // true

3. Métodos de modificación:

concat(String str): Concatena dos cadenas.
replace(char oldChar, char newChar): Reemplaza todas las apariciones de un carácter por otro.
substring(int beginIndex): Obtiene una subcadena desde la posición indicada hasta el final.
substring(int beginIndex, int endIndex): Obtiene una subcadena desde la posición indicada hasta la posición final especificada.
toLowerCase(): Convierte la cadena a minúsculas.
toUpperCase(): Convierte la cadena a mayúsculas.
trim(): Elimina los espacios en blanco al principio y al final de la cadena.

String s1 = "Hola";
String s2 = "Mundo";

String s3 = s1.concat(s2); // "Hola Mundo"
String s4 = s3.replace('o', 'a'); // "Hala Munda"
String s5 = s3.substring(5); // " Mundo"
String s6 = s3.substring(0, 5); // "Hola "
String s7 = s3.toLowerCase(); // "hola mundo"
String s8 = s3.toUpperCase(); // "HOLA MUNDO"
String s9 = s3.trim(); // "Hola Mundo"

System.out.println(s3); // Hola Mundo
System.out.println(s4); // Hala Munda
System.out.println(s5); //  Mundo
System.out.println(s6); // Hola
System.out.println(s7); // hola mundo
System.out.println(s8); // HOLA MUNDO
System.out.println(s9); // Hola Mundo

4. Métodos de transformación:

split(String regex): Divide la cadena en una matriz de subcadenas utilizando la expresión regular especificada.
join(String delimiter, String[] strings): Concatena una matriz de cadenas en una sola cadena utilizando el delimitador especificado.

String s = "Hola, Mundo, cómo estás?";

String[] parts = s.split(","); // ["Hola", " Mundo", " cómo estás?"]
String joined = String.join(" ", parts); // "Hola Mundo cómo estás?"

System.out.println(Arrays.toString(parts)); // [Hola, Mundo, cómo estás?]
System.out.println(joined); // Hola Mundo cómo estás?

Actividad de clase

1. Calculando la propina en un restaurante

Enunciado:

Estás en un restaurante colombiano con amigos y la cuenta ha llegado. ¡Es hora de calcular la propina!

Paso a paso:

Ingresa el valor de la cuenta:
Solicita al usuario que ingrese el valor total de la cuenta, incluyendo el IVA, como un número decimal, por ejemplo: 120000.50.
Guarda el valor de la cuenta en una variable llamada valorCuenta.
Elige el porcentaje de propina:
En Colombia, es común dejar una propina del 10% al 15% del valor de la cuenta.
Solicita al usuario que ingrese el porcentaje de propina que desea dejar, por ejemplo: 12.
Guarda el porcentaje de propina en una variable llamada porcentajePropina.
Calcula el valor de la propina:
Convierte el porcentaje de propina a un valor decimal dividiéndolo entre 100 (por ejemplo, 12 / 100 = 0.12).
Multiplica el valor de la cuenta por el valor decimal del porcentaje de propina para obtener el valor de la propina.
Guarda el valor de la propina en una variable llamada valorPropina.
Calcula el valor total a pagar:
Suma el valor de la cuenta y el valor de la propina para obtener el valor total a pagar.
Guarda el valor total a pagar en una variable llamada valorTotal.
Imprime el resultado:
Muestra el valor de la cuenta, el porcentaje de propina, el valor de la propina y el valor total a pagar, formateados de manera clara y legible, por ejemplo:
```
Valor de la cuenta: $120000.50
Porcentaje de propina: 12%
Valor de la propina: $14400.06
Valor total a pagar: $134400.56
```

Pista:

Recuerda que en Java, las operaciones matemáticas se realizan con números decimales (tipo double).
Puedes usar el método String.format() para dar formato a los números y mostrarlos con dos decimales, por ejemplo: String.format("%.2f", valorPropina).
¡Puedes usar la clase Math para redondear el valor de la propina al entero más cercano, si lo prefieres!

2. Calculando el precio de un taxi en Medellín

Enunciado:

Estás en Medellín y necesitas tomar un taxi para llegar a tu destino. Para calcular el precio del viaje, necesitas considerar la tarifa base, el valor por kilómetro recorrido y el tiempo de espera en tráfico.

Paso a paso:

Ingresa la distancia del viaje:
Solicita al usuario que ingrese la distancia del viaje en kilómetros, por ejemplo: 8.2.
Guarda la distancia en una variable llamada distancia.
Ingresa el tiempo de espera en tráfico:
Solicita al usuario que ingrese el tiempo que espera pasar en tráfico, en minutos, por ejemplo: 10.
Guarda el tiempo de espera en una variable llamada tiempoEspera.
Calcula el precio del viaje:
Define la tarifa base del taxi en Medellín (por ejemplo, $4.000). Guarda este valor en una variable llamada tarifaBase.
Define el valor por kilómetro recorrido (por ejemplo, $900). Guarda este valor en una variable llamada valorKilometro.
Define el valor por minuto de espera en tráfico (por ejemplo, $150). Guarda este valor en una variable llamada valorMinuto.
Calcula el precio total del viaje:
- Multiplica la distancia por el valor por kilómetro recorrido.
- Multiplica el tiempo de espera por el valor por minuto.
- Suma la tarifa base, el precio por distancia y el precio por tiempo de espera.
Guarda el precio total del viaje en una variable llamada precioTotal.
Imprime el resultado:
Muestra el precio total del viaje, formateado de manera clara y legible, por ejemplo:
```
Precio del viaje: $11.580
```

Pista:

Puedes usar variables con nombres descriptivos para almacenar la información del viaje, por ejemplo: distancia, tiempoEspera, tarifaBase, valorKilometro, valorMinuto, precioTotal.
Recuerda que en Java, las operaciones matemáticas se realizan con números decimales (tipo double).
Puedes usar el método String.format() para dar formato al precio total y mostrar el valor con dos decimales, por ejemplo: String.format("%.2f", precioTotal).

3. Decodificando un mensaje secreto

Enunciado:

Eres un agente secreto que ha recibido un mensaje codificado. Para descifrarlo, necesitas aplicar una serie de operaciones sobre las cadenas de texto.

Mensaje codificado:

"H0l4  MUnD0,  3st0  3s  Un  m3ns4j3  s3cr3t0"

Paso a paso:

Convierte los números a letras:
Reemplaza los números "0" por la letra "o", los números "3" por la letra "e" y los números "4" por la letra "a".
Puedes usar el método replace() para realizar estas sustituciones.
Elimina los espacios en blanco adicionales:
Elimina los espacios en blanco al principio y al final de la cadena, y también los espacios en blanco adicionales que se encuentran entre las palabras.
Puedes usar el método trim() para eliminar los espacios al principio y al final, y el método replaceAll() para eliminar los espacios en blanco adicionales.
Convierte la cadena a mayúsculas:
Convierte toda la cadena a mayúsculas.
Puedes usar el método toUpperCase().
Imprime el mensaje decodificado:
Muestra el mensaje decodificado en la consola, con el texto completamente legible.

Pista:

Puedes usar una variable llamada mensajeCodificado para almacenar el mensaje inicial.
Puedes usar una variable llamada mensajeDecodificado para almacenar el mensaje decodificado después de cada paso.
Puedes usar el método System.out.println() para imprimir el mensaje decodificado en la consola.