Java pri­mi­ti­ves: Tudo sobre dados pri­mi­ti­vos em Java

Em Java existem oito tipos de dados pri­mi­ti­vos, cada um com um tamanho fixo e um intervalo de valores definido. Eles são usados para criar variáveis e atribuir números, ca­rac­te­res ou valores lógicos a elas. Os oito Java pri­mi­ti­ves são boolean, byte, char, double, float, int, long e short.

O que são Java pri­mi­ti­ves?

Em Java, assim como em outras lin­gua­gens de pro­gra­ma­ção, existem di­fe­ren­tes tipos de dados. Java define duas ca­te­go­rias prin­ci­pais: tipos de re­fe­rên­cia, que apontam para um objeto que pode ser li­vre­mente definido – exemplos incluem strings, arrays, classes e in­ter­fa­ces. Além disso, existem tipos de dados chamados de “pri­mi­ti­ves” em Java. Estes têm um tamanho fixo, que é idêntico em todas as pla­ta­for­mas. 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 pri­mi­ti­ves são usados para criar variáveis que armazenam números, ca­rac­te­res ou valores lógicos.

Em Java, existem oito tipos pri­mi­ti­vos di­fe­ren­tes, que são tão ele­men­ta­res que sua re­pre­sen­ta­ção é fixada na linguagem de pro­gra­ma­ção. Eles diferem prin­ci­pal­mente 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 par­ci­al­mente se­me­lhan­tes, os tipos de dados Java pri­mi­ti­ves são divididos em quatro ca­te­go­rias:

• 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 ar­ma­ze­na­dos di­re­ta­mente na pilha (stack), seu tamanho pode ser de grande im­por­tân­cia. Vamos explorar isso mais de­ta­lha­da­mente mais adiante. Os tipos pri­mi­ti­vos são também muito im­por­tan­tes porque Java é uma linguagem de tipagem estática. Portanto, quando um programa é criado, é ne­ces­sá­rio que o tipo de dados de uma variável seja conhecido e definido com an­te­ce­dên­cia. Só assim o código pode ser executado sem erros. Estes são os tipos pri­mi­ti­vos 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 é ne­ces­sá­rio um operando lógico e, portanto, pertence ex­clu­si­va­mente ao grupo dos tipos de dados lógicos. Em ex­pres­sões, seus dois valores possíveis fre­quen­te­mente re­pre­sen­tam uma condição que pode ser sa­tis­feita (true) ou não (false). Se você não atribuir um valor a um boolean, ele será au­to­ma­ti­ca­mente false. O boolean pode ser utilizado com ope­ra­do­res em Java booleanos como Java AND e OR. A atri­bui­çã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 ar­ma­ze­na­mento. O fato de 8 bits cor­res­pon­de­rem 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 pri­mi­ti­ves que é usado com menos frequên­cia. 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 é se­me­lhante 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 é re­la­ti­va­mente econômico em termos de espaço. O valor em com­ple­mento de dois é fre­quen­te­mente utilizado também para apli­ca­çõ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 cor­res­pon­dente:

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 é su­fi­ci­ente, 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 re­pre­sen­tar sub­con­jun­tos de números racionais, há dois tipos Java pri­mi­ti­ves 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 é adi­ci­o­nado para informar ao com­pi­la­dor 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 sig­ni­fi­ca­ti­va­mente mais preciso que float, ambos podem apre­sen­tar im­pre­ci­sões ao lidar com números de ponto flutuante muito grandes ou muito pequenos. Uma al­ter­na­tiva para obter precisão total é a classe BigDecimal. Se double for su­fi­ci­ente para suas ne­ces­si­da­des, aqui está um exemplo de código apro­pri­ado:

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 re­pre­sen­tar um caractere do Unicode, que vai de ‘\u0000’ até ‘\uffff’, ou seja, de 0 a 65535. Esse tipo de dado pode, portanto, re­pre­sen­tar quase todos os ca­rac­te­res europeus e asiáticos, uti­li­zando 16 bits de memória. Os valores desse tipo de dados Java pri­mi­ti­ves 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 apre­sen­tará esta saída:

&