Java Integer Wert in signed int umwandeln

[Proktologe]

Hi,

ich habe folgendes Problem und kann mir grad nicht vorstellen, dass es dafuer nix in Java geben soll.
Ich habe einen normalen Integer Wert (als Bsp. 240) und moechte diesen gerne in einen signed int umwandeln.

Das waere also von 11110000 nach 00011111 (sprich -127). Ich habe bisher aber noch keine Funktion gefunden, die mir erlaubt direkt einen Integer in einen signed int zu ueberfuehren.

Gibt es da was?

Schoene Gruesse,
Prok

 

[kling1]

alle javadatentypen sind unsigned

 

[1668mib]

@klomann83: Du meinst das Gegenteil... alle sind signed.

@Proktologe: Ich muss gestehen, dass ich das Problem nicht ganz verstehe, weil ich den Sinn dahinter nicht sehe.
Ansonsten: Wie gehst du selbst dabei vor?

 

[Proktologe]

Das soll mir suggerieren, dass ich es haendisch machen muss, richtig?

edit:
@1668mib

Der Sinn ist folgender: Ich bekomme diesen Wert praesentiert, daran kann ich nix aendern. Ich muss ihn aber umrechnen.

Bisher gehe ich so vor.

- Erstelle den bitString aus der Integer (das geht recht einfach)
- invertiere den bitString
- addiere eine 1
- bilde aus dem resultierenden bitString wieder eine dezimalzahl und haeng ein - davor

So, wie ich's mal in der Uni gelernt hatte.

 

[NullPointer]

Korrektur: Alle Java-Datentypen sind signed.

Ich verstehe auch gerade nicht, was Proktologe da machen will. Es sieht so ähnlich aus wie ein Zweierkomplement, ist aber keins (das wäre hier 00011110). Außerdem ist -127 in keiner mir bekannten Binärdarstellung gleich 00011111.

 

[Proktologe]

Ich bin auch nach dieser Anleitung gegangen:

http://www.wikihow.com/Convert-a-Negative-Binary-to-Decimal

Als Aufklaerung wie ich auf die -127 komme.

Ich hab nun mal diese bloede Integer und weiss, dass es eine negative Zahl sein muss (es handelt sich hierbei um eine Signalstaerke). Ich muss also irgendwie aus der Binaerdarstellung von (zum Beispiel) 240 eine signed int machen.

 

[NullPointer]

Du hast also eine Binärzahl, die negativ ist (im Zweierkomplement), von Java aber als positiv interpretiert wird, und möchtest jetzt wissen, wie die eigentliche negative Zahl lautet?

Okay. Angenommen, die Länge der Zahlen ist wie in deinem Beispiel auf 8 Bit beschränkt. Dann XORe die Zahl bitweise (Operator "^") mit 11111111 (dezimal 255), dadurch werden alle 8 Bits geflippt, dann addiere 1 und negiere das Ergebnis. Das sollte reichen (ohne Gewähr^^).

 

[1668mib]

Und wie kommst du dann auf 0001111?


@Nullpointer: Da wird wohl das Problem sein. Die Eingangswerte haben weniger Bits als Integer bei Java.

Er müsste also die höheren Bits 8-31 alle mit dem höchsten Eingangs-Bit 7 füllen damit es passt.

Das müsste die Lösung sein: (C#-Code)

static int expandByte(int value)
        {
            int bit7 = 128;
            long bit0to7 = 255;
            long bit8to31 = 4294967040;
            if ((value & bit7) == bit7)
            {
                value = (int)(value | bit8to31);
            }
            else
            {
                value = (int)(value & bit0to7);
            }

            return value;
        }

hab nen kleines Testprogramm geschrieben mit dieser Ausgabe (gekürzt bei den Zeilen mit ...)

0 = 0
1 = 1
2 = 2
3 = 3
4 = 4
5 = 5
..
124 = 124
125 = 125
126 = 126
127 = 127
128 = -128
129 = -127
130 = -126
131 = -125
...
240 = -16
...
253 = -3
254 = -2
255 = -1

(der Code:

for (int i = 0; i < 256; i++)
{
  Console.WriteLine("{0} = {1}", i, expandByte(i));
}

)

 

[NachtkindFX]

240 also (1)111.0000 bekommst zurück, aber eine negative Zahl wird darstellt. ( 8 bit ) *hmmm* -16

 

[kugel.]

240 ist doch signed. Signed heißt nicht zwingend negativ, sondern das im gesamten Zahlenbereich des Datentyps auch negative zahlen enthalten sind. Ein signed int geht mit seinen (normalerweise) 32bits von -2.147.483.648 bis +2.147.483.647. Da passt deine 240 locker rein. Siehe auch http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Integer.html

Du willst offenbar den Zahlenbereich auf 8 bit begrenzen. Wäre der Datentyp wirklich auf 8bit begrenzt (physikalisch) dann sieht die Binärfolge von 240 in dem negativen Äquivalent gleich aus. Die 240 passt aber auch schon garnicht in 8bit rein wenns signed sein soll (da gehts von -128 bis +127). Die 240 (unsigned) ist ganz automatisch auch gleichzeitig die negative Version (signed).

Ansonsten versteh ich dein problem auch nich

PS: Das zeigt mal wieder das Java-Programmier von nichts ne Ahnung haben

 

[NachtkindFX]

11110000 ist in 8 Bit -16 , denke hier liegt das Problem.

Ergänzung (25. Mai 2010)

öhm, kann man nicht den Datentyp auf byte festlegen?


http://www.teialehrbuch.de/Kostenlose-Kurse/JAVA/6559-byte-short-int-long.html


http://www.particle.kth.se/~lindsey/JavaCourse/Book/Part1/Java/Chapter02/primitives.html

 

[1668mib]

hab oben nen code der dir das Problem auch löst... ist zwar C# dürfte aber auch unter Java gehen... ansonsten geht es auch anders

wenn die Zahl größer 127 ist dann ist sie negativ => dann ist die Zahl eben -(256 - Eingangswert) (könnte man natürlich umformen zu Eingangswert - 256)

 static int expandByte(int value)
        {
            if (value > 127)
            {
                // negativ
                value = value - 256;
            }
            return value;
}

 

[Proktologe]

Das 240 nicht in einen 8 bit signed gehen, weiss ich. Genau da liegt ja im Prinzip mein Problem.

Der Wert muss negativ sein, nur moechte mein Java es nicht als solchen erkennen. Die darunterliegende Middleware liefert jedenfalls einen int8, der signed ist.

Ich versteh nicht so ganz, warum Java da so maekelt. C erkennt den Wert als negativen Wert.

Ergänzung (25. Mai 2010)

hab oben nen code der dir das Problem auch löst... ist zwar C# dürfte aber auch unter Java gehen... ansonsten geht es auch anders

Hm, ich glaube das war die Ueberlegung, die mir gefehlt hatte.

edit:
Ja, das war die Ueberlegung, die mir gefehlt hatte.
Besten Dank, da haette ich mir gar nicht soviele Muehen machen muessen.

 

[1668mib]

das Poblem ist, dass du einen signed int8 auf einen signed int32 casten willst. Bei diesem Cast müssen aber wie ich schon schrieb die Bits 8 bis 31 (welche beim signed int8 ja nicht vorkommen) mit dem Bit7 des signed int8 gefüllt werden. Am höchsten Bit eines Integer-Werts kann man ablesen, ob die Zahl ein negatives Vorzeichen hat oder eben nicht. Wenn aber nach dem Cast die Bits 8 bis 31 auf 0 bleiben ist es klar, dass die Zahl als positiv interpretiert wird. Entweder man kippt die Bits wie mein C#-Code weiter oben, oder man schaut nur, ob es eine negative Zahl sein muss (größer als 127) und zieht dann davon 256 ab und erhält die korrekte negative Zahl...

 

[NullPointer]

C erkennt den Wert als negativ, wenn du den entsprechenden Datentyp verwendest: signed char (8-bit mit Vorzeichen). Das Problem bei Java ist, daß sein int-Typ 32 Bit hat, Java sieht also nicht 11110000, sondern 00000000000000000000000011110000. Das höchstwertige Bit ist 0, also betrachtet Java den Wert als positiv.

Wenn es möglich ist, versuch doch mal, den Wert in eine Variable vom Typ byte einzulesen. Der hat genau die 8 Bit, die du brauchst.

Edit: Und wieder zu spät