Types de données en Java : types de données primitifs et non primitifs
Publié: 2020-12-01Table des matières
introduction
Dans tout langage de programmation, un type de données est un attribut de données qui permet à l'ordinateur ou au compilateur de savoir comment les programmeurs veulent affecter les données. Un type de données ajoute une restriction aux variables ou à une fonction lors de l'affectation de valeurs.
Ces types de données définissent le comportement des données, comme la façon dont les valeurs de ce type peuvent être stockées et les opérations qui peuvent être effectuées sur les données. Jetons un coup d'œil à tous les types de données fournis par java.
Types de données primitifs
Un type de données primitif ne peut pas être subdivisé en un type de données plus simple. Java fournit 8 types de données primitifs, explorons-les !
Octet
Un octet est un type entier qui stocke des nombres entiers allant de -128 à 127, cela efface les problèmes de contrainte de mémoire si vous avez affaire à de petits nombres car il ne nécessite qu'un octet de mémoire. Une variable byte peut être déclarée à l'aide du mot-clé « byte ». L'attribution d'une valeur supérieure à 127 à un octet génère une erreur "types incompatibles".
| octet n1 = 98 ; Système . dehors . println(n1); |
L'extrait ci-dessus imprime 98 comme prévu.
Court
Un short est un type Integer qui stocke des nombres entiers allant de -32768 à 32767, il consomme 2 octets de mémoire sur le disque. Une variable courte peut être déclarée en utilisant le mot-clé « short ». L'attribution d'une valeur supérieure à 32767 à une variable courte génère une erreur "types incompatibles".
| court n1 = 9876 ; Système . dehors . println(n1); |
L'extrait ci-dessus imprime 9876 en sortie.
Int
Un int est un type entier qui stocke des nombres entiers allant de -2147483648 à 2147483647, il consomme 4 octets de mémoire sur le disque. Généralement, les programmeurs préfèrent utiliser un int pour déclarer une variable qui stocke des valeurs numériques. Le compilateur Java génère une erreur "types incompatibles" s'il tente d'attribuer une valeur supérieure à la plage.
| int n1 = 987654 ; Système . dehors . println(n1); |
L'extrait ci-dessus imprime 987654 comme sortie.
Long
Maintenant, c'est quelque chose de type de données intéressant qui consomme 8 octets de mémoire sur le disque. C'est un type entier qui stocke des nombres entiers allant de -9223372036854775808 à 9223372036854775807, ouf qui prend un temps considérable pour lire cette plage.
Ceci est utilisé lorsque le type de données int déborde pour les opérations que nous effectuons. N'oubliez pas que nous devons terminer la valeur par un "L" lors de l'attribution.
| long n1 = 987654321098765L ; Système . dehors . println(n1); |
L'extrait ci-dessus imprime 987654321098765, comme prévu.
Flotter
Float est un type de données à virgule flottante, ce qui signifie qu'il peut stocker les valeurs, y compris leur précision décimale. Supposons que vous ayez développé un code pour noter toutes vos dépenses, mais que vous soyez assez strict et que vous vouliez garder une trace de chaque centime que vous avez dépensé. Dans ce cas, int ne fera pas le travail car int ne peut stocker que des nombres entiers.
Nous avons besoin d'un type de données à virgule flottante pour cette tâche. Un flottant peut stocker les nombres fractionnaires allant de 3.4e-038 à 3.4e+038, il peut stocker jusqu'à 7 chiffres en précision décimale. N'oubliez pas que vous devez terminer la valeur par un 'f'.
| flottant n = 98.76f ; Système . dehors . println(n); |
L'extrait ci-dessus imprime 98,76 en sortie.
Lire : Propriétés et avantages des JavaBeans : comment les utiliser ?
Double
Double est similaire à float, mais comme son nom l'indique, c'est le double du float dans le cas d'une précision décimale. Il peut avoir une précision décimale à 15 chiffres et peut stocker des nombres fractionnaires allant de 1,7e-308 à 1,7e+308. N'oubliez pas que vous devez terminer la valeur par un "d".
Passons en revue un code pour comprendre la différence entre float et double.
| test de classe publique { public static void main ( Chaîne args[]) { flottant a1 = 1.f / 70 ; flotteur b1 = 0 ; double a2 = 1.d / 70 ; double b2 = 0 ; flottant f1 = 1f ; double f2 = 1d ; pour ( int je = 0 ; je < 490 ; je ++ ){ b1 = b1 + a1 ; b2 = b2 + a2 ; si (je > 1 && je <= 50 ){ f1 = f1 * je ; f2 = f2 * je ; } } Système . dehors . println(b1); //ligne 1 Système . dehors . println(b2); //ligne 2 Système . dehors . println(f1); //ligne3 Système . dehors . println(f2); //ligne4 } } |
Le calcul en main de l'expression "(1/70)*490" nous donne 7 comme réponse, mais l'exécuter en Java en utilisant float et double donne une réponse différente. Dans l'extrait ci-dessus, une variable flottante et une variable double sont initialisées avec 1/70, et l'ajout de cette valeur à une autre variable 490 fois devrait nous donner 7 comme réponse.
Lors de l'exécution de l'extrait de code ci-dessus, la ligne 1 imprime 6,9999795 qui a une précision décimale à 7 chiffres, tandis que la ligne 2 imprime 6,99999999999978 qui a une précision décimale à 15 chiffres. Donc, si float ne vous fournit pas une précision décimale précise, vous pouvez opter pour double. De plus, un flotteur est plus susceptible d'atteindre l'infini car la plage de flotteur est inférieure à celle du double.
Par exemple, si vous stockez la factorielle d'un nombre considérablement grand, cette variable atteint l'infini. À partir de l'extrait ci-dessus, nous pouvons voir qu'il y a deux variables utilisées pour stocker la factorielle de 50 et au moment où nous imprimons le résultat, la ligne 3 imprime l'infini et la ligne 4 imprime 3.0414093201713376E64, donc si float ne correspond pas à votre numérique gamme alors vous pouvez opter pour le double.
Float et double peuvent être utilisés comme nombres scientifiques avec un « e », où « e » dénote la puissance de 10. Par exemple, 3e2f équivaut à 300,0 dans le type de données float et 3e4d équivaut à 30 000,0 dans le type de données double.
booléen
Un type de données booléen ne peut prendre que deux valeurs vrai et faux, il est déclaré en utilisant le mot-clé booléen en java. Ce type de données est généralement utilisé comme variable d'indicateur pour garder une trace des changements que nous effectuons dans un code. Par exemple, définir le drapeau sur vrai si un nombre est divisible par 2 sinon faux.
| drapeau booléen = vrai ; booléen b1 = faux ; Système . dehors . println(drapeau); // imprime vrai Système . dehors . println(b1); // imprime faux |
Carboniser
Un type de données char est utilisé pour stocker un seul caractère, ce type de données peut être déclaré à l'aide du mot-clé char. N'oubliez pas que nous devons placer le caractère entre guillemets simples lors de l'attribution, il peut stocker à la fois des caractères minuscules et majuscules dans un type de données char.
Le stockage de plusieurs caractères dans un type de données char génère une erreur. De plus, il y a un fait amusant concernant le type de données char qui est que la conversion d'un char en un entier stocke la valeur ASCII de ce caractère, et vice versa est également vrai.
| char c1 = ' une ' ; car c2 = 66 ; Système . dehors . println(c1); //ligne 1 Système . dehors . println(c2); //ligne 2 Système . dehors . println(( int )c1); //ligne3 |
Dans l'extrait de code 1 ci-dessus, imprime 'a' en sortie, ce qui est comme prévu. La ligne 2 imprime 'B' en sortie puisque 66 fait référence à B dans la table ASCII. La ligne 3 imprime 97 en sortie puisqu'il s'agit de la valeur ASCII de 'a'.
Mais que se passe-t-il si nous voulons stocker plus d'un caractère ? Nous y reviendrons dans les prochains paragraphes.
Lisez aussi: 17 idées et sujets de projets Java intéressants pour les débutants
Types de données non primitifs
Les types de données non primitifs en Java sont également appelés types de référence car ils font référence à des objets. Les types de données non primitifs sont créés par le programmeur et ne sont pas prédéfinis. Étant donné que les non-primitifs sont appelés objets, ils peuvent être affectés avec null, ce qui n'est pas le cas dans le type primitif.
Contrairement aux types de données primitifs, un type de données non primitif doit commencer par une lettre majuscule. Tous les types de données non primitifs sont de taille égale et consomment la même mémoire sur le disque, ce qui est différent dans le cas des types de données primitifs.
Chaîne de caractères
Une chaîne est un type de données spécial en Java, où elle contredit le fait que les types non primitifs sont définis par les programmeurs. Le type de données chaîne est un type de données non primitif mais il est prédéfini en Java, certaines personnes l'appellent également un neuvième type de données primitif spécial.
Cela résout le cas où un char ne peut pas stocker plusieurs caractères, un type de données chaîne est utilisé pour stocker la séquence de caractères. N'oubliez pas que vous devez placer la séquence de texte entre guillemets doubles.
| Chaîne s1 = « Salut » ; Système . dehors . println(s1); |
L'extrait ci-dessus affichera "Hey There" comme prévu.
Les tableaux, les classes, les interfaces, etc. sont quelques autres types de données non primitifs en Java.
Comment calculer la plage de types de données ?
Après avoir regardé les plages de types de données primitifs, vous pouvez avoir un doute sur le fait que nous devons nous en souvenir ?. Eh bien, la réponse serait NON. Mais nous devons nous souvenir de la taille de chaque type de données, puis nous pouvons calculer la plage de ce type de données.
Par exemple, un type de données byte consomme 1 octet de mémoire sur le disque. Au niveau du compilateur, toutes les données sont stockées sous forme de bits et un octet a 8 bits. Maintenant, l'un des 8 bits est utilisé pour spécifier le signe du nombre et les 7 bits restants peuvent stocker le nombre réel, donc le nombre maximum que nous pouvons stocker en utilisant 7 bits est 128.
Ainsi, -128 est la limite inférieure du type de données byte et +127 est la limite supérieure car zéro est le premier nombre sur la droite numérique après les nombres négatifs.
De même, dans les types à virgule flottante, les données sont divisées en 3 parties bit signé, mantisse et exposant. La partie mantisse est utilisée pour stocker la précision décimale, un flottant a 23 bits de mantisse plus un bit caché et un double a 52 bits de mantisse plus un bit caché.
Pour float, log(2^24)/log(10) qui est approximativement égal à 7, donc précision décimale à 7 chiffres.
Pour double, log(2^53)/log(10) qui est approximativement égal à 15, donc une précision décimale de 15 chiffres.
Inscrivez-vous à des cours de génie logiciel dans les meilleures universités du monde. Gagnez des programmes Executive PG, des programmes de certificat avancés ou des programmes de maîtrise pour accélérer votre carrière.
Conclusion
Nous avons vu différents types de données en Java, compris les types de données primitifs et non primitifs, la différence entre primitifs et non primitifs. Nous avons parcouru des exemples d'extraits de code pour avoir une connaissance de base de la déclaration des types de données.
Comprendre comment calculer la plage de divers types de données de types de données entiers, comment calculer la précision décimale des types de données à virgule flottante.
Maintenant que vous connaissez les différents types de données en Java, commencez à les explorer !
Si vous souhaitez en savoir plus sur Java, les OOP et le développement de logiciels à pile complète, consultez le programme Executive PG de upGrad & IIIT-B en développement de logiciels à pile complète qui est conçu pour les professionnels et offre plus de 500 heures de formation rigoureuse, Plus de 9 projets et affectations, statut d'ancien de l'IIIT-B, projets de synthèse pratiques et aide à l'emploi avec les meilleures entreprises.
