Datentypen Literal überschreitet long-Range, dennoch als long an Variable übergeben

[Jontour]

Moin!

Vorweg:
Ich bin Anfänger und meine folgenden Fragen sind für euch wahrscheinlich rudimentär und trivial.

1. Frage

folgender Fall:

public class Neu
{
  public static void main(String[] args)
  {
      long a = 9223372036854776000L;
  }
}

Fehlermeldung: Das Literal ist ausserhalb der Reichweite für Long-Datentypen.
Merke: die letzten 4 Stellen --> 6000L

Ergänze ich den Code aber folgendermaßen:

public class Neu
{
  public static void main(String[] args)
  {
      long a = 9223372036854775000L + 1000;
  }
}

... dann lässt sich die Summe problemlos an die Variable a übergeben.
Merke: die letzten 4 Stellen --> 5000L + 1000

2. Frage

Warum wird die Variable a (wenn ich sie auf die Konsole schreibe) im falle von

      long a = 9223372036854775000l + 1000;

plötzlich negativ?!
==> -9223372036854775616


Danke & Gruß

 

[Salo]

1. Weil es keine 1000 addiert. (lass dir den wert mal ausgeben)

 public class LongTester {
    public static void main(String[] args) {
        long l = ...5000L + 1000;
        System.out.println(l);
    }
}

 

[Salo]

2. Weiß ich gerade auch nicht, müßte ich mir genauer anschauen. Sorry😕🙁

hab grad keine Zeit.

 

[Meniskusschaden]

Der Datentyp long ist 64Bit groß. Da man auch negative Zahlen abbilden möchte, geht 1 Bit für das Vorzeichen verloren, so dass der größtmögliche darstellbare Wert in 63 Bit passen muß. Den Wert kannst du auch mit System.out.println(Long.MAX_VALUE);ausgeben lassen. Durch die Addition mit 1000 übersteigst du diesen Wert und gelangst dadurch in den Darstellungsbereich der negativen Zahlen. Näheres dazu steht zum Beispiel hier.

 

[Salo]

Der Datentyp long ist 64Bit groß. Da man auch negative Zahlen abbilden möchte, geht 1 Bit für das Vorzeichen verloren, so dass der größtmögliche darstellbare Wert in 63 Bit passen muß. Den Wert kannst du auch mit System.out.println(Long.MAX_VALUE);ausgeben lassen. Durch die Addition mit 1000 übersteigst du diesen Wert und gelangst dadurch in den Darstellungsbereich der negativen Zahlen. Näheres dazu steht zum Beispiel hier.

Genau das meinte ich, nur ich habs nicht so ausführlich beschrieben.

 

[Xyz1]

Es findet ein s. g. long-Überlauf statt - hätt's auch getan...

Wegen dem Wertebereich musst du mal "schauen".

 

[Meniskusschaden]

1. Weil es keine 1000 addiert. (lass dir den wert mal ausgeben)

Das ist dann aber etwas mißverständlich ausgedrückt, denn tatsächlich wird ja 1000 addiert und wenn man das resultierende Bitmuster als vorzeichenlose Ganzzahl interpretieren würde, wäre es das erwartete Ergebnis. Folgender Code:

        long a = 9223372036854775000L + 1000;
        System.out.println(a);
        System.out.println(Long.toUnsignedString(a)); // geht erst seit Java8

führt zu folgendem Ergebnis:

-9223372036854775616
9223372036854776000

 

[Jontour]

Danke für eure Antworten!

System.out.println(Long.toUnsignedString(a)); // geht erst seit Java8[/code]
führt zu folgendem Ergebnis:

-9223372036854775616
9223372036854776000

Was erreiche ich, wenn ich nen Long-Typ zu nem UnsignedString konvertiere? Schummel ich mir da zusätzliche Bits hinzu, um sie doch noch per Long darstellen zu können? ^^

Der Datentyp long ist 64Bit groß. Da man auch negative Zahlen abbilden möchte, geht 1 Bit für das Vorzeichen verloren, so dass der größtmögliche darstellbare Wert in 63 Bit passen muß. Den Wert kannst du auch mit System.out.println(Long.MAX_VALUE);ausgeben lassen. Durch die Addition mit 1000 übersteigst du diesen Wert und gelangst dadurch in den Darstellungsbereich der negativen Zahlen. Näheres dazu steht zum Beispiel hier.

Merci beaucoup! 🙂 Das hatte ich total vergessen. Wäre hierfür dann die Standardlösung, an die lange Zahl ein "D" zu hängen und dementsprechend auch, den ganzen Kram dann in einer double-Variable zu speichern?

Also so: ?

public class Neu
{
  public static void main(String[] args)
  {
      double a = 9223372036854776000d;
  }
}

Soweit ich mich entsinne war es doch ein bisl kritisch, mit Datentypen hin- und her zu jonglieren. Weil von Long nach Double gibt's Risiko für Rundungsfehler und umgekehrt geht die Genauigkeit flöten... richtig?

 

[Meniskusschaden]

Was erreiche ich, wenn ich nen Long-Typ zu nem UnsignedString konvertiere? Schummel ich mir da zusätzliche Bits hinzu, um sie doch noch per Long darstellen zu können? ^^

Das ist nur eine kleine Hilfe, damit man sich den Wert von vorzeichenlosen Ganzzahlen bequem anzeigen lassen kann. Man kann damit aber natürlich nicht weiterrechnen.

Wäre hierfür dann die Standardlösung, an die lange Zahl ein "D" zu hängen und dementsprechend auch, den ganzen Kram dann in einer double-Variable zu speichern?

Das hängt von den Anforderungen ab. Mit double kann man zwar größere Zahlen abbilden, aber letztendlich sind es auch nur 64Bit. Man verliert dann eben Genauigkeit. Die Klasse BigInteger könnte eine Lösung sein: http://openbook.rheinwerk-verlag.de...12_006.htm#mjb7eac3af197800d59092e82df405f7d8

 

[Xyz1]

richtig?

Das lässt sich so vereinfacht nicht sagen.
double beinhaltet ja noch viel mehr, was du nicht kennst.
Wenn es nicht auf die Genauigkeit ankommt, dann kannst du das so machen, ja.