[JAVA] Perdo 256

[legolas93]

byte z1 = (byte) (4500>>8);
println(Integer.toBinaryString(z1));
byte z2 = (byte)(4500);
println(Integer.toBinaryString(z2));

int z3 = ((z1<<8)+ z2);
println(z3);

Mi stampa

10001
11111111111111111111111110010100
4244

Perchè ho perso 256?

Perchè il secondo Byte ha così tante cifre? :muro:

[banryu79]

Il valore letterale intero 4500 in binario è:"1000110010100".
Poi tu forzi il cast a byte. Il tipo Byte è formato di 8 bit, cioè 8 cifre binarie.
Se tronchi "1000110010100" a 8 cifre resta la parte: "xxxxx10010100" e il resto è perso nella conversione.

In Java i tipi primitivi sono tutti trattati come signed, non esiste il concetto di unsigned type.
Quindi qua:

Integer.toBinaryString(z2)

z2 viene convertito a int, prima di essere passato come argomento al metodo toBinaryString (che accetta un parametro di tipo int).

"z2" "unsigned" dovrebbe essere convertito come un int di valore "00000000 00000000 00000000 10010100" (148 in decimale), invece viene trattato come tipo signed e viene convertito in un int di valore "11111111 11111111 11111111 10010100" (-108 in decimale)

Prova a fare così:

byte z1 = (byte) (4500>>8);
println(Integer.toBinaryString(z1));
byte z2 = (byte)(4500);

int z2Cast = unsignedByteToInt(z2);
println(Integer.toBinaryString(z2Cast));

int z1Cast = unsignedByteToInt(z1);
int z3 = (z1Cast << 8) + z2Cast;
println(z3);

// da qualche parte, qualcosa tipo:
public static int unsignedByteToInt(byte b) {
return ((int) b) & 0xFF;
}

Non ho provato il codice e sono di fretta, ma dovrebbe essere corretto.

[legolas93]

Il valore letterale intero 4500 in binario è:"1000110010100".
Poi tu forzi il cast a byte. Il tipo Byte è formato di 8 bit, cioè 8 cifre binarie.
Se tronchi "1000110010100" a 8 cifre resta la parte: "xxxxx10010100" e il resto è perso nella conversione.

In Java i tipi primitivi sono tutti trattati come signed, non esiste il concetto di unsigned type.
Quindi qua:

Integer.toBinaryString(z2)

z2 viene convertito a int, prima di essere passato come argomento al metodo toBinaryString (che accetta un parametro di tipo int).

"z2" "unsigned" dovrebbe essere convertito come un int di valore "00000000 00000000 00000000 10010100" (148 in decimale), invece viene trattato come tipo signed e viene convertito in un int di valore "11111111 11111111 11111111 10010100" (-108 in decimale)

Prova a fare così:

byte z1 = (byte) (4500>>8);
println(Integer.toBinaryString(z1));
byte z2 = (byte)(4500);
println(Byte.valueOf(z2));

int z2Cast = unsignedByteToInt(z2);
int z1Cast = unsignedByteToInt(z1);
int z3 = (z1Cast << 8) + z2Cast;
println(z3);

// da qualche parte, qualcosa tipo:
public static int unsignedByteToInt(byte b) {
return ((int) b) & 0xFF;
}

Non ho provato il codice e sono di fretta, ma dovrebbe essere corretto.

Grazie mille davvero! :) Tutto funziona e ho capito anche perchè. Non potevo chiedere di meglio.

[wingman87]

4500 in binario è:
0001 0001 1001 0100
Mettendolo in un byte hai una perdita, esso viene troncato e diventa:
1001 0100
il cui valore è -108 (il primo bit è il bit di segno)
Integer.toBinaryString si aspetta un int, quando lo invochi quindi il byte viene automaticamente castato a int e in questo caso la conversione è senza perdita, ma su 4 byte -108 viene rappresentato come
1111 1111 1111 1111 1111 1111 1001 0100
Riguardo a questo invece:
int z3 = ((z1<<8)+ z2);
z1 vale 0001 0001, applicando l'operatore di shift viene implicitamente castato a int, poi avvenendo lo shift diventa
0001 0001 0000 0000
cioè 4352
anche z2, per via dell'operatore + viene castato implicitamente a int (ma non è particolarmente rilevante sottolinearlo). In ogni caso z2 vale -108 come detto più su. Quindi l'operazione diventa
4352 - 108
cioè appunto 4244

Reference:
http://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html

EDIT: avevo scritto la prima parte e dopo pranzo ho finito, non ho visto che nel frattempo ti avevano già risposto...

[legolas93]

Grazie Mille ad Entrambi :) davvero molto chiari :D