Java primitives: Tudo sobre dados primitivos em Java

Em Java existem oito tipos de dados primitivos, cada um com um tamanho fixo e um intervalo de valores definido. Eles são usados para criar variáveis e atribuir números, caracteres ou valores lógicos a elas. Os oito Java primitives são boolean, byte, char, double, float, int, long e short.

O que são Java primitives?

Em Java, assim como em outras linguagens de programação, existem diferentes tipos de dados. Java define duas categorias principais: tipos de referência, que apontam para um objeto que pode ser livremente definido – exemplos incluem strings, arrays, classes e interfaces. Além disso, existem tipos de dados chamados de “primitives” em Java. Estes têm um tamanho fixo, que é idêntico em todas as plataformas. Todos eles possuem uma classe wrapper própria, são imutáveis e têm um intervalo de valores definido. Os tipos de dados Java primitives são usados para criar variáveis que armazenam números, caracteres ou valores lógicos.

Em Java, existem oito tipos primitivos diferentes, que são tão elementares que sua representação é fixada na linguagem de programação. Eles diferem principalmente em quais valores podem armazenar. Todos têm em comum o fato de conter apenas um valor. Como suas áreas de aplicação são pelo menos parcialmente semelhantes, os tipos de dados Java primitives são divididos em quatro categorias:

• Tipo lógico (boolean)
• Tipo integral (byte, short, int e long)
• Tipo de ponto flutuante (float e double)
• Tipo de caractere (char)

Como são armazenados diretamente na pilha (stack), seu tamanho pode ser de grande importância. Vamos explorar isso mais detalhadamente mais adiante. Os tipos primitivos são também muito importantes porque Java é uma linguagem de tipagem estática. Portanto, quando um programa é criado, é necessário que o tipo de dados de uma variável seja conhecido e definido com antecedência. Só assim o código pode ser executado sem erros. Estes são os tipos primitivos de Java em um olhar geral:

boolean

O Java boolean também é conhecido como valor de verdade. É o tipo primitivo mais simples em Java, pois conhece apenas dois valores possíveis: “true” ou “false”. É utilizado quando é necessário um operando lógico e, portanto, pertence exclusivamente ao grupo dos tipos de dados lógicos. Em expressões, seus dois valores possíveis frequentemente representam uma condição que pode ser satisfeita (true) ou não (false). Se você não atribuir um valor a um boolean, ele será automaticamente false. O boolean pode ser utilizado com operadores em Java booleanos como Java AND e OR. A atribuição segue o seguinte princípio:

public class Main {
	public static void main(String[] args) {
		boolean x = true;
		System.out.println(x);
	}
}

Quando você inicia uma saída com o comando Java System.out.println, ela aparece da seguinte forma:

true

byte

O byte é a menor opção na categoria dos tipos de dados integrais. Ele possui um intervalo de valores muito restrito, que vai de -128 a 127. No entanto, ele requer apenas 8 bits de espaço de armazenamento. O fato de 8 bits corresponderem a um byte é a razão de seu nome. Quando você trabalha com um intervalo muito limitado de valores, pode declarar um byte da seguinte forma:

public class Main {
	public static void main(String[] args) {
		byte x = 101;
		System.out.println(x);
	}
}

A saída fica assim:

101

short

O short é o dobro do tamanho do byte, mas também é um dos tipos Java primitives que é usado com menos frequência. No entanto, se o byte for pequeno demais e o int for grande demais, você pode usar esse tipo de dado integral. Ele é declarado da seguinte forma:

public class Main {
	public static void main(String[] args) {
		short x = -27412;
		System.out.println(x);
	}
}

A saída é semelhante a esta:

-27412

int

O int é o tipo de dado integral que é mais comumente utilizado. Ele tem um intervalo de valores muito grande e ainda é relativamente econômico em termos de espaço. O valor em complemento de dois é frequentemente utilizado também para aplicações mais avançadas. Você pode utilizá-lo da seguinte maneira:

public class Main {
	public static void main(String[] args) {
		int x = 14;
		int y = 3;
		int z = x + y;
		System.out.println(x + " + " + y + " = " + z);
	}
}

Esta é a saída correspondente:

14 + 3 = 17

long

O long é uma extensão do int e pode conter valores numéricos ainda maiores. Na maioria dos casos, o int é suficiente, mas se você precisar declarar um long, o processo é o seguinte:

public class Main {
	public static void main(String[] args) {
		long x = 47;
		System.out.println(x);
	}
}

Esta é a saída:

47

float

Se você deseja representar subconjuntos de números racionais, há dois tipos Java primitives para isso. O float é o menor dos dois tipos de dados de ponto flutuante e utiliza 32 bits. Ele pode exibir até sete casas decimais. No entanto, não é muito preciso e, portanto, é raramente utilizado. Caso precise usá-lo, ele é declarado da seguinte forma:

public class Main {
	public static void main(String[] args) {
		float x = 7.22f;
		System.out.println(x);
	}
}

Após o número, um “f” minúsculo ou maiúsculo é adicionado para informar ao compilador que se trata de um float e não de um double. Na saída, a letra não é exibida:

7.22

double

O segundo tipo de dado de ponto flutuante é double. Embora ele seja significativamente mais preciso que float, ambos podem apresentar imprecisões ao lidar com números de ponto flutuante muito grandes ou muito pequenos. Uma alternativa para obter precisão total é a classe BigDecimal. Se double for suficiente para suas necessidades, aqui está um exemplo de código apropriado:

public class Main {
	public static void main(String[] args) {
		double x = 7.2252;
		System.out.println(x);
	}
}

Você pode, portanto, dispensar o dígito adicional. Esta é a saída:

7.2252

char

O char é utilizado para representar um caractere do Unicode, que vai de ‘\u0000’ até ‘\uffff’, ou seja, de 0 a 65535. Esse tipo de dado pode, portanto, representar quase todos os caracteres europeus e asiáticos, utilizando 16 bits de memória. Os valores desse tipo de dados Java primitives são colocados entre aspas simples. Veja como isso fica no código:

public class Main {
	public static void main(String[] args) {
		char x = '&';
		System.out.println(x);
	}
}

O código apresentará esta saída:

&