int pour mission

J'ai essayé ce type int et long de conversion où j'ai essayé d'assigner une int variable à un long variable. Le code est comme suit:

public static void main(String []args){
    int i = 1024;
    long j = i;
    long k = i*i*i*i;
    System.out.println("j= " +j+ ", k= " +k);
}

Donc, lors de l'impression j, il ne fait que donner une sortie de 1024. Mais lors de l'impression k, il a montré un dépassement de capacité (k=0). J'ai réglé ce problème en utilisant cette technique, où j'ai explicitement coulé chaque i à long. c'est à dire

public static void main(String []args){
    int i = 1024;
    long j = i;
    long k = ((long)i)*((long)i)*((long)i)*((long)i);
    System.out.println("j= " +j+ ", k= " +k);
}

Maintenant, il a montré des valeurs correctes de deux j et k.
Donc, je voulais savoir pourquoi est-ce qu'il faut pour lancer int dans le second cas, mais pas dans le premier. k, étant un long pouvez conserver cette valeur après cette lourde mission. Mais, pourquoi il n'est pas été correctement attribué?

casting premier i à long devrait être assez
((long)i)*iije
Le défaut du modèle que vous avez identifié -- une multiplication de nombres entiers qui peut déborder, qui est converti en "trop tard" pour une plus grande type -- est relativement commun dans les deux C# et Java; nous trouvons plus de cinq occurrences par million de lignes de code analysé. Une relative défaut avec un même taux de découverte est une division de deux entiers et un "trop tard" conversion en double; les gens sont souvent surpris de constater que trois cent divisé par cinq cents et affecté à un double zéro, pas de 0.6.

OriginalL'auteur Shashish Chandra | 2014-07-15

19

La raison en est que votre ligne
```
long k = i*i*i*i;
```
peut être considéré comme
```
long k = ((i*i)*i)*i;
```
ou...
```
int k1 = i*i;
int k2 = k1*i;
int k3 = k2*i;
long k = k3;
```
Donc, lorsque l'un quelconque de kn débordements, vous obtenez le message d'erreur.

Lorsque vous faites vos jette vous êtes évidemment contourner ce problème en multipliant longs ensemble.

Bien sûr, le plus simple modification de votre programme initial est de définir i comme un long tout de suite, au lieu d'une int.
```
long i = 1024L;
```
sera débordement parce que c'est int variable, il doit être long

OriginalL'auteur dav_i

Ce problème est basée sur le fait que différents types d'utilisation différents de la quantité de mémoire. int et long sont tous les deux des Entiers, la différence est que int fait 4 octets, tandis que long est de 8 octets.

Vous permet de modifier votre code un peu:

public class Test {


  public static void main(String []args){
        int i = 1024;
        long j = i;
        long k = i*i*i;

        System.out.println("My multipliers are of type int:");
        System.out.println("j= " +j+ ", k= " +k);           
        System.out.println("Is k less than Integer.MAX_VALUE: "  + (k < Integer.MAX_VALUE? "YES" : "NO"));
        k = i*i*i*i;
        System.out.println("j= " +j+ ", k= " +k);

        //now multiplying with j instead of i
        System.out.println("\nNow Im working with a long type:");
        k = j*j*j;
        System.out.println("j= " +j+ ", k= " +k);           
        System.out.println("Is k less than Integer.MAX_VALUE: "  + (k < Integer.MAX_VALUE? "YES" : "NO"));
        k = j*j*j*j;
        System.out.println("j= " +j+ ", k= " +k);
        System.out.println("Is k less than Integer.MAX_VALUE: "  + (k < Integer.MAX_VALUE? "YES" : "NO"));
        k = j*j*j*j;

     }

}

Le code ci-dessus montre que, lorsque vous avez multiplié j'ai 3 fois le résultat est une valeur qui est plus petit Entier.MAX_VALUE (qui est de 2 147 483 647), et lorsque vous en multipliant 4 fois, le résultat est 0 car il n'y a pas assez de place dans les pauvres 4 octets de la valeur des multiplicateurs. 🙂
Mais vous pouvez voir que lorsque les multiplicateurs (côté droit, j) sont de type long, la valeur correcte est imprimé, et la dernière impression montre que la déclaration de k < Integer.MAX_VALUE est false, ce qui est la raison de votre zéro. 🙂

Merci pour votre réponse. Je l'apprécie.

OriginalL'auteur Ranic

6

i*i*i*i est un int multiplication de sorte que le résultat est de type entier (Qui déborde dans votre cas). pour une longue résultante, vous avez seulement besoin de les convertir l'un d'eux de temps de sorte que c'est suffisant
```
long k = ((long)i)*i*i*i;
```
Ne associativité entrent en jeu ici? Je voulais dire, si c'est associativité à droite, puis, si on traverse la integer_max_value déjà avant de venir à l' (long i), il affiche un dépassement de nouveau dans votre cas.
essayez @ShashishChandra
Je l'ai essayé, et grâce à vous, il a travaillé. Je demandais juste, quel est le rôle de l'associativité ici?
Donc, il est associativité à gauche et il va travailler de cette façon. Merci pour votre réponse, j'ai vraiment l'apprécier.
Oui, Il va fonctionner dans ce cas. parce que la quatrième de multiplication avec i prend au-delà de Integer.MaxValue. Donc, les deux approches de travail. mais si vous avez choisi i plus élevé que les trois multiplication va au-delà de Integer.MaxValue, vous verrez le comportement.

OriginalL'auteur Sanjeev
2

En premier la valeur de i est un entier (int) et l'entier multipllication passe et i*i*i*i résultat est de type entier, et donc la integer overflow.

Où, comme dans le second cas, vous indiquez explicitement/rendre le résultat que long.

Merci pour votre réponse. Il est vraiment utile. L'apprécier.

OriginalL'auteur ꜱᴜʀᴇꜱʜ ᴀᴛᴛᴀ
2

1099511627776 qui est le résultat de la multiplication est >Integer.MAX_VALUE comme il est Entier Multiplication ainsi, après i*i*i valeur serait 1073741824 mais après multiplication avec 1024 il devient hors de portée, ce qui provoque débordement d'entier et k 0.
- Vous pouvez lancer l'un des i à long
- Multiplier avec 1L ( 1L*i*i*i*i ), Mais PAS i*i*i*i*1L
- Vous pouvez également affecter des i*i*i de long et de se multiplier avec i comme ce long k =(k=i*i*i)*i;
Merci pour votre réponse. Je l'apprécie.

OriginalL'auteur coder-croc

Vous devez vous connecter pour publier un commentaire.