No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Introducción a Java SE

Curso de Introducción a Java SE

Anahí Salgado Díaz de la Vega

Anahí Salgado Díaz de la Vega

Tipos de datos numéricos

14/39
Recursos

Tipos de datos para números enteros (sin decimales):

  • byte: Ocupa 1 byte de memoria y su rango es de -128 hasta 127.
  • short: Ocupa 2 bytes de memoria y su rango es de -32,768 hasta 32,727.
  • int: Ocupa 4 bytes de memoria y su rango es de -2,147,483,648 hasta 2,147,483,647. Es muy cómodo de usar, ya que no es tan pequeño para que no quepan nuestros números ni tan grande como para desperdiciar mucha memoria. Puede almacenar hasta 10 dígitos.
  • long: Ocupa 8 bytes de memoria y su rango es de -9,223,372,036,854,775,808 hasta 9,223,372,036,854,775,807. Para diferenciarlo de un tipo de dato long debemos terminar el número con la letra L.

Por ejemplo:

// Int:
int n = 1234567890;

// Long:
long nL = 123456789012345L;

Tipos de datos para números flotantes (con decimales):

  • float: Ocupan 4 bytes de memoria y su rango es de 1.40129846432481707e-45 hasta 3.40282346638528860e+38. Así como long, debemos colocar una letra F al final.
  • double: Ocupan 8 bytes de memoria y su rango es de 4.94065645841246544e-324d hasta 1.79769313486231570e+308d.

Por ejemplo:

// Double:
double nD = 123.456123456;

// Float
float nF = 123.456F;

Aportes 75

Preguntas 17

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

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.

¡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;

    }
}

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

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.

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;

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.

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

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;

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;
    }
}

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

 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

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;

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!```

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

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

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. 😄

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

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);

    }
}
//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. 💚

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

Me gustó la enseñanza con la empresa de Twitter me gustaría leer en post de todas la historia (que se comenta en la clase sobre las variables de los usuarios ). long (l). float(f).
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.

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

Punto flotante
float - 4 bytes
double - 8 bytes

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!

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

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

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”

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;

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;

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;

    }
}
>

geniaaal

Lo interesante entre el double y el flotante es que aunque tengas el mismo valor, float lo que hace es redondear (aproximar) el valor.
En el siguiente ejemplo vemos las 2 variables con el mismo valor pero lo que se imprime es diferente.
__



Esto es solo en la version 11 de JAVA?