analyser long de nombre négatif

code:

public class Main{
    public static void main(String[] a){
        long t=24*1000*3600;
        System.out.println(t*25);
        System.out.println(24*1000*3600*25);
    }
}

Cette affiche :

2160000000

-2134967296

Pourquoi?

Merci pour toutes les réponses.

Est la seule façon d'utiliser L après le nombre?

J'ai essayé le (long)24*1000*3600*25 mais c'est aussi négatif.

Si vous avez trouvé une réponse qui a résolu votre problème, assurez-vous de voter, comme une réponse (en cliquant sur la case à cocher en dessous de la partition).
Salut hguser. Par (long)24*1000*3600*25 vous convertir le résultat, qui est -2134967296, dans un long, qui est -2134967296L. En effet, vous pourriez utiliser (long) au lieu de L, mais avec d'autres parenthèses: ((long)24)*1000*3600*25. Cependant, L est exactement fait pour ce cas, et il est même possible que le compilateur génère différents octets de code: 24 L est un littéral de type long, alors que la (longue)24 est un littéral de type int qui doit d'abord être converti en long (mais j'espère que le compilateur optimise).

OriginalL'auteur hguser | 2010-10-18

11

De l'expliquer clairement,
```
System.out.println(24*1000*3600*25);
```
Dans la déclaration ci-dessus sont en fait int littéraux. Pour faire traiter comme une long littéral, vous devez suffixe ceux avec L.
```
System.out.println(24L*1000L*3600L*25L);
```
Mise en garde, une petite l suffira trop, mais qui ressemble à du capital I ou 1, parfois. Capital I n'a pas beaucoup de sens ici, mais la lecture qu'en tant que 1 peut vraiment donner du fil à retordre. En outre, Même suffisant une valeur unique L va rendre le résultat long.

un petit l ressemble plus à des chiffres 1.
Oh! Oui, dans la plupart des éditeurs de programmation, ses plus semblable à 1. Mais je ne suis pas si mal dans ce qui suggère que, je suppose. Cela se produit lorsque votre police est Arial. Essayer ça, les deux seraient idem de l'autre.
notez que seul un nombre doit être long; 24L*1000*36000*25 travaillera aussi parce que le résultat final sera de la longueur maximale de l'équation de membres de la longueur, dans ce cas, il est long. Cela est également vrai dans presque tous les langages de programmation. Notez que, parfois, vous aurez besoin d'avoir un double afin de ne pas perdre le sens, ex: (long) (1d * someLong * someLong / someLong)

OriginalL'auteur Adeel Ansari
18

Vous avez atteint le max de la int type qui est Integer.MAX_VALUE ou 2^31-1. Il s'enveloppa de ce fait, vous montrant ainsi un nombre négatif.

Pour un instant l'explication de cette, de voir cette bande dessinée:

Drôle,cependant je ne comprends pas cette bande dessinée..:(. Mais j'ai peut-être connaître le sens,il montre les Données de débordement? N'est-ce pas?
Oui, il montre les moutons comptent aller jusqu'à 32 767 d', puis, quand le débordement se produit, le compte continue, mais à partir de la limite inférieure. Pour moi, la metaphore du cercle qui aide beaucoup dans la compréhension de ce.
Vous avez besoin de compiler en mode 16 bits mode de bande dessinée de travail. Ou de l'utilisation de courts-métrages.
Garder l'incrémentation d'un int et que vous passez de Entier.MAX_VALUE Entier.MIN_VALUE

OriginalL'auteur Alberto Zaccagni
6

Dans le premier cas, vous êtes l'impression d'un long mais dans le second, vous l'impression que int.

Et int dispose d'une gamme de: -2^31 à 2^31 - 1, qui est juste en dessous de ce que vous êtes en calcul (int max: 2147483647 vous: 2160000000) de sorte que vous débordement de l'int de la plage négative.

Vous pouvez forcer la deuxième utilisation long ainsi:
```
System.out.println(24L*1000*3600*25);
```
OriginalL'auteur Lasse Espeholt

Vous devriez suffixe les nombres avec un "l". Vérifier l'extrait de code ci-dessous:

   public static void main(String[] a){
        long t=24*1000*3600;
        System.out.println(t*25);
        System.out.println(24l*1000l*3600l*25l);
    }

OriginalL'auteur Sagar V

2

Partie intégrante des littéraux sont traitées en tant que type int par défaut. 24*1000*3600*25 est plus grand que Integer.MAX_VALUE donc des débordements et évalue à -2134967296. Vous avez besoin de faire explicitement l'un d'eux une long à l'aide de la L suffixe pour obtenir le bon résultat:
```
System.out.println(24L*1000*3600*25);
```
OriginalL'auteur dogbane

Si vous voulez faire des opérations mathématiques avec les grandes valeurs numériques sans fil qui coule, essayez de la classe BigDecimal.

Disons que je veux multiplier

De 200.000.000 * 2,000,000,000,000,000,000 L * 20 000 000 de

int testValue = 200000000;
System.out.println("After Standard Multiplication = " +
                                                       testValue * 
                                                       2000000000000000000L * 
                                                       20000000);

La valeur de l'opération sera -4176287866323730432, ce qui est incorrect.

À l'aide de la classe BigDecimal vous pouvez éliminer le tombé en morceaux et obtenir le résultat correct.

int testValue = 200000000;        
System.out.println("After BigDecimal Multiplication = " +
                              decimalValue.multiply(
                              BigDecimal.valueOf(2000000000000000000L).multiply(
                              BigDecimal.valueOf(testValue))));

Après l'utilisation de la BigDecimal, la multiplication renvoie le résultat correct, qui est

80000000000000000000000000000000000

OriginalL'auteur dinidu

0
```
(int)Long.valueOf("2345678901").longValue();
```
Pouvez-vous expliquer comment (int) de sens que dans votre exemple?

OriginalL'auteur Honghe.Wu

Vous devez vous connecter pour publier un commentaire.