Possiamo creare byte senza segno in Java

Sto cercando di convertire un byte con segno in unsigned. Il problema è che i dati che sto ricevendo sono senza segno e Java non supporta byte senza segno, quindi quando legge i dati li tratta come firmati.

Ho provato a convertirlo con la seguente soluzione che ho ottenuto da Stack Overflow.

public static int unsignedToBytes(byte a)
{
    int b = a & 0xFF;
    return b;
}

Ma quando viene nuovamente convertito in byte, ottengo gli stessi dati firmati. Sto cercando di utilizzare questi dati come parametro per una funzione di Java che accetta solo un byte come parametro, quindi non posso usare nessun altro tipo di dati. Come posso risolvere questo problema?

Non sono sicuro di aver capito la tua domanda.

Ho appena provato questo e per byte -12 (valore con segno) ha restituito un numero intero 244 (equivalente a un valore con byte senza segno ma digitato come int):

  public static int unsignedToBytes(byte b) {
    return b & 0xFF;
  }

  public static void main(String[] args) {
    System.out.println(unsignedToBytes((byte) -12));
  }

È quello che vuoi fare?

Java non consente di esprimere 244 come bytevalore, come farebbe C. Per esprimere numeri positivi sopra Byte.MAX_VALUE(127) è necessario utilizzare un altro tipo intero, come short, into long.

Il fatto che le primitive siano firmate in Java è irrilevante per il modo in cui sono rappresentate in memoria / transito: un byte è solo 8 bit e se lo interpretate come un intervallo firmato o no dipende da voi. Non esiste una bandiera magica per dire "questo è firmato" o "questo non è firmato".

Man mano che le primitive sono firmate, il compilatore Java ti impedirà di assegnare un valore superiore a +127 a un byte (o inferiore a -128). Tuttavia, non c'è nulla che ti impedisca di eseguire il downcasting di un int (o short) per raggiungere questo obiettivo:

int i = 200; // 0000 0000 0000 0000 0000 0000 1100 1000 (200)
byte b = (byte) 200; // 1100 1000 (-56 by Java specification, 200 by convention)

/*
 * Will print a negative int -56 because upcasting byte to int does
 * so called "sign extension" which yields those bits:
 * 1111 1111 1111 1111 1111 1111 1100 1000 (-56)
 *
 * But you could still choose to interpret this as +200.
 */
System.out.println(b); // "-56"

/*
 * Will print a positive int 200 because bitwise AND with 0xFF will
 * zero all the 24 most significant bits that:
 * a) were added during upcasting to int which took place silently
 *    just before evaluating the bitwise AND operator.
 *    So the `b & 0xFF` is equivalent with `((int) b) & 0xFF`.
 * b) were set to 1s because of "sign extension" during the upcasting
 *
 * 1111 1111 1111 1111 1111 1111 1100 1000 (the int)
 * &
 * 0000 0000 0000 0000 0000 0000 1111 1111 (the 0xFF)
 * =======================================
 * 0000 0000 0000 0000 0000 0000 1100 1000 (200)
 */
System.out.println(b & 0xFF); // "200"

/*
 * You would typically do this *within* the method that expected an 
 * unsigned byte and the advantage is you apply `0xFF` only once
 * and than you use the `unsignedByte` variable in all your bitwise
 * operations.
 *
 * You could use any integer type longer than `byte` for the `unsignedByte` variable,
 * i.e. `short`, `int`, `long` and even `char`, but during bitwise operations
 * it would get casted to `int` anyway.
 */
void printUnsignedByte(byte b) {
    int unsignedByte = b & 0xFF;
    System.out.println(unsignedByte); // "200"
}

Guida completa per lavorare con byte senza segno in Java:

Byte senza segno in Java

(Fonte per questa risposta.)

Java Language non fornisce nulla di simile alla unsignedparola chiave. Un bytesecondo le specifiche del linguaggio rappresenta un valore compreso tra -128 e 127. Ad esempio, se un byteviene cast su un intJava interpreterà il primo bit come segno e utilizzerà l' estensione del segno .

Detto questo, nulla ti impedisce di visualizzare bytesemplicemente 8 bit e interpretarli come un valore compreso tra 0 e 255. Tieni presente che non c'è niente che puoi fare per forzare la tua interpretazione sul metodo di qualcun altro. Se un metodo accetta a byte, allora quel metodo accetta un valore compreso tra -128 e 127, salvo diversa indicazione esplicita.

Ecco un paio di utili conversioni / manipolazioni per la tua convenienza:

Conversioni da / a int

// From int to unsigned byte
int i = 200;                    // some value between 0 and 255
byte b = (byte) i;              // 8 bits representing that value

// From unsigned byte to int
byte b = 123;                   // 8 bits representing a value between 0 and 255
int i = b & 0xFF;               // an int representing the same value

(Oppure, se sei su Java 8+, usa Byte.toUnsignedInt.)

Analisi / formattazione

Il modo migliore è utilizzare le conversioni di cui sopra:

// Parse an unsigned byte
byte b = (byte) Integer.parseInt("200");

// Print an unsigned byte
System.out.println("Value of my unsigned byte: " + (b & 0xFF));

Aritmetica

La rappresentazione a 2 complementi "funziona" per addizione, sottrazione e moltiplicazione:

// two unsigned bytes
byte b1 = (byte) 200;
byte b2 = (byte) 15;

byte sum  = (byte) (b1 + b2);  // 215
byte diff = (byte) (b1 - b2);  // 185
byte prod = (byte) (b2 * b2);  // 225

La divisione richiede la conversione manuale degli operandi:

byte ratio = (byte) ((b1 & 0xFF) / (b2 & 0xFF));

Non ci sono byte senza segno primitivi in ​​Java. La solita cosa è lanciarlo su un tipo più grande:

int anUnsignedByte = (int) aSignedByte & 0xff;

Penso che le altre risposte abbiano coperto la rappresentazione della memoria e il modo in cui gestirle dipende dal contesto in cui prevedi di utilizzarlo. Aggiungerò che Java 8 ha aggiunto un po 'di supporto per gestire i tipi senza segno . In questo caso, potresti usareByte.toUnsignedInt

int unsignedInt = Byte.toUnsignedInt(myByte);

Una nota a margine, se vuoi stamparlo, puoi semplicemente dire

byte b = 255;
System.out.println((b < 0 ? 256 + b : b));

Se pensi di cercare qualcosa di simile.

public static char toUnsigned(byte b) {
    return (char) (b >= 0 ? b : 256 + b);
}

Adamski ha fornito la risposta migliore, ma non è del tutto completa, quindi leggi la sua risposta, in quanto spiega i dettagli che non sono.

Se si dispone di una funzione di sistema che richiede il passaggio di un byte senza segno, è possibile passare un byte con segno poiché lo tratterà automaticamente come un byte senza segno.

Pertanto, se una funzione di sistema richiede quattro byte, ad esempio 192 168 0 1 come byte senza segno, è possibile passare -64 -88 0 1 e la funzione continuerà a funzionare, poiché l'atto di passarli alla funzione li annullerà la firma .

Tuttavia è improbabile che tu abbia questo problema poiché le funzioni di sistema sono nascoste dietro le classi per la compatibilità multipiattaforma, anche se alcuni dei metodi di lettura java.io restituiscono byte non sospesi come int.

Se vuoi vederlo funzionare, prova a scrivere byte firmati in un file e rileggili come byte non firmati.

Puoi anche:

public static int unsignedToBytes(byte a)
{
    return (int) ( ( a << 24) >>> 24);
}    

Spiegazione:

diciamo a = (byte) 133;

In memoria è memorizzato come: "1000 0101" (0x85 in esadecimale)

Quindi la sua rappresentazione traduce unsigned = 133, firmato = -123 (come complemento di 2)

a << 24

Quando lo spostamento a sinistra viene eseguito 24 bit a sinistra, il risultato è ora un numero intero di 4 byte che è rappresentato come:

"10000101 00000000 00000000 00000000" (o "0x85000000" in esadecimale)

Poi abbiamo

(a << 24) >>> 24

e si sposta nuovamente a destra di 24 bit ma si riempie di zeri iniziali. Quindi risulta a:

"00000000 00000000 00000000 10000101" (o "0x00000085" in esadecimale)

e questa è la rappresentazione senza segno che equivale a 133.

Se provassi a trasmettere, a = (int) a; ciò che accadrebbe è che mantiene la rappresentazione del complemento di 2 di byte e la memorizza come int anche come complemento di 2:

(int) "10000101" ---> "11111111 11111111 11111111 10000101"

E questo si traduce in: -123

Sto cercando di utilizzare questi dati come parametro per una funzione di Java che accetta solo un byte come parametro

Questo non è sostanzialmente diverso da una funzione che accetta un numero intero a cui si desidera passare un valore maggiore di 2 ^ 32-1.

Sembra che dipende da come viene definita e documentata la funzione; Vedo tre possibilità:

1. Può documentare esplicitamente che la funzione considera il byte come un valore senza segno, nel qual caso la funzione dovrebbe probabilmente fare quello che ti aspetti ma sembra essere implementata in modo errato. Per il caso intero, la funzione dichiarerebbe probabilmente il parametro come intero senza segno, ma ciò non è possibile per il caso byte.

2. Potrebbe documentare che il valore di questo argomento deve essere maggiore di (o forse uguale a) zero, nel qual caso si sta abusando della funzione (passando un parametro fuori range), aspettandosi che faccia più di quanto non fosse progettato per fare. Con un certo livello di supporto per il debug potresti aspettarti che la funzione generi un'eccezione o fallisca un'asserzione.

3. La documentazione non può dire nulla, nel qual caso un parametro negativo è, beh, un parametro negativo e se ciò ha un significato dipende da cosa fa la funzione. Se questo non ha senso, allora forse la funzione dovrebbe davvero essere definita / documentata come (2). Se questo è significativo in modo inopportuno (ad esempio, i valori non negativi vengono utilizzati per indicizzare in un array e i valori negativi vengono utilizzati per indicizzare indietro dalla fine dell'array, quindi -1 significa l'ultimo elemento) la documentazione dovrebbe dire cosa significa e mi aspetterei che non è quello che vuoi che faccia comunque.

Se hai una funzione a cui deve essere passato un byte con segno, cosa ti aspetti che faccia se passi un byte senza segno?

Perché non puoi usare nessun altro tipo di dati?

Insolitamente è possibile utilizzare un byte come byte senza segno con traduzioni semplici o assenti. Tutto dipende da come viene utilizzato. Dovresti chiarire che cosa intendi farci.

Sebbene possa sembrare fastidioso (proveniente da C) che Java non includa byte senza segno nella lingua, in realtà non è un grosso problema poiché una semplice operazione "b & 0xFF" produce il valore senza segno per il byte (firmato) b nel (raro) situazioni che sono effettivamente necessarie. I bit in realtà non cambiano - solo l'interpretazione (che è importante solo quando si eseguono ad esempio alcune operazioni matematiche sui valori).

Non esiste alcun byte senza segno in Java, ma se si desidera visualizzare un byte, è possibile eseguire,

int myInt = 144;

byte myByte = (byte) myInt;

char myChar = (char) (myByte & 0xFF);

System.out.println("myChar :" + Integer.toHexString(myChar));

Produzione:

myChar : 90

Per ulteriori informazioni, consultare Come visualizzare un valore esadecimale / byte in Java .

Secondo le limitazioni in Java, il byte senza segno è quasi impossibile nell'attuale formato del tipo di dati. Puoi scegliere altre librerie di un'altra lingua per ciò che stai implementando e poi puoi chiamarle usando JNI .

Sì e no. Sono stato alla ricerca di questo problema. Come ho capito questo:

Il fatto è che java ha firmato l'interger da -128 a 127 .. È possibile presentare un unsigned in java con:

public static int toUnsignedInt(byte x) {
    return ((int) x) & 0xff;
}

Se per esempio aggiungi -12 il numero con segno per essere senza segno ottieni 244. Ma puoi usare di nuovo quel numero in firmato, deve essere spostato di nuovo in firmato e sarà di nuovo -12.

Se provi ad aggiungere 244 al java byte, otterrai OutfIndexException.

Saluti..

Se vuoi byte non firmati in Java, sottrai solo 256 dal numero che ti interessa. Produrrà il complemento a due con un valore negativo, che è il numero desiderato in byte non firmati.

Esempio:

int speed = 255; //Integer with the desired byte value
byte speed_unsigned = (byte)(speed-256);
//This will be represented in two's complement so its binary value will be 1111 1111
//which is the unsigned byte we desire.

È necessario utilizzare tali hack sporchi quando si utilizza leJOS per programmare il mattoncino NXT .