Variables y datos numéricos

Correspondencia en Python —>

Existen principalmente dos tipos de datos numéricos en Java:

Los enteros (int). Pueden ser positivos, negativos o el cero.
Los float, que permiten almacenar datos decimales. En los entornos de programación de Java es frecuente que al escribir en código estos datos, debamos de añadir al final de la cifra la letra F para que el compilador los reconozca como tipo float. De no existir la F, los tomará como tipo double.
Los double, decimales de mayor precisión.

Con este tipo de datos, se pueden efectuar operaciones que normalmente se almacenarán en una variable.

Operaciones con datos numéricos. Además de las operaciones básicas (suma, resta, multiplicación o división), con los datos tipo numéricos se pueden hacer otras operaciones. Debemos de tener en cuenta, que en Java el resultado de dividir dos enteros será siempre un entero, y el resultado de dividir dos float será siempre un dato float.

Math.pow (base, exponente) . Es la operación de potencia. Elevamos la base al exponente. El resultado será siempre un número tipo double.
Math.sqrt(numero) . Nos facilita la raíz cuadrada de un número. El resultado será double.
Math.cbrt(numero). Que dará la raíz cúbica.
Math.pow (base, exponente) Eleva la base al exponente indicado.
Math.pow (base, 1/ exponente) Nos permite averiguar la raíz enésima de cualquier número.
% Es el operador módulo. Entre número positivos, representa el resto de la división de los dos números. Si alguno de los dos números es de tipo decimal, el resultado será también un resto decimal. Debemos de tener en cuenta, que entre números negativos la división modular ofrece resultados que pueden parecernos diferentes a la división modular entre dos números positivos. Importante: no confundir con el tanto por ciento.

public class Dividir {
    public static void main(String[] args) {
        int entero1=20;
        int entero2=6;
        int division_int=entero1/entero2;
        System.out.println(division_int);  

        float numero1=20;
        float numero2=6;
        float division_float=numero1/numero2;  
        System.out.println(division_float);
                        
        double potencia=Math.pow(3,2);
        System.out.println(potencia);     
    }
}

3
3.3333333
9.0

En una operación con varios operadores, se guarda en orden establecido de las operaciones matemáticas. Primero se efectúan los paréntesis, luego las raíces y potencias, luego multiplicaciones y divisiones, y por último las sumas y restas. Siempre de izquierda a derecha.

Si el tipo de dato que se espera como respuesta no coincide con el tipo de dato de los operadores, java intentará hacer la conversión al tipo de dato esperado, siempre y cuando no se pierda precisión. Esto no siempre es posible, por ejemplo, en el caso de las potencias y raíces, el dato esperado siempre será de tipo double.

public class Dividir {
    public static void main(String[] args) {
        int a=-5;
        double b=26;
        int c=14;
        double d=3;

        double e=Math.pow(b,3);
        double f=Math.pow(16,1/4);

        System.out.println(a+b-c*d); 
        System.out.println(b/a); 
        System.out.println(b/d); 
        System.out.println(e); 
        System.out.println(f); 
        System.out.println(b%d); 
    }
}

-21.0
-5.2
8.666666666666666
17576.0
1.0
2.0

Cuando a una variable numérica se le suma, resta, divide o multiplica por un número, y el resultado lo queremos asignar como valor de la misma variable, podemos usar los operadores “+=” “-=” “*=” “/=”

public class Operar {
    public static void main(String[] args) {
        int a=400;
        a+=3;
        System.out.println(a);
        a-=2; 
        System.out.println(a);
        a*=4;
        System.out.println(a);
        a/=5;
        System.out.println(a);
    }
}

Math.round(mi_decimal) . Este método permite obtener el entero más próximo al decimal que se pasa como parámetro.

Math.round(mi_decimal * 100.0) / 100.0 . Con este truco basado en el método anterior, podemos obtener un decimal redondeado a dos decimales. Si queremos obtener tres decimales, basta con sustituir las dos apariciones de 100.0 por 1000.0, igualmente si queremos el redondeo a un solo decimal, lo sustituiríamos por 10.0

public class Dividir {
    public static void main(String[] args) {
        double kilometros = 12.25;
        double millas = 7.02;

        double millas_a_kilometros;
        double kilometros_a_millas;
        double mi_decimal=34.521;

        millas_a_kilometros = millas*1.61;
        kilometros_a_millas = kilometros/1.61;

        System.out.println(Math.round(mi_decimal));

        System.out.println(millas+" millas son "+ millas_a_kilometros+" kilómetros");
        System.out.println(kilometros+" kilómetros son "+kilometros_a_millas+" millas.");

        millas_a_kilometros = Math.round(millas*1.61*1000.0)/1000.0;
        kilometros_a_millas = Math.round(kilometros/1.61*1000.0)/1000.0;

        System.out.println(millas+ " millas son "+ millas_a_kilometros+" kilómetros.");
        System.out.println(kilometros+ " kilómetros son "+kilometros_a_millas+" millas.");
    }
 }

35
7.02 millas son 11.3022 kilómetros
12.25 kilómetros son 7.608695652173912 millas.
7.02 millas son 11.302 kilómetros.
12.25 kilómetros son 7.609 millas.

Las funciones Math.floor(double) y Math.ceil(double) facilitan un número decimal redondeado a su entero más próximo por lo alto y por lo bajo respectivamente.

public class Prueba2 {
    public static void main(String[] args) {
        double mi_decimal=34.521;
        double redondeo=Math.round(mi_decimal);
        double redondeo_bajo=Math.floor(mi_decimal);
        double redondeo_alto=Math.ceil(mi_decimal);

        System.out.println("Número: "+mi_decimal);
        System.out.println("Redondeado: "+redondeo);
        System.out.println("Redondeado por abajo: "+redondeo_bajo);
        System.out.println("Redondeado por arriba: "+redondeo_alto);
    }
}

Resultado:

Número: 34.521
Redondeado: 35.0
Redondeado por abajo: 34.0
Redondeado por arriba: 35.0

La función Math.abs(numero) nos facilita el valor absoluto del valor numérico pasado como parámetro:

public class Prueba2 {
    public static void main(String[] args) {
        double mi_decimal=-34.521;
        double mi_absoluto=Math.abs(mi_decimal);

        System.out.println("Número: "+mi_decimal);
        System.out.println("Su valor absoluto: "+mi_absoluto);
    }
}

Resultado:

Número: -34.521
Su valor absoluto: 34.521

String.valueOf (numero) . Con este método conseguimos obtener un dato tipo String a partir de cualquier dato de tipo numérico.

public class Dividir {
    public static void main(String[] args) {
        int numero1=8;
        int numero2=14;
        int c=numero1+numero2;

        String cadena1=String.valueOf(numero1);
        String cadena2=String.valueOf(numero2);
        String suma_cadenas=cadena1+cadena2;

        System.out.println("La suma de los numeros es "+c);
        System.out.println("La suma de las cadenas es "+suma_cadenas);
    }
 }

La suma de los numeros es 22
La suma de las cadenas es 814

Si tenemos una cadena que contiene un dato numérico, podemos obtener el dato que encierra aplicando a la cadena el método adecuado. Dependiendo el tipo de dato numérico que deseemos obtener debemos de utilizar un método u otro.

Integer.parseInt(cadena) Nos permite obtener un dato entero a partir de una cadena que representa un entero.

public class Suma_Int {
    public static void main(String[] args) {
        String cadena1="348";
        String cadena2="43";
        String suma_cadenas=cadena1+cadena2;
        System.out.println("La suma de las cadenas es "+suma_cadenas);

        int entero1=Integer.parseInt(cadena1);
        int entero2=Integer.parseInt(cadena2);
        int suma_enteros=entero1+entero2;
        System.out.println("La suma de los números es "+suma_enteros);
    }
 }

La suma de las cadenas es 34843
La suma de los números es 391

Double.parseDouble(cadena) De la misma manera, podemos obtener con este otro método un dato decimal tipo double.

public class Suma_Double {
    public static void main(String[] args) {
        String cadena1="0.23";
        String cadena2="6.789";
        String suma_cadenas=cadena1+cadena2;
        System.out.println("La suma de las cadenas es "+suma_cadenas);

        double decimal_1=Double.parseDouble(cadena1);
        double decimal_2=Double.parseDouble(cadena2);
        double suma_decimales=decimal_1+decimal_2;
        System.out.println("La suma de los números es "+suma_decimales);
    }
 }

La suma de las cadenas es 0.236.789
La suma de los números es 7.019

Float.parseFloat(cadena) Y este otro método será valido si deseamos obtener un decimal tipo float.

public class Suma_Float {
    public static void main(String[] args) {
        String cadena1="23.41";
        String cadena2="78.245";
        String suma_cadenas=cadena1+cadena2;
        System.out.println("La suma de las cadenas es "+suma_cadenas);

        float decimal_1=Float.parseFloat(cadena1);
        float decimal_2=Float.parseFloat(cadena2);
        float suma_decimales=decimal_1+decimal_2;
        System.out.println("La suma de los números es "+suma_decimales);
    }
 }

La suma de las cadenas es 23.4178.245
La suma de los números es 101.655

Debemos tener cuidado al utilizar estados métodos anteriores, ya que, si intentamos obtener un tipo de dato de una cadena que no puede transformarse en ese tipo de dato, al ejecutar el código obtendremos un error de código.

public class Dividir {
    public static void main(String[] args) {
        String cadena1="23.41";
        int mi_entero=Integer.parseInt(cadena1);
        System.out.println(mi_entero);
    }
 }

Exception in thread "main" java.lang.NumberFormatException: For input string: "23.41"

Una variable de un tipo numérico puede contener un dato numérico de otro tipo con algunas restricciones.

Si el tipo de dato numérico de origen tiene menor precisión que el dato que vamos a obtener no habrá ningún problema, ya que el dato no va a perder precisión con el cambio. Por ejemplo, una variable tipo double puede contener un dato tipo int o float, y una variable tipo float puede contener un dato tipo int.

En cambio si intentamos cambiar el sentido de la conversión, por ejemplo pasar a una variable tipo int un dato tipo double, en este caso sí que habrá problemas, ya que estamos perdiendo precisión en el dato.

Veamos el siguiente ejemplo:

public class Prueba3 {
    public static void main(String[] args) {
        int a=4;
        int b=3;
        int c= Math.pow(a,b);
        System.out.println(c);
    }
}

Si intentamos compilar el código anterior, nos saltará una incompatibilidad de variables. Esto es debido a que la función Math.pow siempre devuelve un dato tipo double, que no podrá ser asignado directamente a un dato tipo int.

Para poder compilar el código anterior, necesitamos hacer una conversión explícita:

public class Prueba3 {
    public static void main(String[] args) {
        int a=4;
        int b=3;
        int c= (int)Math.pow(a,b);
        System.out.println(c);
    }
}

Resultado:

64

Le hemos pedido a java que convierta el tipo double a int anteponiendo al dato (o variable) el código «(int). En ocasiones se puede perder precisión con el cambio, por ejemplo si el dato numérico contiene decimales.

public class Prueba3 {
    public static void main(String[] args) {
        double a=4.34;
        double b=3.17;
        int c= (int)(a+b);
        System.out.println(c);
    }
}

Resultado:

7

El resultado que nos da de tipo int es 7, sin embargo 4.34+3.17=7.51

Ambíto de las variables. Un dato muy importante es el lugar donde está declarada una variable, tanto si es numérica como si es de tipo String.

Una variable será válida dentro del ámbito donde esté definida. Este ámbito quedará limitado generalmente por el par de llaves más próximo al que pertenezca.

public class Prueba3 {
    public static void main(String[] args) {
        String dia="Lunes";
        if (dia=="Lunes"){
            int dia_semana=1;
            System.out.println("Día semana: "+dia_semana);
        }
        int dia_despues=dia_semana+1;
        System.out.println("Día despues: "+dia_despues);
    }
}

El código anterior nos dará error al compilarse. Detectará que la variable dia_semana pertenece al bloque if, y hemos tratado de utilizarla fuera de dicho bloque.

La solución estaría en declarar la misma variable fuera del bloque.

public class Prueba3 {
    public static void main(String[] args) {
        int dia_semana=0;
        String dia="Lunes";
        if (dia=="Lunes"){
            dia_semana=1;
            System.out.println("Día semana: "+dia_semana);
        }
        int dia_despues=dia_semana+1;
        System.out.println("Día despues: "+dia_despues);
    }
}

Resultado:

Día semana: 1
Día despues: 2

Inicio	Comandos Java	Bloques de código.
Comentar código	System.out.print	Scanner (System.in)
Captura de errores	String	Datos Numéricos
Elementos aleatorios	Datos Fecha/hora	Constantes
Bucles for	Bucles while	Bloque if
Arrays	ArrayList	switch case
HashSet	HashMap	Métodos.
Clases	Archivos	Entorno gráfico Swing
JFrame (Ventanas)	Componentes básicos.