int in byte umwandeln

[Nathy]

Ich habe jetzt schon mehrere Beispielprogramm getestet, die einen int-Wert in byte umwandeln sollen.
Hier ein Beispiel

    public static void berechnung() {
        int foo = 1000;
        byte[] mybyte = new byte[4];
        mybyte[0] =(byte)( foo >> 24 );
        mybyte[1] =(byte)( (foo << 8) >> 24 );
        mybyte[2] =(byte)( (foo << 16) >> 24 );
        mybyte[3] =(byte)( (foo << 24) >> 24 );
        System.out.println(mybyte[0]);
        System.out.println(mybyte[1]);
        System.out.println(mybyte[2]);
        System.out.println(mybyte[3]);
    }

Leider ergibt die Ausgabe immer
0
0
3
-24

Warum gibt es eine negative Zahl? Mache ich etwas mit der Ausgabe falsch?

Gruss und danke

 

[SlaterB]

mit String.toBinaryString()
kannst du dir die ints in bit-Darstellung anschauen,
mach das mal für foo,
für foo << 8, dann das wieder >> 24 usw

das Problem ist, wenn ich richtig rate, dass beim letzten durch das << das Negationsbit auf -1 gesetzt
und beim >> beibehalten wird

 

[Ark]

Noch umständlicher ging's nicht, oder? :autsch:

    public static void berechnung() {
        int foo = 1000;
        byte[] mybyte = new byte[4];
        mybyte[0] =(byte)(foo >> 24);
        mybyte[1] =(byte)(foo >> 16);
        mybyte[2] =(byte)(foo >> 8);
        mybyte[3] =(byte)(foo);
        System.out.println(mybyte[0] & 0xFF);
        System.out.println(mybyte[1] & 0xFF);
        System.out.println(mybyte[2] & 0xFF);
        System.out.println(mybyte[3] & 0xFF);
    }

Das "& 0xFF" ist notwendig, um aus dem Zweierkomplement eine vorzeichenlose Zahl zu machen.

Ark

 

[Nathy]

Sorry. Ich verstehe nicht genau was ich machen muss und wo das Problem liegt.

Gruss

 

[Marco13]

@Ark: Deins ist mindestens genauso umständlich, und in gewisser Hinsicht nichtmal das, was gewünscht ist: Durch das anfängliche shiften nach links sollte genau das erreicht werden, was du (allerdings NUR bei der Ausgabe durch das & 0xFF erreichst. Dass dabei implizit nach int gecastet wird, ändert nichts daran, dass das Ergebnis (mybyte[3]) "falsch" ist.

"Falsch" ist es aber garnicht: byte hat einen Wertebereich von -128 bis 127. Und in jedem byte werden 8 bits gespeichert. Es kann also einfach sein, dass die Zahlen, die da rauskommen, negativ sind. Die "richtige" Zahl (232) kann einfach als byte nicht dargestellt werden...


Man kann sich ja mal die 4 bytes ausgeben lassen:

class Berechnung
{
    public static void main(String args[])
    {
        berechnung();
    }

     public static void berechnung() {
        int foo = 1000;
        byte[] mybyte = new byte[4];

        System.out.println(bin(foo));

        mybyte[0] =(byte)( foo >> 24 );
        mybyte[1] =(byte)( (foo << 8) >> 24 );
        mybyte[2] =(byte)( (foo << 16) >> 24 );
        mybyte[3] =(byte)( (foo << 24) >> 24 );
        System.out.println(mybyte[0]);
        System.out.println(mybyte[1]);
        System.out.println(mybyte[2]);
        System.out.println(mybyte[3]);
    }

    public static String bin(int n)
    {
		String result = "";
		for (int i=31; i>=0; i--)
		{
			if ((n & (1<<i)) == 0)
			{
				result+="0";
			}
			else
			{
				result +="1";
			}
			if (i%8==0) result+=" ";
		}
		return result;
	}
}

Und das letzte byte ist einfach -24. Falls die Frage "Warum?" noch zu klären ist:
http://de.wikipedia.org/wiki/Zweierkomplement


EDIT: Nachtrag @Nathy: Du kannst die bytes auch als chars speichern. Der läßt sowieso nur positive Zahlen zu. Wenn du später aber die bytes weiterverarbeiten willst (z.B. in eine Datei schreiben o.ä. solltest du dich mit der negativen zal abfinden :wink: )

 

[Nathy]

Danke für die Antwort.
Jetzt habe ich an Stelle von byte, int eingesetzt. Dies gibt aber genau dieselbe Ausgabe? Wieso das?
int kann ja mehr als 128 speichern.

    public static void berechnung() {
        int foo = 1000;
        
        int[] mybyte = new int[4];
        mybyte[0] =(int)( foo >> 24 );
        mybyte[1] =(int)( (foo << 8) >> 24 );
        mybyte[2] =(int)( (foo << 16) >> 24 );
        mybyte[3] =(int)( (foo << 24) >> 24 );
        System.out.println(mybyte[0]);
        System.out.println(mybyte[1]);
        System.out.println(mybyte[2]);
        System.out.println(mybyte[3]);
    }

 

[Ark]

Der >>-Operator kopiert das Vorzeichen (d. h., es bleibt erhalten). Außerdem verstehe ich immer noch nicht, warum du deine Zahlen hin- und herschiebst, obwohl einmal Schieben mit UND-Verknüpfung es auch getan hätte, zumal bei einer gut durchdachten UND-Verknüpfung das Vorzeichen automatisch rausfällt. ???:L

Beschäftige dich mal näher mit dem Zweierkomplement und Binärarithmetik überhaupt.

Ark

 

[Nathy]

Hallo

Habe das Problem gelöst:

[/code]
int foo = 1000;

int[] mybyte = new int[4];
mybyte[0] =(int)( foo >>> 24 );
mybyte[1] =(int)( (foo << 8) >>> 24 );
mybyte[2] =(int)( (foo << 16) >>> 24 );
mybyte[3] =(int)( (foo << 24) >>> 24 );
System.out.println(mybyte[0]);
System.out.println(mybyte[1]);
System.out.println(mybyte[2]);
System.out.println(mybyte[3]);

Gruss und danke für die Hilfe

 

[Leroy42]

Bin ich hier im falschen Forum? :shock:

Ich hab bei google doch gar nicht
Bit-Schubser-Fetischisten eingegeben.

Versteh' ich nicht! ???:L