Spécification du numéro L (long) de Java
Il semble que lorsque vous tapez un nombre en Java, le compilateur le lit automatiquement sous forme d’entier, ce qui explique pourquoi lorsque vous tapez (long) 6000000000 (pas dans la plage de l'entier), il se plaindra que 6000000000 n'est pas un entier. Pour corriger cela, je devais spécifier 6000000000L. Je viens d'apprendre à propos de cette spécification.
Existe-t-il d'autres spécifications numériques telles que court, octet, float, double? Il semblerait que ce soit bien parce que (je suppose) si vous pouviez spécifier que le nombre que vous tapez est court, alors Java ne devrait pas le lancer - c’est un Supposez, corrigez-moi si je me trompe. Normalement, je chercherais moi-même cette question, mais je ne sais pas comment ce type de spécification de numéro est appelé.
Il existe des suffixes spécifiques pour long (par exemple, 39832L), float (par exemple 2.4f) et double (par exemple, -7.832d).
S'il n'y a pas de suffixe et qu'il s'agit d'un type intégral (par exemple, 5623), il est supposé être un int. Si ce n'est pas un type intégral (par exemple, 3.14159), il est supposé être un double.
Dans tous les autres cas (byte, short, char), vous avez besoin de la conversion car il n'y a pas de suffixe spécifique.
La spécification Java autorise les suffixes majuscules et minuscules, mais la version majuscule de longs est préférable, car la majuscule L est moins facile à confondre. avec un chiffre 1 que la minuscule l.
Voir le section 3.10 de JLS pour les détails sanglants (voir la définition de IntegerTypeSuffix).
J'espère que vous ne craindrez pas une légère tangente, mais je pense que cela pourrait vous intéresser de savoir qu'en plus de F (pour float), D (pour double) et L (pendant longtemps), ne proposition a été faite d'ajouter des suffixes pour byte et short — Y et S respectivement. Cela éliminerait le besoin de transtyper en octets lors de l'utilisation de la syntaxe littérale pour les tableaux d'octets (ou courts). Citant l'exemple de la proposition:
AVANTAGE PRINCIPAL: Pourquoi la plate-forme est-elle meilleure si la proposition est adoptée?
code cruddy comme
byte[] stuff = { 0x00, 0x7F, (byte)0x80, (byte)0xFF};peut être recodé comme
byte[] ufum7 = { 0x00y, 0x7Fy, 0x80y, 0xFFy };
Joe Darcy supervise Project Coin pour Java 7, et son blog a été un moyen facile de suivre ces propositions.
Par défaut, tout type de données de primitive intégrale (octet, short, int, long) sera traité comme int tapez par Java compilateur. Pour octet = et short, tant que la valeur qui leur est assignée est dans leur plage, il n'y a pas de problème ni de suffixe requis. Si la valeur est assignée à octet et court) dépasse leur plage, le transtypage de type explicite est requis.
Ex:
byte b = 130; // CE: range is exceeding.
pour surmonter cela effectuer type casting.
byte b = (byte)130; //valid, but chances of losing data is there.
En cas de type de données long, il peut accepter la valeur entière sans tracas. Supposons que nous assignions comme
Long l = 2147483647; //which is max value of int
dans ce cas, aucun suffixe comme L/l n'est requis. Par défaut, la valeur 2147483647 est considérée par Java est de type int. Le transtypage de type interne est effectué par le compilateur et int est automatiquement promu en type long.
Long l = 2147483648; //CE: value is treated as int but out of range
Ici, nous devons mettre le suffixe en tant que L pour traiter le littéral 2147483648 comme un type long avec Java compilateur.
alors finalement
Long l = 2147483648L;// works fine.
Ce sont des littéraux et sont décrits dans section 3.1 de la Java.
Il semble que ce serait bien d'avoir ceci parce que (je suppose) si vous pouviez spécifier que le nombre que vous tapez est court alors Java ne devrait pas le lancer
Comme l'analyse des littéraux a lieu au moment de la compilation, cela n'a absolument aucune incidence sur les performances. La seule raison d'avoir les suffixes short et byte est Nice, c'est que cela conduit à un code plus compact.
Considérer:
long l = -1 >>> 1;
versus
int a = -1;
long l = a >>> 1;
Vous vous attendez maintenant à ce que des fragments de code dérangeants donnent la même valeur à la variable l. Nous avons donc besoin que l'expression sur int littéral se fasse comme ints.