Types de données de base Java

Une variable est utilisée pour allouer de la mémoire afin de stocker des valeurs. Autrement dit, lorsque vous créez une variable, vous devez allouer de l'espace en mémoire.

Le système de gestion de la mémoire alloue un espace de stockage à la variable en fonction de son type, et l'espace alloué ne peut être utilisé que pour stocker des données de ce type.

Par conséquent, en définissant des variables de différents types, vous pouvez stocker des entiers, des nombres décimaux ou des caractères en mémoire.

Les deux principaux types de données de Java :

Types de données intégrés
Types de données de référence

Types de données intégrés

Le langage Java fournit huit types primitifs. Six types numériques (quatre types entiers, deux types à virgule flottante), un type caractère et un type booléen.

byte：

Le type de données byte est un entier signé de 8 bits représenté en complément à deux ;
La valeur minimale est-128（-2^7）；
La valeur maximale est127（2^7-1）；
La valeur par défaut est0；
Le type byte est utilisé dans les grands tableaux pour économiser de l'espace, principalement en remplacement des entiers, car une variable byte n'occupe qu'un quart de l'espace d'un type int ;
Exemple : byte a = 100, byte b = -50.

short :

Le type de données short est un entier signé de 16 bits représenté en complément à deux ;
La valeur minimale est-32768（-2^15）；
La valeur maximale est32767（2^15 - 1）；
Le type de données short peut également économiser de l'espace comme le type byte. Une variable short occupe la moitié de l'espace occupé par une variable int ;
La valeur par défaut est0；
Exemple : short s = 1000, short r = -20000.

int :

Le type de données int est un entier signé de 32 bits représenté en complément à deux ;
La valeur minimale est-2,147,483,648（-2^31）；
La valeur maximale est2,147,483,647（2^31 - 1）；
En général, les variables entières ont par défaut le type int ;
La valeur par défaut est0 ；
Exemple : int a = 100000, int b = -200000.

long :

Le type de données long est un entier signé de 64 bits représenté en complément à deux ;
La valeur minimale est-9,223,372,036,854,775,808（-2^63）；
La valeur maximale est9,223,372,036,854,775,807（2^63 -1）；
Ce type est principalement utilisé dans les systèmes qui nécessitent des entiers relativement grands ;
La valeur par défaut est0L；
Exemple :long a = 100000L，long b = -200000L。
"L" est théoriquement insensible à la casse, mais s'il est écrit "l", il est facile de le confondre avec le nombre "1" et difficile à distinguer. Il est donc préférable d'utiliser une majuscule.

float :

Le type de données float est un nombre à virgule flottante simple précision de 32 bits conforme à la norme IEEE 754 ;
float peut économiser de l'espace mémoire lors du stockage de grands tableaux de nombres à virgule flottante ;
La valeur par défaut est0.0f；
Les nombres à virgule flottante ne peuvent pas être utilisés pour représenter des valeurs précises, comme la monnaie ;
Exemple : float f1 = 234.5f.

double :

Le type de données double est un nombre à virgule flottante double précision de 64 bits conforme à la norme IEEE 754 ;
Le type par défaut des nombres à virgule flottante est double ;
Le type double ne peut pas non plus représenter des valeurs précises, comme la monnaie ;
La valeur par défaut est0.0d；

Exemple :

double   d1  = 7D ;
double   d2  = 7.; 
double   d3  =  8.0; 
double   d4  =  8.D; 
double   d5  =  12.9867;

7 est un littéral int, tandis que 7D, 7. et 8.0 sont des littéraux double.

boolean :

Le type de données boolean représente un bit d'information ;
Il n'a que deux valeurs : true et false ;
Ce type n'est utilisé que comme un indicateur pour enregistrer des conditions true/false ;
La valeur par défaut estfalse；
Exemple : boolean one = true.

char：

Le type char est un seul caractère Unicode de 16 bits ;
La valeur minimale est\u0000(l'équivalent décimal est 0);
La valeur maximale est\uffff(i.e., 65535);
Le type de données char peut stocker n'importe quel caractère ;
Exemple : char letter = 'A';.

Exemple

Pour les plages de valeurs des types primitifs numériques, nous n'avons pas besoin de les mémoriser de force, car leurs valeurs sont déjà définies comme des constantes dans les classes wrapper correspondantes. Voir l'exemple ci-dessous :

Exemple

public class PrimitiveTypeTest { public static void main(String[] args) { // byte System.out.println("Type primitif : byte Chiffres binaires :" + Byte.SIZE); System.out.println("Classe enveloppe : java.lang.Byte"); System.out.println("Valeur minimale : Byte.MIN_VALUE=" + Byte.MIN_VALUE); System.out.println("Valeur maximale : Byte.MAX_VALUE=" + Byte.MAX_VALUE); System.out.println(); // short System.out.println("Type primitif : short Chiffres binaires :" + Short.SIZE); System.out.println("Classe enveloppe : java.lang.Short"); System.out.println("Valeur minimale : Short.MIN_VALUE=" + Short.MIN_VALUE); System.out.println("Valeur maximale : Short.MAX_VALUE=" + Short.MAX_VALUE); System.out.println(); // int System.out.println("Type primitif : int Chiffres binaires :" + Integer.SIZE); System.out.println("Classe enveloppe : java.lang.Integer"); System.out.println("Valeur minimale : Integer.MIN_VALUE=" + Integer.MIN_VALUE); System.out.println("Valeur maximale : Integer.MAX_VALUE=" + Integer.MAX_VALUE); System.out.println(); // long System.out.println("Type primitif : long Chiffres binaires :" + Long.SIZE); System.out.println("Classe enveloppe : java.lang.Long"); System.out.println("Valeur minimale : Long.MIN_VALUE=" + Long.MIN_VALUE); System.out.println("Valeur maximale : Long.MAX_VALUE=" + Long.MAX_VALUE); System.out.println(); // float System.out.println("Type primitif : float Chiffres binaires :" + Float.SIZE); System.out.println("Classe enveloppe : java.lang.Float"); System.out.println("Valeur minimale : Float.MIN_VALUE=" + Float.MIN_VALUE); System.out.println("Valeur maximale : Float.MAX_VALUE=" + Float.MAX_VALUE); System.out.println(); // double System.out.println("Type primitif : double Chiffres binaires :" + Double.SIZE); System.out.println("Classe enveloppe : java.lang.Double"); System.out.println("Valeur minimale : Double.MIN_VALUE=" + Double.MIN_VALUE); System.out.println("Valeur maximale : Double.MAX_VALUE=" + Double.MAX_VALUE); System.out.println(); // char System.out.println("Type primitif : char Chiffres binaires :" + Character.SIZE); System.out.println("Classe enveloppe : java.lang.Character"); //Afficher Character.MIN_VALUE dans la console en tant que valeur numérique plutôt qu'en tant que caractère. System.out.println("Valeur minimale : Character.MIN_VALUE=" + (int) Character.MIN_VALUE); //Afficher Character.MAX_VALUE dans la console en tant que valeur numérique plutôt qu'en tant que caractère. System.out.println("Valeur maximale : Character.MAX_VALUE=" + (int) Character.MAX_VALUE); } }

Exécuter l'exemple »

La compilation du code ci-dessus produit la sortie suivante :

基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127

基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767

基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647

基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807

基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38

基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308

基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535

Les valeurs minimale et maximale de Float et Double sont toutes deux affichées en notation scientifique. Le "E+nombre" final indique que le nombre avant E doit être multiplié par 10 à la puissance de ce nombre. Par exemple, 3.14E3 est 3.14 × 10³=3140, et 3.14E-3 est 3.14 x 10^-3 =0.00314.

En fait, il existe un autre type primitif en Java, void, qui possède également une classe enveloppe correspondante java.lang.Void, mais nous ne pouvons pas les manipuler directement.

Valeurs par défaut des types

Le tableau suivant répertorie les valeurs par défaut de chaque type Java :

Type de données	Valeur par défaut
int	0
long	0L
short	0
char	'\u0000'
octet	0
float	0.0f
double	0.0d
booléen	false
Types de référence (classes, interfaces, tableaux)	null

Notes :

int, short, long, byteLa valeur par défaut est 0.
charLa valeur par défaut est\u0000(caractère nul).
floatLa valeur par défaut est0.0f。
doubleLa valeur par défaut est0.0d。
booleanLa valeur par défaut estfalse。
La valeur par défaut pour les types de référence (classes, interfaces, tableaux) estnull。

Exemple

public class Test { static boolean bool; static byte by; static char ch; static double d; static float f; static int i; static long l; static short sh; static String str; public static void main(String[] args) { System.out.println("Bool :" + bool); System.out.println("Byte :" + by); System.out.println("Character:" + ch); System.out.println("Double :" + d); System.out.println("Float :" + f); System.out.println("Integer :" + i); System.out.println("Long :" + l); System.out.println("Short :" + sh); System.out.println("String :" + str); } }

Les sorties de l'exemple :

Bool     :false
Byte     :0
Character:
Double   :0.0
Float    :0.0
Integer  :0
Long     :0
Short    :0
String   :null

Types de référence

En Java, les variables de type référence sont très similaires aux pointeurs en C/C++. Un type référence pointe vers un objet, et la variable qui pointe vers l'objet est une variable de référence. Ces variables sont spécifiées comme un type spécifique lors de la déclaration, tel que Employee, Puppy, etc. Une fois qu'une variable est déclarée, son type ne peut pas être modifié.
Les objets et les tableaux sont des types de données de référence.
La valeur par défaut de tous les types de référence est null.
Une variable de référence peut être utilisée pour référencer tout type compatible.
Exemple : Site site = new Site("Example").

Constantes Java

Les constantes ne peuvent pas être modifiées pendant l'exécution du programme.

En Java, le mot-clé final est utilisé pour modifier des constantes. La méthode de déclaration est similaire à celle des variables :

final double PI = 3.1415927;

Bien que les noms de constantes puissent aussi être en minuscules, pour faciliter l'identification, on utilise généralement des lettres majuscules pour les constantes.

Les littéraux peuvent être affectés à des variables de tout type intégré. Par exemple :

byte a = 68;
char a = 'A'

byte, int, long et short peuvent tous être représentés en décimal, en hexadécimal et en octal.

Lors de l'utilisation de littéraux, le préfixe0indique l'octal, tandis que le préfixe0xreprésente l'hexadécimal, par exemple :

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

Comme dans d'autres langages, les constantes de chaîne Java sont aussi des séquences de caractères encadrées par deux guillemets. Voici des exemples de littéraux de chaîne :

"Hello World"
"two\nlines"
"\"This is in quotes\""

Les constantes de chaîne et les variables de caractère peuvent contenir n'importe quels caractères Unicode. Par exemple :

char a = '\u0001';
String a = "\u0001";

Le langage Java prend en charge certaines séquences d'échappement spéciales.

Symbole	Signification du caractère
\n	Nouvelle ligne (0x0a)
\r	Retour chariot (0x0d)
\f	Saut de page (0x0c)
\b	Retour arrière (0x08)
\0	Caractère nul (0x0)
\s	Espace (0x20)
\t	Onglet
\"	Guillemet double
\'	Guillemet simple
\\	Barre oblique inversée
\ddd	Caractère octal (ddd)
\uxxxx	Caractère Unicode hexadécimal (xxxx)

Conversion de type automatique

Les données de type entier, réel (constante) et caractère peuvent être mélangées dans les opérations. Lors des opérations, les différents types de données sont d'abord convertis vers le même type, puis l'opération est effectuée.

La conversion se fait du niveau inférieur vers le niveau supérieur.

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double

La conversion de type de données doit respecter les règles suivantes :

1. La conversion de type ne peut pas être effectuée sur le type booléen.
2. Les types objet ne peuvent pas être convertis en objets de classes sans rapport.
3. Lors de la conversion d'un type de plus grande capacité vers un type de plus petite capacité, une conversion de type forcée (cast) doit être utilisée.
4. Le processus de conversion peut provoquer un dépassement de capacité ou une perte de précision, par exemple :
```
int i =128;   
byte b = (byte)i;
```
Comme le type byte fait 8 bits et que sa valeur maximale est 127, lorsqu'un int est converti de force en byte, la valeur 128 provoquera un dépassement.
5. La conversion d'un nombre à virgule flottante en entier se fait en supprimant la partie fractionnaire, et non par arrondi, par exemple :
```
(int)23.7 == 23;        
(int)-45.89f == -45
```

Conversion de type automatique

La largeur de bits du type de données avant conversion doit être inférieure à celle du type de données après conversion. Par exemple : le type de données short a 16 bits, il peut donc être automatiquement converti en type int avec 32 bits ; de même, le type de données float a 32 bits et peut être automatiquement converti en type double avec 64 bits.

Exemple

public class ZiDongLeiZhuan{ public static void main(String[] args){ char c1='a';//Définir un type char int i1 = c1;//char automatiquement converti en int System.out.println("La valeur après conversion automatique de char en int est égale à"+i1); char c2 = 'A';//Définir un type char int i2 = c2+1;//Calculer avec le type char et le type int System.out.println("La valeur après calcul du type char et du type int est égale à"+i2); } }

Le résultat d'exécution est :

char自动类型转换为int后的值等于97
char类型和int计算后的值等于66

Analyse :La valeur de c1 est le caractèrea, la consultation de la table ASCII montre que la valeur int correspondante est 97, et A correspond à 65, donci2=65+1=66。

Conversion de type

1. La condition est que les types de données en cours de conversion doivent être compatibles.
2. Format : (type)value, où type est le type de données après conversion de type forcée. Exemple :

Exemple

public class ForceTransform { public static void main(String[] args){ int i1 = 123; byte b = (byte)i1;//Conversion de type forcée en byte System.out.println("La valeur après conversion de type forcée de int en byte est égale à"+b); } }

Résultat de l'exécution:
```
int强制类型转换为byte后的值等于123
```

Conversion de type implicite

1. Le type par défaut pour les entiers est int.
2. Les nombres décimaux sont par défaut du type à virgule flottante double ; lors de la définition d'un type float, vous devez ajouter F ou f après le nombre.

Cette section a expliqué les types de données de base de Java. La section suivante abordera les différents types de variables et leur utilisation.

Autres extensions

Java Orienté objet

Java Tutoriel avancé

Types de données de base Java

Types de données intégrés

Exemple

Exemple

Valeurs par défaut des types

Exemple

Types de référence

Constantes Java

Conversion de type automatique

Conversion de type automatique

Exemple

Conversion de type

Exemple

Conversion de type implicite