markdown Tipos de datos primitivos

Posted 2021-05-05

# byte :

* http://blog-programando-ando.blogspot.com/2013/10/tipo-byte-en-java.html

el byte tipo de datos es un entero de complemento de dos firmado de 8 bits. Tiene un valor mínimo de -128 y
un valor máximo de 127 (inclusive). El byte tipo de datos puede ser útil para guardar la memoria en
matrices grandes , donde el ahorro de memoria realmente importa. También se pueden usar en lugar de int que
sus límites ayuden a aclarar su código; el hecho de que el rango de una variable sea limitado puede servir
como una forma de documentación

La utilidad de este tipo de datos reside en el ahorro de espacio: si tenemos dos vectores, uno de tipo int
y otro de tipo  byte, y comparamos la cantidad de memoria que usan, notaremos que la usada por el de tipo
byte es mucho menor.

Operaciones Básicas con Datos de Tipo Byte
Con datos de tipo byte es posible realizar las 4 operaciones básicas: suma, resta, multiplicación y división.

```
public class PruebasByte {
    public static void main(String[] args) {
        byte b1 = 4;
        byte b2 = 3;
         
        byte suma =  (byte) (b1 + b2);
        byte resta =  (byte) (b1 - b2);
        byte division =  (byte) (b1/b2);
        byte multiplicacion = (byte) (b1*b2);
       
        System.out.println("Suma: " + suma);
        System.out.println("Resta: " + resta);
        System.out.println("Division: " + division);
        System.out.println("Multiplicacion: " + multiplicacion);
    }
}

```

* Preguntas

¿Por qué estamos haciendo un casting en suma, resta división y multiplicación?: Primero, si no sabes a que me refiero con casting, digamos simplemente que es esta línea de código (en el caso de la suma):
?
1
byte suma =  (byte) (b1 + b2);

La razón fundamental es que la suma, resta, multiplicación y división de dos bytes me retorna un entero;
luego, debo transformarlo para volver a guardarlo en un tipo byte. 

¿Por qué la división da 1 y no 1,333...?: En el mundo real sabemos que al dividir 4 entre 3 el resultado 
no es un número entero; sin embargo, en nuestro programa estamos almacenando ese resultado en un entero 
tipo byte, y un entero no puede tener decimales. Luego, lo que sucede es que guardamos el cociente de la 
división en nuestra variable byte.

 *Conversión de Binario a Byte
 
Antes de comenzar es importante saber que que el tipo byte es un tipo entero de 8 bits complemento a dos.
¿Qué significa eso de "complemento a dos"?, pues es básicamente una forma de representar datos positivos
y negativos en binario. Resulta que un entero tipo byte es almacenado en 8 bits, donde el último representa
el signo
```
     b7     b6b5b4b3b2b1b0
     signo  numero
```

Según lo anterior, si el último bit (b7) es 0, el número es positivo y si es 1 será negativo. 
Las reglas para aplicar el complemento a dos son bastante sencillas:
Si el número es positivo (b7 = 0) no se hace nada, y el número en decimal será el equivalente de 
transformar la parte en azul de la figura 1.
Si el número es negativo (b7 = 1), el decimal resultante será igual a invertir los 0 por 1 y viceversa y
luego sumar 1 al resultado. 

``````
public class ConvertBinarioIsByte {
    public static void main(String[] args) {
        // Es equivalente a: byte numero1 = (byte)Short.parseShort("00000001", 2);
        byte numero1 = Byte.parseByte("0000001", 2);
        // NO es equivalente a: byte numero2 = Byte.parseByte("10000001", 2);
        byte numero2 = (byte)Short.parseShort("10000001", 2);
        System.out.println("Numero 1: "+numero1);
        System.out.println("Numero 2: "+numero2);
    }
}
```

* preguntas

El ejemplo anterior mostrará que numero1 es igual a 1 y numero2 es igual a -127. Hay varias cosas que es
importante resaltar:
¿Por qué en numero1 y numero2 hacemos diferente la conversión?: Simplemente quiero mostrar cuan
importante es saber cómo guarda el computador los datos. En el caso de numero1, la conversión se puede
tanto usando parseShort() junto a un casting como con un simple parseByte(); sin embargo, en numero2 si
es necesario usar el parseShort(). 

Ahora la pregunta que seguramente se están haciendo, ¿por qué?. Resulta que, en el caso de numero2,
si intentamos hacer:
?
1
byte numero2 = Byte.parseByte("10000001", 2);

Se generará un error, porque 10000001 en binario es igual a 129 en decimal, un valor por fuera del rango del tipo byte. Es por esto que es necesario primero "parsearlo" en un objeto tipo short, y luego ya almacenarlo en uno de tipo byte.

¿Por qué numero2 es igual a -127?: Esto esta relacionado con el complemento a dos. Al ser negativo (el último bit de derecha a izquierda es igual a 1), es necesario aplicarle a los 6 primeros dicho complemento, con lo cual 0000001 se transforma en 1111110 (126 en decimal), y finalmente al sumarle 1 se obtiene el 127.


# short : 

el short tipo de datos es un entero complementario de dos firmado de 16 bits. Tiene un valor mínimo 
de -32.768 y un valor máximo de 32.767 (incluido). Al igual que con byte, se aplican las mismas pautas:
puede usar a short para guardar la memoria en arreglos grandes, en situaciones donde el ahorro de memoria
realmente importa.