Solución:
Esos son los operadores AND bit a bit y OR bit a bit.
int a = 6; // 110
int b = 4; // 100
// Bitwise AND
int c = a & b;
// 110
// & 100
// -----
// 100
// Bitwise OR
int d = a | b;
// 110
// | 100
// -----
// 110
System.out.println(c); // 4
System.out.println(d); // 6
Gracias a Carlos por señalar la sección apropiada en Java Language Spec (15.22.1, 15.22.2) con respecto a los diferentes comportamientos del operador en función de sus entradas.
De hecho, cuando ambas entradas son booleanas, los operadores se consideran Operadores lógicos booleanos y se comportan de manera similar al Condicional-Y (&&) y condicional-O (||), excepto por el hecho de que no cortocircuitan, por lo que lo siguiente es seguro:
if((a != null) && (a.something == 3)){
}
Esto no es:
if((a != null) & (a.something == 3)){
}
“Cortocircuito” significa que el operador no necesariamente examina todas las condiciones. En los ejemplos anteriores, && examinará la segunda condición sólo cuando a no es null (de lo contrario, la declaración completa devolverá falso, y sería discutible examinar las siguientes condiciones de todos modos), por lo que la declaración de a.something no generará una excepción, o se considera “seguro”.
los & El operador siempre examina todas las condiciones de la cláusula, por lo que en los ejemplos anteriores, a.something puede ser evaluado cuando a es de hecho un null valor, planteando una excepción.
Creo que estás hablando del significado lógico de ambos operadores, aquí tienes un resumen de tabla:
boolean a, b;
Operation Meaning Note
--------- ------- ----
a && b logical AND short-circuiting
a || b logical OR short-circuiting
a & b boolean logical AND not short-circuiting
a | b boolean logical OR not short-circuiting
a ^ b boolean logical exclusive OR
!a logical NOT
short-circuiting (x != 0) && (1/x > 1) SAFE
not short-circuiting (x != 0) & (1/x > 1) NOT SAFE
Evaluación de cortocircuito, evaluación mínima, o evaluación de McCarthy (después de John McCarthy) es la semántica de algunos operadores booleanos en algunos lenguajes de programación en los que el segundo argumento se ejecuta o evalúa solo si el primer argumento no es suficiente para determinar el valor de la expresión: cuando el el primer argumento de la función AND se evalúa como falso, el valor general debe ser falso; y cuando el primer argumento de la función OR se evalúa como verdadero, el valor general debe ser verdadero.
No es seguro significa que el operador siempre examina todas las condiciones de la cláusula, por lo que en los ejemplos anteriores, 1 / x puede evaluarse cuando x es, de hecho, un valor 0, lo que genera una excepción.
Sé que hay muchas respuestas aquí, pero todas parecen un poco confusas. Entonces, después de investigar un poco de la guía de estudio del oráculo de Java, se me ocurrieron tres escenarios diferentes de cuándo usar && o &. Los tres escenarios son Y lógico, bit a bit Y, y booleano Y.
Y lógico:
Y lógico (también conocido como Y condicional) utiliza el && operador. Es el significado de cortocircuito: si el operando izquierdo es falso, entonces el operando derecho no será evaluado.
Ejemplo:
int x = 0;
if (false && (1 == ++x) {
System.out.println("Inside of if");
}
System.out.println(x); // "0"
En el ejemplo anterior, el valor impreso en la consola de x será 0, porque el primer operando en la instrucción if es falso, por lo tanto, java no necesita calcular (1 == ++ x), por lo tanto, x no se calculará.
Y bit a bit:
Bitwise AND usa el Y operador. Se utiliza para realizar una operación bit a bit sobre el valor. Es mucho más fácil ver lo que está sucediendo al observar la operación en números binarios, por ejemplo:
int a = 5; // 5 in binary is 0101
int b = 12; // 12 in binary is 1100
int c = a & b; // bitwise & preformed on a and b is 0100 which is 4
Como puede ver en el ejemplo, cuando las representaciones binarias de los números 5 y 12 están alineadas, entonces un Y preformado bit a bit solo producirá un número binario donde el mismo dígito en ambos números tiene un 1. Por lo tanto, 0101 y 1100 == 0100. Que en decimal es 5 y 12 == 4.
Y booleano:
Ahora el operador booleano AND se comporta de manera similar y diferente tanto al AND bit a bit como al AND lógico. Me gusta pensar en ello como una preformación bit a bit Y entre dos valores booleanos (o bits), por lo tanto, usa Y operador. Los valores booleanos también pueden ser el resultado de una expresión lógica.
Devuelve un valor verdadero o falso, muy parecido al Y lógico, pero a diferencia del Y lógico, no está cortocircuitado. La razón es que, para realizar ese AND bit a bit, debe conocer el valor de los operandos izquierdo y derecho. Aquí hay un ex:
int x = 0;
if (false & (1 == ++x) {
System.out.println("Inside of if");
}
System.out.println(x); //"1"
Ahora, cuando se ejecute la instrucción if, se ejecutará la expresión (1 == ++ x), aunque el operando izquierdo sea falso. Por lo tanto, el valor impreso para x será 1 porque se incrementó.
Esto también se aplica a OR lógico (||), OR bit a bit (|) y OR booleano (|) Espero que esto aclare algo de confusión.