# 16-Bit int --> 2* 8-Bit Bytes



## Dit (10. Jul 2006)

Hallo zusammen,

ich habe die aufgabe bekommen einen int in einen byte umzuwandeln.
d.h. einen int mit 16 Bit in einen "2 * 8 bit großem byte --> 2 byte)

wenn ich das richtig sehe genügen 2 byte aus um die Positiven stellen eines int zu speichern
(2 byte --> 65536)
habe auch schon lang gesucht und keine Hilfe gefunden.

hier sind zwar ansätze aber noch lange keine Lösungen:

http://groups.google.de/group/comp....int+in+2+bytes&rnum=32&hl=de#327f80dab2dd07f6

ein andere Ansatz:


```
int zahl = ??; 

byte[] array = new byte[4]; 
array[0] = (zahl >>> 24) & 0xFF; 
array[1] = (zahl >>> 16) & 0xFF; 
array[2] = (zahl >>> 8) & 0xFF; 
array[3] = zahl & 0xFF;
```

aber das ist wiederrum ein byte Array... :? und aucn nicht das was ich suche!

ich hoffe mir kann einer helfen...


----------



## 0xdeadbeef (10. Jul 2006)

Hi, hast die Lösung doch im Prinzip schon ???:L 


```
int number = ??;
...

byte low = (byte)number;
byte high = (byte)(number >> 8);
```

Das Maskieren mit 0xff ist in diese Richtung (Int - Byte) eigentlich Unsinn, weil in ein Byte ja eh nur 8bit passen, also werden die anderen Bits automatisch abgeschnitten. Das "& 0xff" kostet also nur unnötig Laufzeit und Codegröße.

Ach so: und ein Int ist natürlich vorzeichenbehaftet und geht von -32768 bis +32767 (nicht bis 65535). Die Schieberei mit ">>>" (ohne Vorzeichenerweiterung) statt mit ">>" (mit Vorzeichenwerweiterung) im obigen Beispiel ist zwar nicht falsch, aber ebenfalls völlig wirkungslos, weil die davon betroffenen Bits ja gleich wieder abgeschnitten werden (sogar doppelt durch das unnötige "& 0xff").


----------



## Dit (10. Jul 2006)

naja also ich bin da noch nicht so ganz von überzeugt, dass das die Lösung sein soll:


```
public class Typumwandlung {
	public static void main(String[] args) {
		int number = 255; 
		byte low = (byte)number; 
		byte high = (byte)(number >> 8); 
		System.out.println("low  :  " + low);
		System.out.println("high :  " + high);
	}

}
```

Ausgabe: 
low  :  -1
high :  0

und genau das versteh ich nicht! warum 0 und -1 ??  :?


----------



## kama (10. Jul 2006)

Hi,

warum da "-1" rauskommt ist ganz klar, da byte ein Vorzeichenbehafteter Integer mit 8 Bit ist. Somit -128 ... +127.


```
public static void main(String[] args) {
	      int number = 255;
	      
	      
	      char low = (char)(number & 0x00ff);
	      char high = (char)((number & 0xff00) >> 8);
	      System.out.println("Size=" + Character.SIZE);
	      System.out.println("low  :  " + (int)low);
	      System.out.println("high :  " + (int)high);
	   }
```

So gibt das schon eher was.
Byte ist in Java leider kein 8-Bit (unsigned). ;-(
BTW: auch noch mal lesen. Java ist eine Insel.

MfG
Karl Heinz Marbaise


----------



## Dit (10. Jul 2006)

Ich habe irgendwo gelesen, das die Möglichkeit besteht nur die Positiven Zahlen eines byte zu benutzen und so auf den wert (+)255  zu kommen.

Aber mal so in den Raum gestellt. 

besteht überhaupt die Möglichkeit einen int (bsp: 2006) in bytes darzustellen das ich nach der ausgabe wieder 2006 erhalt?


----------



## thE_29 (10. Jul 2006)

```
int number = 2006;
    byte low = (byte)number;
    byte high = (byte)(number >> 8);
    System.out.println("number: " + number + "  bitmask: " + Integer.toBinaryString(number));
    String tmpNumber = Integer.toBinaryString(low);
    tmpNumber = tmpNumber.substring(tmpNumber.length() -8);
    System.out.println("low: " + low + "  bitmask: " + tmpNumber);
    System.out.println("high: " + high + "  bitmask: " + Integer.toBinaryString(high)); 
    int new_number = high & 255; //zuerst die hohe Maske hinzuweisen
    new_number <<= 8; //dann 8 bits nach links verschieben
    new_number |= low & 255; //dann die low Maske hinzufügen
    System.out.println("new_number: " + new_number + "  bitmask: " + Integer.toBinaryString(new_number));
```



			
				Ausgabe hat gesagt.:
			
		

> number: 2006  bitmask: 11111010110
> 
> low: -42  bitmask: 11010110
> 
> ...


----------



## Beni (10. Jul 2006)

Du kannst das byte vor der Ausgabe zurück in einen int verwandeln. 
	
	
	
	





```
for( byte x = Byte.MIN_VALUE; x < Byte.MAX_VALUE; x++ ){
            int y = x & 0xFF;
            System.out.println( x + " " + y );           
        }
```

Schlussendlich ist ein byte einfach mal 8 Bits, was sie bedeuten, kannst du selbst festlegen (du könntest ein Byte auch als ASCII-Zeichen anschauen...).


----------



## Dit (10. Jul 2006)

:toll: 

ich denke das könnte mir schon weiter helfen wenn nicht sogar die Lösung sein.
vielen dank schon / erst mal 
ich werde mal schauen ob das so funktioniert


----------



## Dit (10. Jul 2006)

Also das sieht schon mal gut aus!

besteht aber vielleicht noch die Möglichkeit aus den 2 byte einen byte[] zu machen?
dann hätte ich nur eine Zahl die ich abspeichern müsste (es handelt sich um Telegramme  )


ABER NOCH MALS VIELEN DANK AN ALLE BETEILIGTEN!!!!!!!!!! :toll:  :toll:


----------



## thE_29 (10. Jul 2006)

byte[0] = low;
byte[1] = high;

das war aber leicht :bae:


----------



## Dit (10. Jul 2006)

hehe 

ich meinte eher einen array mit einem namen aber der die beiden werte high und low enthält 

aber cool die antwort  :lol: 
aber müsste auch so gehen


----------



## thE_29 (10. Jul 2006)

Sind wir ein bisi Denkfaul?!

byte buf[] = new byte[2];
buf[0] = low;
buf[1] = high;

sowas?!


----------



## Dit (10. Jul 2006)

nope simma net!
ich muss nur zu geben das das ganze Binaer Zeug nicht mein Ding ist!
(da macht Oberflächendesign mehr spaß  :lol: )

aber jetzt wo die Lösung gibst... ja ich muss zu geben da hätte ich auch drauf kommen können!
 

danke!


----------



## thE_29 (10. Jul 2006)

Häkchen setzen net vergessen!


----------



## Dit (10. Jul 2006)

ok ^^ 
danke!


----------



## Dit (10. Jul 2006)

ich könnt heulen   

habe gerade festgestellt das nen short ja auch nur 2 byte hat!

mir hätte folgendes völlig gereicht:


```
public class Typumwandlung2 {
	public static void main (String[] args){
		int b = 1234;
		short a = (short) b;
		System.out.println(a);
		
	}
}
```

^^
so ist das... aber trotzdem.. gelernt habe ich was und das ist das wichtigste!!  :###


----------



## thE_29 (10. Jul 2006)

short hat 2 bytes, int hat 4 bytes 

In Java ist das bisi anders als in C/C++


----------



## Dit (10. Jul 2006)

ja nen short hat 2 bytes..
und meine Aufgabe war nen Int in 2 byte un zu wandeln
aber da mein Kollege das auch nicht besser wusste

setzte er sowas in die Welt : 16-Bit int to 2 8-Bit Bytes
er hätte auch sagen 4 byte in 2 byte.. 
vielleicht wäre ich dann auf den short gekommen!

naja egal!
jetzt habe ich es ja! und du hast dich als guter Berater bewiesen  :lol:


----------

