online - java interview questions

Diferencia entre & y &&

Question

Siempre pensé que el operador && en Java se utiliza para verificar si sus dos operandos booleanos son true , y el operador & se usa para realizar operaciones de bits en dos tipos enteros.

Recientemente llegué a saber que & operador también se puede usar para verificar si sus dos operandos booleanos son true , la única diferencia es que verifica el operando RHS incluso si el operando LHS es falso.

¿El operador & en Java está sobrecargado internamente? ¿O hay algún otro concepto detrás de esto?

Answer 1

& <- verifica ambos operandos
&& <- deja de evaluar si el primer operando se evalúa como falso ya que el resultado será falso

(x != 0) & (1/x > 1) <- esto significa evaluar (x != 0) luego evaluar (1/x > 1) luego hacer el &. el problema es que para x = 0 esto generará una excepción.

(x != 0) && (1/x > 1) <- esto significa evaluar (x != 0) y solo si esto es cierto, evalúa (1/x > 1) así que si tienes x = 0 entonces esto es perfectamente seguro y no lanzará ninguna excepción si (x! = 0) evalúa como falso todo el asunto se evalúa directamente como falso sin evaluar el (1/x > 1) .

EDITAR:

exprA | exprB exprA | exprB <- esto significa evaluar exprA luego evaluar exprB luego hacer el | .

exprA || exprB exprA || exprB <- esto significa evaluar exprA y solo si esto es false entonces evalúa exprB y haz el || .

Answer 2

& es un operador bit a bit más utilizado para verificar ambas condiciones porque a veces necesitamos evaluar ambas condiciones. Pero && operador lógico pasa a la 2ª condición cuando la primera condición da verdadero.

Answer 3

&& es un operador de cortocircuito mientras que & es un operador AND.

Prueba esto.

    String s = null;
    boolean b = false & s.isEmpty(); // NullPointerException
    boolean sb = false && s.isEmpty(); // sb is false

Answer 4

''&&'': - es un operador lógico AND producir un valor booleano de verdadero o falso basado en la relación lógica de sus argumentos.

Por ejemplo: - Condition1 && Condition2

Si la Condición1 es falsa, entonces (Condición1 y Condición2) siempre será falsa, esa es la razón por la cual este operador lógico también se conoce como Operador de cortocircuito porque no evalúa otra condición. Si Condition1 es falso, entonces no hay necesidad de evaluar Condtiton2.

Si Condition1 es verdadero, se evalúa Condition2, si es verdadero, el resultado general será verdadero, de lo contrario será falso.

''&'': - es un operador Y de Bitwise. Produce uno (1) en la salida si ambos bits de entrada son uno. De lo contrario, produce cero (0).

Por ejemplo:-

int a = 12; // representación binaria de 12 es 1100

int b = 6; // representación binaria de 6 es 0110

int c = (a & b); // representación binaria de (12 y 6) es 0100

El valor de c es 4.

para referencia, consulte este http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html

Answer 5

Además de && y || Al estar en cortocircuito, también considere la precedencia del operador cuando mezcle las dos formas. Creo que no será inmediatamente evidente para todos que el resultado1 y el resultado2 contienen valores diferentes.

boolean a = true;
boolean b = false;
boolean c = false;

boolean result1 = a || b && c; //is true;  evaluated as a || (b && c)
boolean result2 = a  | b && c; //is false; evaluated as (a | b) && c

Answer 6

Además de no ser un evaluador perezoso evaluando ambos operandos, creo que las principales características de los operadores bit a bit comparan cada byte de operandos como en el siguiente ejemplo:

int a = 4;
int b = 7;
System.out.println(a & b); // prints 4
//meaning in an 32 bit system
// 00000000 00000000 00000000 00000100
// 00000000 00000000 00000000 00000111
// ===================================
// 00000000 00000000 00000000 00000100

Answer 7

Con booleanos, no hay diferencia de salida entre los dos. Puedes cambiar && y & o || y | y nunca cambiará el resultado de tu expresión.

La diferencia radica en la escena donde se procesa la información. Cuando aciertas una expresión "(a! = 0) & (b! = 0)" para a = 0 yb = 1, sucede lo siguiente:

left side: a != 0 --> false
right side: b 1= 0 --> true
left side and right side are both true? --> false
expression returns false

Cuando escribe una expresión (a != 0) && ( b != 0) cuando a = 0 yb = 1, sucede lo siguiente:

a != 0 -->false
expression returns false

Menos pasos, menos procesamiento, mejor codificación, especialmente al hacer muchas expresiones booleanas o argumentos complicados.

Answer 8

Creo que mi respuesta puede ser más comprensible:

Hay dos diferencias entre & y && .

Si lo usan como lógico Y

& y && puede ser lógico AND , cuando el resultado de la expresión & y && left and right all es verdadero, el resultado de la operación completa puede ser verdadero.

cuando & y && como AND lógico, hay una diferencia:

cuando se usa && como AND lógico, si el resultado de la expresión izquierda es falso, la expresión correcta no se ejecutará.

Toma el ejemplo:

String str = null;

if(str!=null && !str.equals("")){  // the right expression will not execute

}

Si usas & :

String str = null;

if(str!=null & !str.equals("")){  // the right expression will execute, and throw the NullPointerException 

}

Otro ejemplo más:

int x = 0;
int y = 2;
if(x==0 & ++y>2){
    System.out.print(“y=”+y);  // print is: y=3
}

int x = 0;
int y = 2;
if(x==0 && ++y>2){
    System.out.print(“y=”+y);  // print is: y=2
}

y puede ser utilizado como operador de bit

& puede usarse como operador AND Bitwise, && no puede.

El operador AND "&" bit a bit produce 1 si y solo si ambos bits en sus operandos son 1. Sin embargo, si los dos bits son 0 o ambos son diferentes, entonces este operador produce 0. Para ser más precisos en bits Y el operador "&" devuelve 1 si alguno de los dos bits es 1 y devuelve 0 si alguno de los bits es 0.

De la página wiki:

http://www.roseindia.net/java/master-java/java-bitwise-and.shtml

Answer 9

Depende del tipo de argumentos ...

Para los argumentos enteros, el signo único ("&") es el operador "bit-wise AND". El doble ampersand ("&&") no se define para nada más que para dos argumentos booleanos.

Para argumentos booleanos, el signo comercial único constituye el operador lógico AND (incondicional), mientras que el signo doble ("&&") es el operador "operador lógico condicional". Es decir que el signo único siempre evalúa ambos argumentos, mientras que el signo doble solo evaluará el segundo argumento si el primer argumento es verdadero.

Para todos los demás tipos de argumentos y combinaciones, debe producirse un error en tiempo de compilación.

Answer 10

es como se especifica en el JLS (15.22.2) :

Cuando ambos operandos de a &, ^, o | operador son de tipo booleano o booleano, entonces el tipo de expresión de operador bit a bit es booleano. En todos los casos, los operandos están sujetos a la conversión de unboxing (§5.1.8) según sea necesario.

Para &, el valor del resultado es verdadero si ambos valores del operando son verdaderos; de lo contrario, el resultado es falso.

Para ^, el valor del resultado es verdadero si los valores del operando son diferentes; de lo contrario, el resultado es falso.

Para |, el valor del resultado es falso si ambos valores del operando son falsos; de lo contrario, el resultado es verdadero.

El "truco" es que & es un operador de bits enteros así como un operador lógico booleano . Entonces, ¿por qué no? Ver esto como un ejemplo de sobrecarga del operador es razonable.

Answer 11

todas las respuestas son great , y parece que no is needed más respuesta, pero solo he querido señalar algo sobre el operador && llamado dependent condition

En las expresiones que usan el operador &&, una condición -llamaremos esto dependent condition puede requerir que otra condición sea verdadera para que la evaluación de la condición dependiente sea significativa.

En este caso, la condición dependiente debe colocarse después del operador && para evitar errores.

Considere la expresión (i != 0) && (10 / i == 2) . La condición dependiente (10 / i == 2) debe appear after del operador && para evitar la posibilidad de división por cero.

otro ejemplo (myObject != null) && (myObject.getValue() == somevaluse)

y otra cosa: && y || se llaman evaluación de cortocircuito porque el segundo argumento se ejecuta o evalúa only if el first argumento no not suffice para determine el value de la expression

Referencias: Java ™ How to Program (Early Objects), décima edición

Answer 12

&& y || se llaman operadores de cortocircuito. Cuando se usan, para || - si el primer operando se evalúa como true , entonces el resto de los operandos no se evalúan. Para && - si el primer operando se evalúa como false , el resto de ellos no se evalúa en absoluto.

entonces, if (a || (++x > 0)) en este ejemplo, la variable x no se incrementará si a es true .

Answer 13

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