Tipos de Dados Java

Este artigo visa facilitar a compreensão dos tipos de dados Java , avaliando-os e fornecendo exemplos .

Tipos de Dados JAVA

Tipos de Dados Java

Em Java, uma variável deve ser um determinado tipo de dados, conforme discutido no capítulo anterior:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Main {
public static void main(String[] args) {
int my_num = 25; // integer (whole number)
float my_Float_num = 5.99f; // floating point number
char my_Letter = 'D'; // character
boolean my_Bool = true; // boolean
String my_Words = "Hello am learning Java Data Types"; // String
System.out.println(my_num);
System.out.println(my_Float_num);
System.out.println(my_Letter);
System.out.println(my_Bool);
System.out.println(my_Words);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Main {
public static void main(String[] args) {
String mrx_string="This is a String data type";
float ample_PI_value=3.142f; // This is a float data type
int mrx=45; // this represents an integer
boolean isJavaEasy=true; // The boolean value is represented here
char mrx_start='J'; // Shows the character data type
System.out.println(mrx_string);
System.out.println(ample_PI_value);
System.out.println(mrx);
System.out.println(isJavaEasy);
System.out.println("The word Java starts with : "+mrx_start);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Existem duas categorias de tipos de dados ao discutir os tipos de dados Java :

  1. Tipos de dados primitivos – inclui byte, short, int, long, float, double, boolean e char
  2. Tipos de dados não primitivos – como String , Arrays e Classes (os próximos capítulos fornecerão mais informações sobre esses tipos de dados não primitivos).
Índice-

Tipos de dados primitivos

O tipo de dados primitivo descreve apenas o tamanho e o tipo dos valores das variáveis. Falta-lhe quaisquer funções extras.

Java suporta os seguintes oito tipos de dados primitivos :

Tipo de dados Tamanho Visão geral
byte 1 byte Armazena números inteiros com um intervalo entre -128 e 127.
curto 2 bytes Suporta todo o intervalo de números inteiros entre -32.768 e 32.767.
int 4 bytes Armazena números inteiros de -2.147.483.648 a 2.147.483.647.
longo 8 bytes Contém os números inteiros entre -9.223.372.036.854.775.808 e 9.223.372.036.854.775.807
flutuador 4 bytes Números fracionários são armazenados. Suficiente para armazenar seis a sete dígitos decimais
dobro 8 bytes Números fracionários são armazenados. Suficiente para armazenar 15 dígitos decimais
boleano 1 bit Contém valores para verdadeiro ou falso.
Caracteres 2 bytes Um único caractere, letra ou valores ASCII são armazenados.

Números

No que diz respeito aos tipos de dados Java, os tipos numéricos primitivos podem ser divididos em duas categorias principais:

Ao contrário dos tipos decimais, os tipos inteiros armazenam números inteiros (como 786 ou -987). Existem quatro tipos válidos: byte , short , integer e long .

Dependendo do valor numérico, você deve usar o tipo apropriado .

Um valor de ponto flutuante representa números contendo partes fracionárias e decimais. O tipo de dados é float ou double .

Os tipos numéricos mais comumente usados ​​em Java são int (para números inteiros) e double (para números de ponto flutuante). À medida que você lê, vamos descrevê-los todos.

Tipos inteiros

 

Tipo de byte:

Os bytes podem armazenar números inteiros entre -128 e 127. Se você tiver certeza de que o valor estará entre -128 e 127, um byte pode ser usado em vez de um int .

Example: 

1
2
3
4
5
6
7
8
9
10
11
public class Main {
public static void main(String[] args) {
byte my_number = 110;
System.out.println(my_number);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Main {
public static void main(String[] args) {
byte my_number = 126; // Byte ranges from -128 to 127
System.out.println("Byte value= "+my_number);
}
// Output : Byte value = 126
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Tipo Int:

É possível armazenar números inteiros entre -2147483648 e 2147483647 usando o tipo de dados int . Ao criar variáveis ​​com valores numéricos, o tipo de dados int é o tipo de dados preferencial.

Example: 

1
2
3
4
5
6
7
8
9
10
11
public class Main {
public static void main(String[] args) {
int my_Number = 120000;
System.out.println(my_Number);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
public class Main {
public static void main(String[] args) {
int my_Number = 32423000;
System.out.println(my_Number);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Tipo Curto:

Tipos de dados curtos podem armazenar números inteiros entre -32768 e 32767:

Example: 

1
2
3
4
5
6
7
8
9
10
11
public class Main {
public static void main(String[] args) {
short my_ short_num = 6000;
System.out.println(my_short_num);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
public static void main(String[] args) {
short my_short_num = 32767; // Displays the biggest possible number from the short data type range
System.out.println(my_short_num);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Tipo longo:

Tipos de dados longos podem armazenar números inteiros de -9223372036854775808 a 9223372036854775807. O valor é armazenado aqui quando int não é grande o suficiente para contê-lo. Em tipos de dados Java , você deve terminar o valor com um “L”:

Example: 

1
2
3
4
5
6
7
8
9
10
11
public class Main {
public static void main(String[] args) {
long my_long_num = 17000000000L;
System.out.println(my_long_num);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
public class Main {
public static void main(String[] args) {
long ample_long_num = 3120400000000L;
System.out.println(ample_long_num);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Tipos de ponto flutuante

Em tipos de dados Java, um tipo de ponto flutuante é mais adequado para números com decimais , como 9,99 ou 3,14515.

Flutuador:

No tipo de dados float, os números fracionários podem variar de 3,4eâˆ'038 a 3,4e+038. O valor deve terminar com um “ f ”:

Example: 

1
2
3
4
5
6
7
8
9
10
11
public class Main {
public static void main(String[] args) {
float my_float_num = 7.85f;
System.out.println(my_float_num);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
public class Main {
public static void main(String[] args) {
float mrx_float_num = 46.1241f;
System.out.println(mrx_float_num);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Dobro:

Tipos de dados duplos podem armazenar números fracionários de 1,7e-308 a 1,7e+308. Em Java, você deve terminar o valor com um “d”:

Example: 

1
2
3
4
5
6
7
8
9
10
11
public class Main {
public static void main(String[] args) {
double my_Double_num = 20.29d;
System.out.println(my_Double_num);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
public class Main {
public static void main(String[] args) {
double ample_Double_num = 14.5234123112312d;
System.out.println(ample_Double_num);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

É melhor usar floats ou doubles?

A precisão do ponto flutuante refere-se a quantos dígitos o valor pode ter após o ponto decimal.

Uma variável float tem uma precisão de apenas seis ou sete dígitos decimais , enquanto as variáveis ​​double têm uma precisão de cerca de 15 dígitos.

Portanto, a maioria dos cálculos é mais segura quando feita com doubles .

Números Científicos:

Números de ponto flutuante também podem ser números científicos indicando a potência de 10 com um “ e ”:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
public static void main(String[] args) {
float float_Num = 85e4f;
double double_Num = 32E5d;
System.out.println(float_Num);
System.out.println(double_Num);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Main {
public static void main(String[] args) {
float float_mrx = 126e3f;
double double_ample = 62E5d;
System.out.println(float_mrx);
System.out.println(double_ample);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Booleanos

Os booleanos podem receber apenas valores verdadeiros ou falsos e são declarados com a palavra-chave booleana :

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
public static void main(String[] args) {
boolean isJavaEasy = true;
boolean isJavaHard = false;
System.out.println(isJavaEasy);
System.out.println(isJavaHard);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Main {
public static void main(String[] args) {
boolean isMatch_Tricky = true;
boolean isMath_Fun =true;
boolean maths_Is_My_Favourite=false;
System.out.println(isMatch_Tricky);
System.out.println(isMath_Fun);
System.out.println(maths_Is_My_Favourite);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O principal uso de valores booleanos é o teste condicional, que você descobrirá no próximo capítulo.

Personagens

Um tipo de dados char armazena um único caractere. Quando se trata de tipos de dados Java , o caractere deve estar entre aspas simples, como 'A' ou 'c':

Example: 

1
2
3
4
5
6
7
8
9
10
11
public class Main {
public static void main(String[] args) {
char my_Final_Grade = 'A';
System.out.println(my_Final_Grade);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
public static void main(String[] args) {
char first_Alphabet_Of_Java = 'J';
System.out.println("First letter of word Java is: "+first_Alphabet_Of_Java);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Você também pode exibir certos caracteres usando valores ASCII:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
public static void main(String[] args) {
char my_char1 = 67, my_char2 = 66, my_char3 = 65;
System.out.println(my_char1);
System.out.println(my_char2);
System.out.println(my_char3);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Main {
public static void main(String[] args) {
char my_char1 = 74, my_char2 = 65, my_char3 = 86 , my_char4= 65 ;
System.out.println(my_char1);
System.out.println(my_char2);
System.out.println(my_char3);
System.out.println(my_char4);
}
// Output :
// J
// A
// V
// A
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

 

Cordas

O tipo de dados String é usado para armazenar uma sequência de caracteres (texto) em Java. Para usar valores de string, aspas duplas devem ser usadas:

Example: 

1
2
3
4
5
6
7
8
9
10
11
public class Main {
public static void main(String[] args) {
String introduction = "We are learning about java data types in this chapter";
System.out.println(introduction);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
public class Main {
public static void main(String[] args) {
String java_Intro = "Java Programming Language was founded by James Gosling at 23rd May, 1995";
System.out.println(java_Intro);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Alguns se referem a String como “o nono tipo especial” em Java porque é amplamente utilizado.

Strings são, na verdade , tipos de dados Java não primitivos , pois se referem a objetos.

Existem métodos no objeto String que podem ser usados ​​para realizar certas operações em strings.

Você não precisa se preocupar se não entender o que significa “ objeto ”.

Em um capítulo posterior, aprenderemos mais sobre strings e objetos.

Tipos de dados não primitivos

Por se referirem a objetos , os tipos de dados não primitivos são chamados de tipos de referência.

Os tipos de dados primitivos e não primitivos diferem das seguintes maneiras:

  • Em Java, os tipos primitivos são predefinidos (já definidos).
  • Os tipos não primitivos são criados pelo programador e não são definidos por Java (exceto para Strings).
  • Em contraste com os tipos primitivos, os tipos não primitivos podem chamar métodos para executar determinadas operações.
  • Os tipos primitivos sempre têm um valor, enquanto os tipos não primitivos podem ser nulos.
  • Os tipos primitivos começam 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 de seu tipo de dados, enquanto o tamanho de um tipo não primitivo é o mesmo.

Agora você sabe em detalhes quais são os tipos de dados Java. Strings , Arrays , Classes , Interfaces , etc., são exemplos de tipos não primitivos . Um capítulo posterior discutirá esses tópicos com mais detalhes.

Nós valorizamos o seu feedback.
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
Assine a nossa newsletter
Digite seu e-mail para receber um resumo semanal de nossos melhores posts. Saber mais!
ícone
Ao assinar, você concorda com nossa política de privacidade e nossos termos de serviço.