Tipos de datos numéricos

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
       //byte, short, int, long
        System.out.println("bits tipo byte:" + Byte.SIZE);
        System.out.println("bytes tipo byte:" + Byte.BYTES);
        System.out.println("valor minimo tipo byte:" + Byte.MIN_VALUE);
        System.out.println("valor maximo tipo byte:" + Byte.MAX_VALUE);
        System.out.println();
        System.out.println("bits tipo short:" + Short.SIZE);
        System.out.println("bytes tipo short:" + Short.BYTES);
        System.out.println("valor minimo tipo short:" + Short.MIN_VALUE);
        System.out.println("valor maximo tipo short:" + Short.MAX_VALUE);
        System.out.println();
        System.out.println("bits tipo int:" + Integer.SIZE);
        System.out.println("bytes tipo int:" + Integer.BYTES);
        System.out.println("valor minimo tipo int:" + Integer.MIN_VALUE);
        System.out.println("valor maximo tipo int:" + Integer.MAX_VALUE);
        System.out.println();
        System.out.println("bits tipo long:" + Long.SIZE);
        System.out.println("bytes tipo long:" + Long.BYTES);
        System.out.println("valor minimo tipo long:" + Long.MIN_VALUE);
        System.out.println("valor maximo tipo long:" + Long.MAX_VALUE);

        byte byteVar = 15;
        System.out.println("byteVar = " + byteVar);
        short shortVar = 100;
        System.out.println("shortVar = " + shortVar);
        int intVar = 500;
        System.out.println("intVar = " + intVar);
        long longVar = 1000;
        System.out.println("longVar = " + longVar);

        var numero = 10;
        System.out.println("numero = " + numero);

    }
}```

Bien, explicado. Esos detalles que en la universidad ni explicaron :'V y Platzi me informa y enseña.

Me es increíble como en el plan de estudios de mi carrera, en la materia de Java, sólo se limitaron a enseñarnos “int” sin siquiera decirnos que existían otros tipos de datos. Por eso es bueno complementar la educación universitaria, para no quedarnos estancados y seguir aprendiendo… Grande Platzi.

¡Hola!
Aquí les dejo el código comentado, para que lo tengan de recordatorio 😃

public class DataTypes {
    public static void main(String[] args) {
        // Numero entero (max. 10 numeros)
        int n = 1234567890;

        //Para diferenciarlo de Int colocar una L al final
        long nL = 12345678901L;

        //Numero grande en decimales
        double nD = 123.456;
        
        //Para diferenciarlo de Double colocar una F al final
        float nF = 123.456F;

    }
}

Obtener valor máximo de int
No necesitas memorizar el valor máximo o mínimo de un determinado tipo de dato numérico.
Una manera mas sencilla de saberlo es haciendo que Java nos lo diga:

System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);

Se hace uso de la clase equivalente al tipo de datos. Esto también aplica para los demás tipos de datos.

byte: 1 byte
short: 2 bytes
int: 4 bytes
double : 4 bytes
long: 8 bytes

En Java los valores numéricos enteros se evalúan como tipo int y los valores numéricos decimales como tipo ** double** es por eso que la siguiente sentencia marca error de compilación :

float decimalNumber = 5.3;

por eso se debe de colocar la letra “f” para forzar que sea evaluada como float

float decimalNumber = 5.3f;

ya sea para long o para float, se puede usar la L o F ya sea mayúscula o minúscula.

long nL = 1234567890l;
float nF = 123.456f;

Creo que el que hizo Java dijo: “Quiero hacer todo de la manera mas complicada posible”

Una corrección a esta clase y es que el tipo int no precisamente se usa para números de 10 caracteres sino para números comprendidos en el rango -2,147,483,648 a 2,147,483,648, por ejemplo no podrias tratar un número de celular como int en Colombia porque daría error. Ejemplo:

int cel = 3110000000 // Integer number too large

Aplica para bases de datos, alguna vez tuve que trabajar una tabla donde todos los celulares eran 2147483648 y es porque se excedía el limite superior.

Estupenda clase instructora Anahí, ahora noto la razón por la que siempre usaba double en mis proyectos, ya que cuando usaba float me salía error y no sabía que lo causaba así que cambiaba al otro tipo de variable numérica. En adelante tendré cuidado con esos detalles de las variable float y long.
Por cierto, para la persona que necesite el código acá lo coloco:

public class DataTypes {
    public static void main(String[] args) {
        //int
        int n = 1234567890;
        //long
        long nL = 12345678901L;
        //double
        double nD = 123.456123456;
        //float
        float nF = 123.456F;
    }
}

📦 Utilizar los tipos de datos de manera adecuada en Java, permite optimizar la memoria que utilizara la aplicación.

Al declarar un dato tipo long y float:
entero
long numero = 12345L;
Decimal
float numero2 = 123.12345F;

los demas byte, short, int y double son de la forma normal:
int numero2 = 123;

Gracias por lo datos adicionales y esos detalles que hacen la vida mas facil de llevar, la leta al final (que a muchos se nos olvida y estamos ahi, rompiendonos la cabeza) o cosas que simplemente no nos habian dicho antes.

Tipos de datos numéricos

En Java, se pueden utilizar los siguientes tipos de datos numéricos para números enteros

1. Byte: ocupa 1 byte de memoria.
2. Short: ocupa 2 bytes de memoria.
3. int: ocupa 4 bytes de memoria
4. long: ocupa 8 bytes de memoria.
   Nota: Para diferenciar un int de un long es necesario poner una ‘L’ al final del número de tipo long. Ejemplo:

long numLong = 1234L;

Para datos numéricos con punto decimal existen dos opciones: float y double.

1. float: ocupa 4 bytes de memoria y no tiene tanta precisión como double.
2. double: ocupa 8 bytes de memoria y tiene más precisión que float.
   Para hacer la distinción entre estos, es necesario poner una ‘F’ al final del número flotante. Ejemplo:

float numf = 1234F;

El botón crear apuntes es algo que había pedido, hacia falta y esta muy bueno, estaría mucho mejor si cuando estoy viendo en pagina completa el video estuviera un botón flotante mas chico tipo chat en la pantalla y al darle grabar al apunte se pusiera en play automáticamente, seria mas practico y mas eficiente, gracias

No se menciona, pero, hay diferencia si se pone la letra L y/o F en mayuscula o minuscula?

Byte: (1 byte de memoria Ram) rango -128 a 127.
Short: (2 bytes de memoria Ram) rango -32,768 a 32,767.
Int: (4 bytes de memoria Ram) rango -2,147,483,648 a 2,147,483,647
long: (8 bytes de memoria Ram) rango -9,223,372,036,854,775,808 a -9,223,372,036,854,775,807

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
       //byte, short, int, long
        System.out.println("bits tipo byte:" + Byte.SIZE);
        System.out.println("bytes tipo byte:" + Byte.BYTES);
        System.out.println("valor minimo tipo byte:" + Byte.MIN_VALUE);
        System.out.println("valor maximo tipo byte:" + Byte.MAX_VALUE);
        System.out.println();
        System.out.println("bits tipo short:" + Short.SIZE);
        System.out.println("bytes tipo short:" + Short.BYTES);
        System.out.println("valor minimo tipo short:" + Short.MIN_VALUE);
        System.out.println("valor maximo tipo short:" + Short.MAX_VALUE);
        System.out.println();
        System.out.println("bits tipo int:" + Integer.SIZE);
        System.out.println("bytes tipo int:" + Integer.BYTES);
        System.out.println("valor minimo tipo int:" + Integer.MIN_VALUE);
        System.out.println("valor maximo tipo int:" + Integer.MAX_VALUE);
        System.out.println();
        System.out.println("bits tipo long:" + Long.SIZE);
        System.out.println("bytes tipo long:" + Long.BYTES);
        System.out.println("valor minimo tipo long:" + Long.MIN_VALUE);
        System.out.println("valor maximo tipo long:" + Long.MAX_VALUE);

        byte byteVar = 15;
        System.out.println("byteVar = " + byteVar);
        short shortVar = 100;
        System.out.println("shortVar = " + shortVar);
        int intVar = 500;
        System.out.println("intVar = " + intVar);
        long longVar = 1000;
        System.out.println("longVar = " + longVar);

        var numero = 10;
        System.out.println("numero = " + numero);

    }
}

public class DataTypes {
    public static void main(String[] args) {
        //byte, short, int, long
        System.out.println("==========TIPOS DE DATOS ENTEROS==========");
        System.out.println();

        System.out.println("BYTE");
        System.out.println("Ocupa una capacidad de: " + Byte.SIZE + " bits ó " + Byte.BYTES + " byte");
        System.out.println("Comprende desde " + Byte.MIN_VALUE + " hasta " + Byte.MAX_VALUE);
        System.out.println();

        System.out.println("SHORT");
        System.out.println("Ocupa una capacidad de: " + Short.SIZE + " bits ó " + Short.BYTES + " byte");
        System.out.println("Comprende desde " + Short.MIN_VALUE + " hasta " + Short.MAX_VALUE);
        System.out.println();

        System.out.println("INTEGER");
        System.out.println("Ocupa una capacidad de: " + Integer.SIZE + " bits ó " + Integer.BYTES + " byte");
        System.out.println("Comprende desde " + Integer.MIN_VALUE + " hasta " + Integer.MAX_VALUE);
        System.out.println();

        System.out.println("LONG");
        System.out.println("Ocupa una capacidad de: " + Long.SIZE + " bits ó " + Long.BYTES + " byte");
        System.out.println("Comprende desde " + Long.MIN_VALUE + " hasta " + Long.MAX_VALUE);
        System.out.println();

        //float,double
        System.out.println("==========TIPOS DE DATOS DE PUNTO FLOTANTE==========");
        System.out.println();

        System.out.println("FLOAT");
        System.out.println("Ocupa una capacidad de: " + Float.SIZE + " bits ó " + Float.BYTES + " byte");
        System.out.println("Comprende desde " + Float.MIN_VALUE + " hasta " + Float.MAX_VALUE);
        System.out.println();

        System.out.println("DOUBLE");
        System.out.println("Ocupa una capacidad de: " + Double.SIZE + " bits ó " + Double.BYTES + " byte");
        System.out.println("Comprende desde " + Double.MIN_VALUE + " hasta " + Double.MAX_VALUE);
        System.out.println();
        System.out.println();

        //float,double
        System.out.println("EJEMPLOS====================");
        System.out.println();

        byte byteVar = 15;
        System.out.println("byteVar = " + byteVar);
        short shortVar = 100;
        System.out.println("shortVar = " + shortVar);
        int intVar = 500;
        System.out.println("intVar = " + intVar);
        long longVar = 1000;
        System.out.println("longVar = " + longVar);
        float floatVar = 1.618033f;
        System.out.println("floatVar = " + floatVar);
        double doubleVar = 3.141592654;
        System.out.println("doubleVar = " + doubleVar);

        var numero = 10;
        System.out.println("numero = " + numero);

    }
}

Estaba jugando con el tipo de dato byte y me paso algo curioso.

Segun los rangos el valor minimo es -128 y el maximo es 127, así que coloque en el IDE el valor 150 a ver como era el error pero el IDE me suguirio hacer un casteo o conversión a byte de la siguiente forma

byte b3 = (byte) 150;

Pero al ejecutar un print la consola me arroja esto

System.out.println("B3: " + b3);
B3: -106

Enteros
Byte - 1 byte
short - 2 bytes
int - 4 bytes
long - 8 bytes

Punto flotante
float - 4 bytes
double - 8 bytes

Nunca llegue a pensar que colocando, o una L o una F en esos respectivos datos Long y Float, podieran hacer que se consideren como tal.

Un punto importante que leí es que los programas escritos en versiones anteriores de java (7, 8, etc) son compatibles con los jdk nuevos(11, 12, etc), pero no puedes correr un programa escrito con un jdk de java 11 en un entorno de jdk de java anterior, dígase 9, 8 etc. 😄

Si usan Linux y trabajn todo desde la consola, vean esta página. En la página van a ver como cambiar la version de Java que se está usando, TODO DESDE LA TERMINAL!!
Les adelonto algo, este es el comando
update-alternatives --config java
den enter y leccionen el numero de la version y luego <Enter> otra vez. Listo!

Yo lo puse en un alias en mi ~/.bashrc que se ve así:
#change Java version
alias cjava=‘update-alternatives --config java’
#note: cjava es porque en inglés sería tercnicamente “change java”

 byte b; // -128 a 127
        short s; // -32,768 a 32,767
        int i = 1234567890; // -2,147,483,648 a 2,147,483,648
        long l = 12345678901L; // -9223372036854775808 a 9223372036854775807

        double d = 123.123;
        float f = 123.123F;

en java como es un lenguaje fuertemente estereotipado el manejo de los tipos de variable es muy importante según hasta donde tengo entendido

esto lo vi hace mucho tiempo atras

No recordaba lo de la letra al final, muchas gracias 😄

Me interesa mucho.
Me lo habían explicado mal antes 😃 , solo por esto te pongo carita feliz 😃

Para aquellos que precisan el codigo:

public class DataTypes {
    public static void main(String[] args) {
        int n = 1234567890;
        long nL = 12345678901L;

        double nD = 123.456;
        float nF = 123.456F;
    }
}

Slds!```

Es importante recordar que cuando utlizamos double o float debemos colocar la letra en mayúscula al final de los digitos. Es decir: float nF = 123.452F y long nL = 123.452L

Punto Flotante / double - 8 bytes / float - 4 bytes.

Tipos de datos numéricos, int, long, utillizar L mayúscula al final de declarar la variable.

Me encanto tu explicación sobre los tipos de datos.

Muy clara la explicacion.

• Para el caso de datos con punto decimal (punto flotante) Java también maneja una categoría interesante y es que tenemos dos tipos de datos que podemos utilizarlos como punto flotante o punto decimal, el más común es y nuestro comodín será el double:

1. float
   Rango: 1.40129846432481707e-45 a 3.40282346638528860e+38 (4bytes)
2. double
   Rango: 4.94065645841246544e-324d a 1.79769313486231570e+308d (8 bytes)

• Gran variedad de tipos datos que existen en Java para clasificar a los datos de tipo entero; vamos a decir que un tipo de dato entero va a ser un número que no sea decimal; aquí puede ser un número positivo o un número negativo que tenga un signo de menos al principio de ese número, pero siempre deberían ser enteros no deberían ser de punto con punto decimal, siempre enteros.

• Dentro de los enteros hay:

1. byte
   rango: ( -128 a 127) 1 byte
2. short
   rango: (-32,768 a 32,767) 2bytes.
3. int
   rango: (-2,147,483,648 a 2,147,483,647) 4 bytes
4. long
   rango: (-9,223,372,036,854,775,808 a +9,223,372,036,854,775,807) 8 bytes

• Tipos de variables que hemos visto:

1. Variables tipo numéricas.
2. Variables tipo string de cadenas de texto.

✅

No conocía lo de poner las letras al final

lo bueno que la casi todos los lenguajes usan los mismos tipos de variables

Realice una clase Family y modele las principales caracteristicas que puede tener un familiar, solo defini los parametros y en otra clase coloque el psvm donde imprimo las caracteristicas.

Comparto mi ejercicio realizado de esta clase.

y sobre todo con un buen sabor de boca ya que al comprender esto me permite poder entender que dependiendo de lo que hará el programa puedo usar un dato para que no se consuma mas memoria de lo necesario.

 // numeric types
        //type byte
        byte isByte = 12; //byte 1 byte  -128 to 127
        //type short
        short isShort = -32756; //short 2 bytes  -32,768 to 32,767
        //type int
        int isInt = 2147483647; //int 4 bytes -2,147,483,648 to 2,147,483,647
        //type long
        long myLong = -999999999L; //long 8 bytes -9,223,372,036,854,775,808 to 9,223,372,036,854,775,80

Aprendan bien sobre los tipos de datos y sus impactos en la memoria. Saber de esto les puede ahorrar dolores de cabeza.
Aqui un ejemplo:
Esto da falso. ¿Saben porque?

public class Variables {
    public static void main(String[] args) {
        float a = (float) 5.7;

        if(a == 5.7){
            System.out.println("Verdadero");
        }else {
            System.out.println("Falso");
        }
    }
}

Empecé a aprender Java SE en en mi primer semestre de la U y no me habían explicado factores importantes como estos, aquí se aprende más a detalle.

[

Tipos de datos numércios:
byte | -128 a 127
short | -32,728 a 32,797
int | -2,147,483,548 a 2,147,483,647
long | -9,223,372,035,854,775,808 a 9,223,372,036,854,775,807

es interesante saber esto pero la verdad siempre uso int y double

//int tiene un limite de 10 digitos
int n = 1234567890;

//solucion de twiter varaible LONG y s debe poner una "L" al final
long nl = 12345678901;
long nl = 12345678901L;

//Punto Flotante
double nD = 234.53459438508340;
//pro defecto detecta que es del tipo double
float xF = 234.53459438508340;
//deberemos agregar F al fnial
float nF = 234.53459438508340F;

• Enteros:
  

  

• Punto Flotante:
  

  

Cada variable utiliza espacio en memoria, por eso, es importante elegir el tipo de dato correcto para agilizar el funcionamiento del programa. 💚

https://www.w3schools.com/java/java_data_types.asp

Por cierto
Yo se que tiene que ver por el tipo de curso pero el Boolean es el más pequeño por solo contar con 1 bit (true y false).

public class TipoDatosNumericos {
    public static void main(String[] args) {
        //LOs tipos de datos tienen un limite
        byte numeroByte = 127;
        System.out.println("La cantidad de un byte a bites es de: " + Byte.SIZE);
        System.out.println("La cantidad de un byte a bytes es de: " + Byte.BYTES);
        System.out.println("El valor maximo de un byte es de: " + Byte.MAX_VALUE);
        System.out.println("El valor minimo de un byte es de: " + Byte.MIN_VALUE);

        short numeroShort = 32767;
        System.out.println("La cantidad de un short a bites es de: " + Short.SIZE);
        System.out.println("La cantidad de un short a bytes es de: " + Short.BYTES);
        System.out.println("El valor maximo de un short es de: " + Short.MAX_VALUE);
        System.out.println("El valor minimo de un short es de: " + Short.MIN_VALUE);

        int numeroInt = 2147483647;
        System.out.println("La cantidad de un int a bites es de: " + Integer.SIZE);
        System.out.println("La cantidad de un int a bytes es de: " + Integer.BYTES);
        System.out.println("El valor maximo de un int es de: " + Integer.MAX_VALUE);
        System.out.println("El valor minimo de un int es de: " + Integer.MIN_VALUE);

        long numeroLong = 9223372036854775807L;
        System.out.println("La cantidad de un long a bites es de: " + Long.SIZE);
        System.out.println("La cantidad de un long a bytes es de: " + Long.BYTES);
        System.out.println("El valor maximo de un long es de: " + Long.MAX_VALUE);
        System.out.println("El valor minimo de un long es de: " + Long.MIN_VALUE);

    }
}

Para ampliar los conceptos sobre los tipos de datos en Java y sus usos más comunes.

https://javadesdecero.es/basico/tipos-datos-java-ejemplos/

Byte, Short, int, long
el tipo long permite mas datos numericos

public class DataTypes {
    public static void main(String[] args) {
        int n=1234567890;//digitos del 10 numeros
        long nL=12345678901L;//digitos de longitud de diferencia con la L al final
        Double nD=123.456;//digitos de tipo Double
        float nF=123.456F;//digito de tipo float se identicfica con la letra F al final

    }
}

long hay que escribir “L” al final de la los números, mientras que para float se escribe una “F”.

byte: 1 byte
short: 2 bytes
int: 4 bytes
double : 4 bytes
long: 8 bytes

excelente no sabia que tenia que agregar las letras al final al menos en la universidad nunca me dijeron eso

Cosas que no sabias y ya las estas aprendiendo po eso nunca paren de aprender ❤️

int n = 1234567890;
long nL = 12345678901L;

    double nD = 123.456;
    float nF = 123.456F;

Super!!

indetificar tipo de datos colocando un idicador al final del valor de la variable.

package pkg01_variables;

public class Variables {

    /*
        Crea una variable de cada tipo:
            - byte
            - short
            - int
            - long
            - char
            - double
            - float
            - String
            - boolean
    
    */
    public static void main(String[] args) {
       
        //numeros enteros
        byte a=5;
        short b = 200;
        int c = 1000000;
        long d = 10000000000L;
        
        //caracter
        char e = 'a';
        
        double f = 4.5;
        float g = 4.5f;
        
        String h = "Hola mundo";
        
        boolean i = 5 > 10;
        
        
    }
    
}

“el secreto” que menciona se ve en el proximo video y… pues si que sorprendió.

Excelente recordatorio de los tipos de datos, en java que es un lenguaje fuertemente tipado

REPASO DE LA CLASE ANTERIOR;

-upper camel case,hacemos referencias a nombre de cosas SUPERIORES(UPPERS) en java

Comienza el mundo de los lenguajes tipados 😉

Genial! me recordaron cosas que hacia mucho no usaba y que son muy útiles y adicionalemente aprendí a trabajar mejor los tipos de datos. Gracias!

no recordaba esto y vaya que si es muy importante

Aunque no da error si no lo ponemos, double necesita la letra d ya sea may/min al final de los decimales. Ejemplo:

double numDecimal = .1234567890D;

Excelente clase, no sabía que teníamos que agregar la letra L al tipo de dato long.

public class DataTypes {
public static void main(String[] args) {

    int n = 1234567890;

    long nL = 12345678901L;

    double nD = 123.456123456;

    float nF = 123.456F;
}

}

Todo muy claro hasta ahora.

Creo que está es la primera razón por la cual no me encantará Java, eso de ponerle L o F a los tipos de datos Long o Double para que no salte errores se e hace feo.

Todo muy claro.

Excelente clase.

Muy claro todo

Todo claro… gracias 😃

Tipos de datos numéricos:
Para números enteros
byte
short
int
long (se coloca una L al final de los dígitos)
Para números con decimales (flotantes)
double
float (se coloca una F al final de los dígitos)

😃

Genial, corregi un error que me genero de inmediato 😃

En lenguajes como C si sabemos que solo vamos a usar números positivos podemos especificarle al tipo de dato que todo lo que ocupe en memoria ram sea para números positivos. Se hace con “unsigned”.

Entonces, en vez de que se puedan usar números negativos, todo el espacio disponible de la variable se va a usar solo para números positivos.

La página de Arduino lo explica muy bien: https://www.arduino.cc/reference/en/language/variables/data-types/unsignedint/

excelente explicacion y didactica…

Todo clarísimo. Gracias

public class DataType {
    public static void main(String[] args) {

        //Tipos de datos
        //Byte -> de -128 a 127 (1 byte)
        //short -> -32768 a 32767 (2 bytes)
        //int -> -2147483648 a 2147483648 (4 bytes)
        //long -> -9223372036854775808 a 9223372036854775807 (8 bytes)
        //float -> 1.401 E-45 a 3.402 E38 (4 bytes)
        //double -> 4.9406 E-324 a 1.7976 E308 (8 bytes)

        int n = 1234567890; //El tipo de dato int soporta hasta 10 digitos
        long nL = 12134567890L; //Para identificar el long es necesario poner 'L' al final del número

        double nD = 123.456789123; //Se utiliza para cálculos matemáticos para más precisión, así mísmo utiliza más memoria
        float nF = 123.456f; //Para identificar el float es necesario poner 'f' al final del número
    }
}

La “L” que se pone al final para declarar el long va con mayúscula;

continuando con la clase

<public class DataTypes {
    public static void main(String[] args) {
        int n=1234567890;
        long nL=12345678901L;
        double nD=12121.50;
        float nF=1212.058F;

    }
}
>