Tipos de dados Java
Tipos de dados Java
Conforme explicado no capítulo anterior, uma variável em Java deve ser um tipo de dado especificado:
Exemplo
int myNum = 5; // Integer (whole number)
float myFloatNum = 5.99f; // Floating point number
char myLetter = 'D'; // Character
boolean myBool = true; // Boolean
String myText = "Hello"; // String
Os tipos de dados são divididos em dois grupos:
- Tipos de dados primitivos - inclui
byte
,short
,int
,long
,float
,double
eboolean
char
- Tipos de dados não primitivos - como String , Arrays e Classes (você aprenderá mais sobre eles em um capítulo posterior)
Tipos de dados primitivos
Um tipo de dados primitivo especifica o tamanho e o tipo de valores de variáveis e não possui métodos adicionais.
Existem oito tipos de dados primitivos em Java:
Data Type | Size | Description |
---|---|---|
byte | 1 byte | Stores whole numbers from -128 to 127 |
short | 2 bytes | Stores whole numbers from -32,768 to 32,767 |
int | 4 bytes | Stores whole numbers from -2,147,483,648 to 2,147,483,647 |
long | 8 bytes | Stores whole numbers from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 |
float | 4 bytes | Stores fractional numbers. Sufficient for storing 6 to 7 decimal digits |
double | 8 bytes | Stores fractional numbers. Sufficient for storing 15 decimal digits |
boolean | 1 bit | Stores true or false values |
char | 2 bytes | Stores a single character/letter or ASCII values |
Números
Os tipos de números primitivos são divididos em dois grupos:
Os tipos inteiros armazenam números inteiros, positivos ou negativos (como 123 ou -456), sem decimais. Os tipos válidos são byte
, short
e int
. long
O tipo que você deve usar depende do valor numérico.
Os tipos de ponto flutuante representam números com uma parte fracionária, contendo um ou mais decimais. Existem dois tipos: float
e double
.
Embora existam muitos tipos numéricos em Java, os mais usados para números são int
(para números inteiros) e double
(para números de ponto flutuante). No entanto, descreveremos todos eles à medida que você continuar lendo.
Tipos inteiros
Byte
O byte
tipo de dados pode armazenar números inteiros de -128 a 127. Isso pode ser usado em vez de int
ou outros tipos inteiros para economizar memória quando você tiver certeza de que o valor estará entre -128 e 127:
Exemplo
byte myNum = 100;
System.out.println(myNum);
Baixo
O short
tipo de dados pode armazenar números inteiros de -32768 a 32767:
Exemplo
short myNum = 5000;
System.out.println(myNum);
Int
O int
tipo de dados pode armazenar números inteiros de -2147483648 a 2147483647. Em geral, e em nosso tutorial, o int
tipo de dados é o tipo de dados preferido quando criamos variáveis com um valor numérico.
Exemplo
int myNum = 100000;
System.out.println(myNum);
Grandes
O long
tipo de dados pode armazenar números inteiros de -9223372036854775808 a 9223372036854775807. Isso é usado quando int não é grande o suficiente para armazenar o valor. Observe que você deve terminar o valor com um "L":
Exemplo
long myNum = 15000000000L;
System.out.println(myNum);
Tipos de ponto flutuante
Você deve usar um tipo de ponto flutuante sempre que precisar de um número com um decimal, como 9,99 ou 3,14515.
Flutuador
O float
tipo de dados pode armazenar números fracionários de 3.4e−038 a 3.4e+038. Observe que você deve terminar o valor com um "f":
Exemplo
float myNum = 5.75f;
System.out.println(myNum);
Dobro
O double
tipo de dados pode armazenar números fracionários de 1.7e−308 a 1.7e+308. Observe que você deve terminar o valor com um "d":
Exemplo
double myNum = 19.99d;
System.out.println(myNum);
Usar float
ou double
?
A precisão de um valor de ponto flutuante indica quantos dígitos o valor pode ter após o ponto decimal. A precisão de float
é de apenas seis ou sete dígitos decimais, enquanto double
as variáveis têm uma precisão de cerca de 15 dígitos. Portanto, é mais seguro usar double
para a maioria dos cálculos.
Números científicos
Um número de ponto flutuante também pode ser um número científico com um "e" para indicar a potência de 10:
Exemplo
float f1 = 35e3f;
double d1 = 12E4d;
System.out.println(f1);
System.out.println(d1);
Booleanos
Um tipo de dados booleano é declarado com a palavra- boolean
chave e só pode receber os valores true
ou false
:
Exemplo
boolean isJavaFun = true;
boolean isFishTasty = false;
System.out.println(isJavaFun); // Outputs true
System.out.println(isFishTasty); // Outputs false
Os valores booleanos são usados principalmente para testes condicionais, sobre os quais você aprenderá mais em um capítulo posterior.
Personagens
O char
tipo de dados é usado para armazenar um
único caractere. O caractere deve estar entre aspas simples, como 'A' ou 'c':
Exemplo
char myGrade = 'B';
System.out.println(myGrade);
Como alternativa, você pode usar valores ASCII para exibir determinados caracteres:
Exemplo
char myVar1 = 65, myVar2 = 66, myVar3 = 67;
System.out.println(myVar1);
System.out.println(myVar2);
System.out.println(myVar3);
Dica: Uma lista de todos os valores ASCII pode ser encontrada em nossa Referência de Tabela ASCII .
Cordas
O String
tipo de dados é usado para armazenar uma sequência de caracteres (texto). Os valores de string devem estar entre aspas duplas:
Exemplo
String greeting = "Hello World";
System.out.println(greeting);
O tipo String é tão usado e integrado em Java, que alguns o chamam de "o nono tipo especial".
Uma String em Java é na verdade um tipo de dado não primitivo , porque se refere a um objeto. O objeto String tem métodos que são usados para realizar certas operações em strings. Não se preocupe se você ainda não entende o termo "objeto" . Aprenderemos mais sobre strings e objetos em um capítulo posterior.
Tipos de dados não primitivos
Tipos de dados não primitivos são chamados de tipos de referência porque se referem a objetos.
A principal diferença entre tipos de dados primitivos e não primitivos são:
- Tipos primitivos são predefinidos (já definidos) em Java. Tipos não primitivos são criados pelo programador e não são definidos por Java (exceto para
String
). - Tipos não primitivos podem ser usados para chamar métodos para realizar certas operações, enquanto tipos primitivos não podem.
- Um tipo primitivo sempre tem um valor, enquanto tipos não primitivos podem ser
null
. - Um tipo primitivo começa com uma letra minúscula, enquanto os tipos não primitivos começam com uma letra maiúscula.
- O tamanho de um tipo primitivo depende do tipo de dados, enquanto os tipos não primitivos têm todos o mesmo tamanho.
Exemplos de tipos não primitivos são Strings , Arrays , Classes, Interface , etc. Você aprenderá mais sobre eles em um capítulo posterior.