operador - java operator

Bitwise Y, Bitwise Inclusive O pregunta, en Java

Question

Tengo unas pocas líneas de código dentro de un proyecto, que no puedo ver el valor de ...

buffer[i] = (currentByte & 0x7F) | (currentByte & 0x80);

Lee el archivo búfer de un archivo, almacenado como bytes, y luego lo transfiere al búfer [i] como se muestra, pero no puedo entender cuál es el propósito general, ¿alguna idea?

Gracias

Answer 1

Como las otras respuestas ya indicadas, (currentByte & 0x7F) | (currentByte & 0x80) (currentByte & 0x7F) | (currentByte & 0x80) es equivalente a (currentByte & 0xFF) . El JLS3 15.22.1 dice que esto se promociona a un int :

Cuando ambos operandos de un operador &, ^, o | son de un tipo que es convertible (§5.1.8) a un tipo integral primitivo, la promoción numérica binaria se realiza primero en los operandos (§5.6.2). El tipo de expresión de operador bit a bit es el tipo promovido de los operandos.

porque JLS3 5.6.2 dice que cuando currentByte tiene byte tipo y 0x7F es un int (y este es el caso), ambos operandos se promueven a int .

Por lo tanto, el buffer será una matriz de elemento tipo int o más ancho.

Ahora, al ejecutar & 0xFF en un int , efectivamente mapeamos el rango de byte original -128..127 en el rango sin signo 0..255, una operación que a menudo usan las transmisiones de java.io por ejemplo.

Puedes ver esto en acción en el siguiente fragmento de código. Tenga en cuenta que para comprender lo que está sucediendo aquí, debe saber que Java almacena tipos integrales, excepto char , como valores de complemento de 2 .

byte b = -123;
int r = b;
System.out.println(r + "= " + Integer.toBinaryString(r));
int r2 = b & 0xFF;
System.out.println(r2 + "= " + Integer.toBinaryString(r2));

Finalmente, para un ejemplo del mundo real, consulte el Javadoc y la implementación del método de read de java.io.ByteArrayInputStream :

/**
* Reads the next byte of data from this input stream. The value
* byte is returned as an <code>int</code> in the range
* <code>0</code> to <code>255</code>. If no byte is available
* because the end of the stream has been reached, the value
* <code>-1</code> is returned.
*/
public synchronized int read() {
return (pos < count) ? (buf[pos++] & 0xff) : -1;
}

Answer 2

Creo que alguien pensó demasiado aquí. Eso no está bien.

Solo tengo un comentario

• Al autor original le preocupaba que el tiempo de ejecución reemplazara el byte con un entero nativo con signo (presumiblemente de 32 bits) y explícitamente intenta decirnos algo sobre que el bit de signo es "especial".

Es código dejado atrás. ¿A menos que sepas que estás en un tiempo de fuga apestoso? ¿Cuál es el tipo de ''buffer'' de todos modos?

Answer 3

El resultado de una operación Y a nivel de bit tiene un 1 en esos bits donde ambos bits son 1, mientras que el resultado de una operación OR bit a bit se basa en los bits donde cualquiera de los bits bot es 1.

Entonces una evaluación de ejemplo para el valor 0x65:

 01100101 0x65
& 01111111 0x7F
===============
01100101 0x65
01100101 0x65
& 10000000 0x80
===============
00000000 0x00
01100101 0x65
| 00000000 0x00
===============
01100101 0x65

Answer 4

Lo bueno de este tipo de operaciones lógicas es que puedes probar todas las combinaciones posibles (todas las 256) y verificar que obtienes la respuesta que esperabas.

Answer 5

La complicada lógica bit a bit es completamente superflua.

for (int i = 0; i < buffer.length; i++) {
buffer[i] = filebuffer[currentPosition + i] & 0xff;
}

hace lo mismo Si el búfer se declara como una matriz de bytes, puede omitir el & 0xff, pero desafortunadamente la declaración no se muestra.

La razón puede ser que el desarrollador original estaba confundido por los bytes que se firmaron en Java.

Answer 6

 (currentByte & 0x7F) | (currentByte & 0x80)

es equivalente a

 currentByte & (0x7F | 0x80)

que es igual

 currentByte & 0xFF

que es exactamente lo mismo que

 currentByte

Editar: solo miré en el lado derecho de la tarea, y todavía creo que la equivalencia es verdadera.

Sin embargo, parece que el código quiere convertir el byte con signo a un tipo más grande al interpretar el byte como unsigned.

¿Hay alguna forma más fácil de convertir byte firmado a unsigned en java?

Answer 7

Resulta que el archivo del que se leía el byte estaba en una notación de bit con signo, y de una longitud diferente, por lo tanto, se requería realizar esta tarea para permitir que se extendiera al tipo java int, mientras se conserva su señal correcta :)