Division mit Rest, die in Java nicht funktioniert wie erwartet

class LongDiv{
public static void main(String [] args){

    final long x = 24*60*60*1000*1000;
    final long y = 24*60*60*1000;
    System.out.println(x/y);
}
}

obwohl die erwartete Antwort ist 1000, aber der javac gibt es als 5. Grund?

InformationsquelleAutor Aakash Goel | 2011-07-20

java long-integer

13

Lange x Sie erstellen, ist nicht der Wert, den Sie erwarten. Es ist in den integer-Bereich. Erstellen Sie sehnt sich danach, Verwendung:
```
final long x = 24L*60L*60L*1000L*1000L;
final long y = 24L*60L*60L*1000L;
System.out.println(x/y);
```
Den x Sie berechnet, in den integer-Bereich, war 500654080. Diese geteilt durch die y ( = 86400000), Ergebnisse in 5.794607407407407.... Java schneidet die Nachkommastellen, die bewirkt, dass die 5.

Durch das hinzufügen einer L nach der Anzahl Literale, sagen Sie dem compiler zu kompilieren als long statt einer int. Der Wert für x Sie erwartet 86400000000. Aber ist kompiliert wurde als int.

Können wir reproduzieren den falschen Wert für x (500654080) durch Rundung es zu einer int:
```
//First correct
long x = 24L*60L*60L*1000L*1000L;
/* x = `86400000000`; */
//Now truncate
x &= 0xFFFFFFFFL; //again: don't forget the L suffix
/* x = `500654080` */
```
- Nur eines dieser Literale in jedem Ausdruck muss ein long. Siehe @Peter die Antwort.
- akzeptiert. aber wie ist die Antwort 5?
- Ich weiß, aber ich denke, das ist eine Stil-Vorliebe.
- wie kann ich berechnen, dieser Wert 500654080 ohne computer!! diese Frage erschien in einer SCHRIFTLICHEN Prüfung!!
- Dies ist eine ziemlich grausame schriftliche Prüfung Frage... die besten, Die ich denken kann, wäre zu schreiben, die bits jeder Zahl und Maske Sie mit 0xFFFFFFFF, wie @Peter schon angedeutet oben.
- Wenn die Frage war "Warum ist dieser Wert falsch ist?", Sie können einfach sagen, dass x ist trucated ein int, weil der vergessen L suffix.
- eBay campus recruitment-Programm!!
InformationsquelleAutor Martijn Courteaux
5

Ausdrücke 24*60*60*1000*1000 ist ein int Typ nicht ein long Was Sie wollen, ist 24L*60*60*1000*1000 die long

Dies ist, was Sie haben.
```
final long x = (24*60*60*1000*1000) & 0xFFFFFFFF;
final long y = (24*60*60*1000) & 0xFFFFFFFF;
System.out.println(x/y);
```
was Sie wollen, ist
```
final long x = 24L*60*60*1000*1000;
final long y = 24L*60*60*1000;
System.out.println(x/y);
```
- Explizit über Sie kann man immer tun, eine 1L * 24 * 60 * 60 * 1000 * 1000.
- In diesem Fall können Sie tun (long) 24 * 60 * 60 * 1000 * 1000
- Wann würde der int->lange Förderung passieren? Für 24 oder die volle (intified) Ergebnis?
- casting Vorrang vor Multiplikation introcs.cs.princeton.edu/java/11precedence
InformationsquelleAutor Peter Lawrey
2

Tricky"!

Das Problem ist, dass von 24, 60 und 1000 sind Java-literal ints. Bevor die Werte zugeordnet sind, x und y, Sie sind abgeschnitten, in int-Werte. Versuchen
```
System.out.print(x + ", " + y);
```
genau zu sehen, was ich meine. Die schnelle Lösung ist, um Ihre Literale in long-Werte etwa so:
```
public class LongDiv{
public static void main(String [] args){

    final long x = 24l*60l*60l*1000l*1000l;
    final long y = 24l*60l*60l*1000l;
    System.out.println(x/y);
}
}
```
- Geschlagen, um den Stempel! Nicht ganz so schwierig, wie ich dachte, denke ich 🙂
InformationsquelleAutor Eric

casting (zwingen) zu lange arbeitet, im Falle von literal-Werte für den rechten Operanden; aber das problem besteht weiterhin im Falle der Zuweisung einer long variable an eine andere, wie in dem unten gegebenen Beispiel:

package utils;

public class Utils {

    public static void main(String ... clps){
        Utils.longDivision();
        Utils.doubleDivision();
    }

    private static void doubleDivision(){
        double x=new Long("54321").doubleValue();
        double y=new Long("12345").doubleValue();
        double difference=x - y;
        double percentage=(difference/x)*100.00;
        System.out.println("\nDouble Division ==> X : "+x+" ; Y : "+y+" ; Difference : "+difference+" ; percentage : "+percentage+"\n");
    }

    private static void longDivision(){
        long x=new Long("54321").longValue();
        long y=new Long("12345").longValue();
        long difference=x - y;
        long percentage=(difference/x)*100L;
        System.out.println("\nLong Division ==> X : "+x+" ; Y : "+y+" ; Difference : "+difference+" ; percentage : "+percentage+"\n");
    }

}

Nur so konnte ich die richtige Antwort ist durch die Umstellung der Aufteilung der sich danach sehnt in Teilung verdoppelt. Es ist sehr seltsam warum der division der sehnt sich verhält in so geheimnisvoller Weise.

longDivision gibt die Antwort als null in der Erwägung, dass die doubleDivision gibt die richtige Antwort.

Ich hoffe, dies hilft anderen Menschen, die auf ein ähnliches Problem gestoßen...

InformationsquelleAutor Saasira

1

24*60*60*1000*1000 ist zu groß, um in ein int - und überläufe.

InformationsquelleAutor matt b

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.