Diferencia entre & y &&

Además de no ser un evaluador perezoso al evaluar ambos operandos, creo que las principales características de los operadores bitwise 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

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

Depende del tipo de argumentos...

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

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

Para todos los demás tipos de argumentos y combinaciones, debería ocurrir un error en tiempo de compilación.

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

Prueba esto.

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

Creo que mi respuesta puede ser más comprensible:

Hay dos diferencias entre & y &&.

Si utilizan como lógica Y

& y && puede ser lógico AND, cuando el & o && resultado de la expresión izquierda y derecha todo es verdadero, el resultado de toda la operación puede ser verdadero.

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

Cuando use && como AND lógico, si el resultado de la expresión izquierda es false, el la expresión correcta no se ejecutará.

Tomemos el ejemplo :

String str = null;

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

}

Si se usa &:

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
}

& se puede utilizar como operador de bits

& se puede usar como operador AND Bitwise, && no se puede.

El operador bitwise Y " &" produce 1 si y solo si ambos bits en sus operandos son 1. Sin embargo, si ambos bits son 0 o ambos bits son diferentes, entonces esto operador produce 0. Para ser más precisos, 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

Es como se especifica en el JLS (15.22.2):

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

Para &, el valor del resultado es true si ambos valores de operando son true; de lo contrario, el resultado es false.

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 false si ambos valores de operando son false; de lo contrario, el resultado es true.

El "truco" es que & es un Operador Entero Bitwise así como un Operador Lógico Booleano. Entonces, por qué no, ver esto como un ejemplo para la sobrecarga del operador es razonable.

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

Por ejemplo: - Condition1 & & Condition2

Si Condition1 es false, entonces (Condition1 && Condition2) siempre será false, esa es la razón por la que este operador lógico también se conoce como Operador de cortocircuito porque no evalúa otra condición. Si Condition1 es false, entonces no hay necesidad de evaluar Condtiton2.

Si Condition1 es true, entonces Condition2 se evalúa, si es true entonces el resultado general será true de lo contrario será false.

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

Por ejemplo: -

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

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

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

El el valor de c es 4.

Para referencia , refiera esto http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html

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

Así que if (a || (++x > 0)) en este ejemplo la variable x no se incrementará si a fuera true.

Con booleanos, no hay diferencia de salida entre los dos. Puede intercambiar & & y & o / / y / y nunca cambiará el resultado de su expresión.

La diferencia está detrás de la escena donde se procesa la información. Cuando enderezas una expresión " (a!= 0) & (b != 0)" para a = 0 y b = 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 escribes una expresión (a != 0) && ( b != 0) cuando a = 0 y b = 1, sucede lo siguiente:

a != 0 -->false
expression returns false

Menos pasos, menos procesamiento, mejor codificación, especialmente cuando se hacen muchas expresiones booleanas o argumentos complicados.

Además de que && y || son cortocircuitos, también considere la precedencia del operador al mezclar las dos formas. Creo que no será inmediatamente evidente para todos que result1 y result2 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

& es un operador bitwise plus utilizado para comprobar ambas condiciones porque a veces necesitamos evaluar ambas condiciones. Pero el operador & & lógico va a la 2da condición cuando la primera condición da verdadero.

Todas las respuestas son great, y parece que no más respuesta is needed pero solo quería señalar algo sobre && operador llamado dependent condition

En expresiones que usan el operador &&, una condición-la llamaremos 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). El la condición dependiente (10 / i == 2) debe appear after el 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 argumento first hace not suffice a determine el value del expression

Referencias: Java™ Cómo Programar (Objetos antiguos), Décima Edición