# int in byte umwandeln



## Nathy (31. Mai 2007)

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 (31. Mai 2007)

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 (31. Mai 2007)

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 (31. Mai 2007)

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

Gruss


----------



## Marco13 (31. Mai 2007)

@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 (31. Mai 2007)

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 (31. Mai 2007)

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 (31. Mai 2007)

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 (31. Mai 2007)

Bin ich hier im falschen Forum?  :shock: 

Ich hab bei google doch gar nicht
_Bit-Schubser-Fetischisten_ eingegeben.

Versteh' ich nicht!  ???:L


----------

