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

[Dit]

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]

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]

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]

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]

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]

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));

number: 2006 bitmask: 11111010110

low: -42 bitmask: 11010110

high: 7 bitmask: 111

new_number: 2006 bitmask: 11111010110

 

[Beni]

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]

: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]

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]

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

das war aber leicht :bae:

 

[Dit]

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]

Sind wir ein bisi Denkfaul?!

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

sowas?!

 

[Dit]

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]

Häkchen setzen net vergessen!

 

[Dit]

ok ^^
danke!

 

[Dit]

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]

short hat 2 bytes, int hat 4 bytes

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

 

[Dit]

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: