Tipos Primitivos no Java.

A linguagem Java oferece vários tipos de dados, podemos dividi-los em dois tipos: os tipos primitivos e os tipos de referências. Neste tópico serão abordados os oito tipos primitivos do Java.


byte - tamanho de 8 bits com sinal, significa que pode representar de -128 até 127.

short - tamanho de 16 bits com sinal,  representa valores entre -32.768 até 32.767.

int - tamanho de 32 bits com sinal, representa valores entre  -2,147,483,648  até 2,147,483,647.

long - tamanho de 64 bits com sinal, representa valores entre -9,223,372,036,854,775,808 até  9,223,372,036,854,775,807.

boolean - somente dois valores possíveis, true ou false.

float - tamanho de 32 bits com sinal.

double - tamanho de 64 bits com sinal.

char - tamanho de 16 bits sem sinal, representa valores de 0 até 65.535.

Tipos com sinal

Em tipos com sinal, o bit mais a esquerda indica se o número é negativo "1" ou positivo "0".

byte Number = 7;
Representação em binário 00000111

byte Number = -7;
Representação em binário 11111001

Além do bit para indicar o sinal, um número quando representado em negativo, calcula-se o complemento de 2, e soma-se um. Portanto 00000111 após o complemento 11111000, somando 1 fica 11111001.

byte Number = 7;                // 00000111
Number = (byte)~Number;  // 11111000
Number += 1;                     // 11111001

Isto é apenas um exemplo, claro que para transformar um número positivo em negativo, basta multiplicar por menos um (-1).

Se um byte armazena valores entre -128 a 127, como armazenar valores de 0 a 255?
Da mesma forma, a diferença estará na representação do valor, nas conversões para outros tipos de variáveis, e nas comparações.


Apresentado o byte:

byte Number = -7;

this.jTextArea.append( Number + "\n" );                   // -7
this.jTextArea.append( (Number & 0xFF) + "\n" );   //  249


Conversão de byte (0..255) para short:

byte NumberA = (short)249;
short NumberB = (short)(NumberA & 0xFF);


this.jTextArea.append( NumberB + "\n" );   //  249

Neste caso, o que se deseja representar é o valor 249, e não o valor -7.

O que acontece na conversão Number & 0xFF é que a operação binaria ocorre com um byte e um tipo int, e o resultado é um int, portanto ele fica positivo.

byte -7 = 11111001

int FF  = 0000000011111111

O resultado da operação binária 11111001 & 0000000011111111 = 0000000011111001
Ou seja: 0000000011111001

O primeiro bit indica o sinal e ficou com zero (0), o número representado é um inteiro positivo, logo seu valor é 249.


Conparando um byte com um short:

byte NumberA = (byte)249;
short NumberB = 249;


if( NumberA == NumberB ) // Errado
{
   ....
}

Fazer um typecast, também não resolve:

if( (short)(NumberA) == NumberB ) // Errado

O valor de NumberA na verdade é -7, que é diferente de 249, para fazer a comparação correta, use a operação binária:

if( ( NumberA & 0xFF ) == NumberB ) // Certo

Já vi alguns programadores cometerem este engano e reclamarem da linguagem Java, estas operações não são específicas do Java, isto se aplica também para outras linguagens, como C#, C,  e outras. Desta forma, sempre que for comparar variáveis com sinal, e de tamanhos diferentes, as conversões binárias devem ser efetuadas.

Para os demais tipos, short, int, long se aplicam as mesmas regras.