Por que geralmente usamos || sobre |? Qual é a diferença?

Eu só estou me perguntando por que geralmente usamos OR lógico ||entre dois booleanos não bit a bit OU |, embora ambos estejam funcionando bem.

Quero dizer, veja o seguinte:

if(true  | true)  // pass
if(true  | false) // pass
if(false | true)  // pass
if(false | false) // no pass

if(true  || true)  // pass
if(true  || false) // pass
if(false || true)  // pass
if(false || false) // no pass

Podemos usar em |vez de ||? A mesma coisa com &e &&.

Se você usar os ||e &&formas, ao invés do |e &formas de estes operadores, Java não vai se preocupar em avaliar a direita operando sozinho.

É uma questão de se você deseja dar um curto-circuito na avaliação ou não - na maioria das vezes você deseja.

Uma boa maneira de ilustrar os benefícios do curto-circuito seria considerar o exemplo a seguir.

Boolean b = true;
if(b || foo.timeConsumingCall())
{
   //we entered without calling timeConsumingCall()
}

Outro benefício, como Jeremy e Peter mencionaram, para um curto-circuito é a verificação de referência nula:

if(string != null && string.isEmpty())
{
    //we check for string being null before calling isEmpty()
}

mais informações

| não faz avaliação de curto-circuito em expressões booleanas. ||parará de avaliar se o primeiro operando é verdadeiro, mas |não será.

Além disso, |pode ser usado para executar a operação OR bit a bit em valores de byte / short / int / long. ||não podes.

Portanto, para aproveitar as outras respostas com um exemplo, o curto-circuito é crucial nas seguintes verificações defensivas:

if (foo == null || foo.isClosed()) {
    return;
}

if (bar != null && bar.isBlue()) {
    foo.doSomething();
}

Usar |e, em &vez disso, pode resultar em NullPointerExceptionser jogado aqui.

Lógico ||e &&verifique o lado direito somente se necessário. O |e &verifique os dois lados toda vez.

Por exemplo:

int i = 12;
if (i == 10 & i < 9) // It will check if i == 10 and if i < 9
...

Reescreva-o:

int i = 12;
if (i == 10 && i < 9) // It will check if i == 10 and stop checking afterward because i != 10
...

Outro exemplo:

int i = 12;
if (i == 12 | i > 10) // It will check if i == 12 and it will check if i > 10
...

Reescreva-o:

int i = 12;
if (i == 12 || i > 10) // It will check if i == 12, it does, so it stops checking and executes what is in the if statement
...

Observe também uma armadilha comum: os operadores não preguiçosos têm precedência sobre os preguiçosos, portanto:

boolean a, b, c;
a || b && c; //resolves to a || (b && c)
a | b && c; //resolves to (a | b) && c

Tenha cuidado ao misturá-los.

Além do curto-circuito, outra coisa a ter em mente é que fazer uma operação lógica bit a bit em valores que podem ser diferentes de 0 ou 1 tem um significado muito diferente da lógica condicional. Embora geralmente seja o mesmo para |e ||, com &e &&você obtém resultados muito diferentes (por exemplo, 2 & 4é 0 / falso, enquanto 2 && 4é 1 / verdadeiro).

Se o que você obtém de uma função é realmente um código de erro e está testando não-0-ness, isso pode importar bastante.

Isso não é um problema tão grande em Java, no qual você precisa tipicamente explicitar para booleano ou comparar com 0 ou algo semelhante, mas em outros idiomas com sintaxe semelhante (C / C ++ et al), pode ser bastante confuso.

Além disso, observe que & e | só pode ser aplicado a valores do tipo inteiro e nem tudo o que pode ser equivalente a um teste booleano. Novamente, em linguagens não Java, existem algumas coisas que podem ser usadas como booleanas com uma != 0comparação implícita (ponteiros, flutuadores, objetos com um operator bool()etc.) e os operadores bit a bit são quase sempre sem sentido nesses contextos.

O único momento em que você usaria |ou em &vez de ||ou &&é quando você tem expressões booleanas muito simples e o custo de atalho (ou seja, uma ramificação) é maior que o tempo que você economiza ao não avaliar as expressões posteriores.

No entanto, essa é uma micro-otimização que raramente importa, exceto no código de nível mais baixo.

|| é o lógico ou operador enquanto | é o operador bit a bit ou

boolean a = true;
boolean b = false;

if (a || b) {
}

int a = 0x0001;
a = a | 0x0002;

a | b: avalie b em qualquer caso

a || b: avalie b apenas se a for avaliado como falso

Além do fato de que | é um operador bit a bit: || é um operador de curto-circuito - quando um elemento é falso, ele não verifica os outros.

 if(something || someotherthing)
 if(something | someotherthing)

se algo é VERDADEIRO, || não avaliará algo, enquanto | vai fazer. Se as variáveis ​​em suas instruções if forem realmente chamadas de função, use || possivelmente está economizando muito desempenho.

| is the binary or operator

|| is the logic or operator

Os operadores ||e &&são chamados operadores condicionais , enquanto |e &são chamados operadores bit a bit . Eles servem a propósitos diferentes.

Operadores condicionais funcionam apenas com expressões que são avaliadas estaticamente booleannos lados esquerdo e direito.

Operadores bit a bit funcionam com qualquer operando numérico.

Se você deseja realizar uma comparação lógica, use operadores condicionais , pois adicionará algum tipo de segurança de tipo ao seu código.

Uma observação: Java possui | =, mas não um || =

Um exemplo de quando você deve usar || é quando a primeira expressão é um teste para ver se a segunda expressão explodiria. por exemplo, usando um único | no seguinte caso pode resultar em um NPE.

public static boolean isNotSet(String text) {
   return text == null || text.length() == 0;
}

As outras respostas fizeram um bom trabalho ao cobrir a diferença funcional entre os operadores, mas as respostas podem se aplicar a praticamente todas as linguagens derivadas de C existentes hoje. A pergunta está marcada comJavae, por isso, tentarei responder específica e tecnicamente à linguagem Java.

&e |podem ser operadores inteiros bit a bit ou operadores lógicos booleanos. A sintaxe para os operadores bit a bit e lógicos ( §15.22 ) é:

AndExpression:
  EqualityExpression 
  AndExpression & EqualityExpression

ExclusiveOrExpression:
  AndExpression 
  ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:
  ExclusiveOrExpression 
  InclusiveOrExpression | ExclusiveOrExpression

A sintaxe para EqualityExpressioné definida no §15.21 , que requer RelationalExpressiondefinido no §15.20 , que por sua vez requer ShiftExpressione ReferenceTypedefinido nos §15.19 e §4.3 , respectivamente. ShiftExpressionOs requisitos AdditiveExpressiondefinidos no §15.18 , que continuam a detalhar, definindo a aritmética básica, os operadores unários, etc. detalham ReferenceTypetodas as várias maneiras de representar um tipo. (Embora ReferenceTypenão inclua os tipos primitivos, a definição de tipos primitivos é finalmente necessária, pois eles podem ser o tipo de dimensão para uma matriz, que é a ReferenceType.)

Os operadores bit a bit e lógicos têm as seguintes propriedades:

• Esses operadores têm precedência diferente, com &a maior e |a menor precedência.
• Cada um desses operadores é sintaticamente associativo à esquerda (cada grupo da esquerda para a direita).
• Cada operador é comutativo se as expressões do operando não tiverem efeitos colaterais.
• Cada operador é associativo.
• Os operadores bit a bit e lógicos podem ser usados ​​para comparar dois operandos do tipo numérico ou dois operandos do tipo boolean. Todos os outros casos resultam em um erro em tempo de compilação.

A distinção entre se o operador serve como operador bit a bit ou operador lógico depende se os operandos são "conversíveis em um tipo integral primitivo" ( §4.2 ) ou se são do tipo booleanou Boolean( §5.1.8 ).

Se os operandos são do tipo integral, a promoção numérica binária ( §5.6.2 ) é realizada nos dois operandos, deixando-os como longs ou ints para a operação. O tipo da operação será o tipo dos operandos (promovidos). Nesse ponto, &será AND bit a bit, ^será OR bit a bit exclusivo e |será OR bit a bit, inclusive. ( §15.22.1 )

Se os operandos forem booleanou Boolean, os operandos estarão sujeitos à conversão de unboxing, se necessário ( §5.1.8 ), e o tipo da operação será boolean. &resultará em truese ambos os operandos forem true, ^resultará em truese ambos operandos forem diferentes e |resultará em truese qualquer operando for true. ( §15.22.2 )

Por outro lado, && é o "Operador condicional-E" ( §15.23 ) e ||é o " Operador condicional-E " ( §15.24 ). Sua sintaxe é definida como:

ConditionalAndExpression:
  InclusiveOrExpression 
  ConditionalAndExpression && InclusiveOrExpression

ConditionalOrExpression:
  ConditionalAndExpression 
  ConditionalOrExpression || ConditionalAndExpression

&&é como &, exceto que ele avalia apenas o operando direito se o operando esquerdo estiver true. ||é como |, exceto que ele avalia apenas o operando direito se o operando esquerdo estiver false.

Condicional-E tem as seguintes propriedades:

• O operador condicional e é associativamente à esquerda sintaticamente (agrupa da esquerda para a direita).
• O operador condicional e é totalmente associativo em relação aos efeitos colaterais e ao valor do resultado. Ou seja, para qualquer expressão a, be cavaliação da expressão ((a) && (b)) && (c)produz o mesmo resultado, com os mesmos efeitos colaterais ocorrendo na mesma ordem, como avaliação da expressão (a) && ((b) && (c)).
• Cada operando do operador condicional e deve ser do tipo booleanou Boolean, ou ocorre um erro em tempo de compilação.
• O tipo de uma expressão condicional e é sempre boolean.
• No tempo de execução, a expressão do operando do lado esquerdo é avaliada primeiro; se o resultado tiver um tipo Boolean, ele estará sujeito à conversão de unboxing ( §5.1.8 ).
• Se o valor resultante for false, o valor da expressão condicional e é falsee a expressão do operando do lado direito não é avaliada.
• Se o valor do operando do lado esquerdo for true, a expressão do lado direito será avaliada; se o resultado tiver um tipo Boolean, ele estará sujeito à conversão de unboxing ( §5.1.8 ). O valor resultante se torna o valor da expressão condicional-e.
• Assim, &&calcula o mesmo resultado que &nos booleanoperandos. Difere apenas no fato de a expressão do operando do lado direito ser avaliada condicionalmente, e não sempre.

Condicional-Or tem as seguintes propriedades:

• O operador condicional ou é associativamente à esquerda sintaticamente (agrupa da esquerda para a direita).
• O operador condicional ou é totalmente associativo em relação aos efeitos colaterais e ao valor do resultado. Ou seja, para qualquer expressão a, be cavaliação da expressão ((a) || (b)) || (c)produz o mesmo resultado, com os mesmos efeitos colaterais ocorrendo na mesma ordem, como avaliação da expressão (a) || ((b) || (c)).
• Cada operando do operador condicional ou deve ser do tipo booleanou Boolean, ou ocorre um erro em tempo de compilação.
• O tipo de uma expressão condicional ou é sempre boolean.
• No tempo de execução, a expressão do operando do lado esquerdo é avaliada primeiro; se o resultado tiver um tipo Boolean, ele estará sujeito à conversão de unboxing ( §5.1.8 ).
• Se o valor resultante for true, o valor da expressão condicional ou é truee a expressão do operando do lado direito não é avaliada.
• Se o valor do operando do lado esquerdo for false, a expressão do lado direito será avaliada; se o resultado tiver um tipo Boolean, ele estará sujeito à conversão de unboxing ( §5.1.8 ). O valor resultante se torna o valor da expressão condicional-ou.
• Assim, ||calcula o mesmo resultado que |on booleanou Booleanoperandos. Difere apenas no fato de a expressão do operando do lado direito ser avaliada condicionalmente, e não sempre.

Resumindo, como @JohnMeagher apontou repetidamente nos comentários, &e |são, de fato, operadores booleanos sem curto-circuito no caso específico dos operandos serem um booleanou outro Boolean. Com boas práticas (ou seja, sem efeitos secundários), essa é uma pequena diferença. Quando os operandos não são booleans ou Booleans, no entanto, os operadores se comportam de maneira muito diferente: as operações bit a bit e lógicas simplesmente não se comparam bem no alto nível da programação Java.

1). (Expressão1 | expressão2), | O operador avaliará a expressão2, independentemente de o resultado da expressão1 ser verdadeiro ou falso.

Exemplo:

class Or 
{
    public static void main(String[] args) 
    {
        boolean b=true;

        if (b | test());
    }

    static boolean test()
    {
        System.out.println("No short circuit!");
        return false;
    }
}

2). (Expressão1 || expressão2), || O operador não avaliará a expressão2 se a expressão1 for verdadeira.

Exemplo:

class Or 
{
    public static void main(String[] args) 
    {
        boolean b=true;

        if (b || test())
        {
            System.out.println("short circuit!");
        }
    }

    static boolean test()
    {
        System.out.println("No short circuit!");
        return false;
    }
}

|| retorna um valor booleano OR'ing dois valores (é por isso que é conhecido como LOGICAL or)

IE:

if (A || B) 

Retornaria true se A ou B for true ou false se ambos forem falsos.

| é um operador que executa uma operação bit a bit em dois valores. Para entender melhor as operações bit a bit, você pode ler aqui:

http://en.wikipedia.org/wiki/Bitwise_operation

Uma diferença principal é que || e && exibem "curto-circuito"; portanto, o RHS será avaliado apenas se necessário.

Por exemplo

if (a || b) {
    path1...
} else {
    path2..
}

Acima, se a for verdadeiro, b não será testado e o caminho1 será executado. Se | foi usado, os dois lados serão avaliados mesmo se 'a' for verdadeiro.

Veja aqui e aqui , para um pouco mais de informação.

Espero que isto ajude.

Um curto-circuito não pode ser útil. Às vezes, você deseja garantir que duas expressões sejam avaliadas. Por exemplo, digamos que você tenha um método que remova um objeto de duas listas separadas. Você pode fazer algo assim:

class foo {

    ArrayList<Bar> list1 = new ArrayList<Bar>();
    ArrayList<Bar> list2 = new ArrayList<Bar>();

    //Returns true if bar is removed from both lists, otherwise false.
    boolean removeBar(Bar bar) {
        return (list1.remove(bar) & list2.remove(bar));
    }
}

Se, em vez disso, seu método usasse o operando condicional, ele falharia em remover o objeto da segunda lista se a primeira lista retornasse false.

//Fails to execute the second remove if the first returns false.
boolean removeBar(Bar bar) {
    return (list1.remove(bar) && list2.remove(bar));
}

Não é incrivelmente útil e (como na maioria das tarefas de programação), você pode consegui-lo com outros meios. Mas é um caso de uso para operandos bit a bit.

A diferença básica entre eles é que | primeiro converte os valores em binário e depois executa o bit ou operação. Enquanto isso, || não converte os dados em binários e apenas executa a expressão ou em seu estado original.

int two = -2; int four = -4;
result = two | four; // bitwise OR example

System.out.println(Integer.toBinaryString(two));
System.out.println(Integer.toBinaryString(four));
System.out.println(Integer.toBinaryString(result));

Output:
11111111111111111111111111111110
11111111111111111111111111111100
11111111111111111111111111111110

Leia mais: http://javarevisited.blogspot.com/2015/01/difference-between-bitwsie-and-logical.html#ixzz45PCxdQhk

Quando tive essa pergunta, criei o código de teste para ter uma idéia sobre isso.

public class HelloWorld{

   public static boolean bool(){
      System.out.println("Bool");
      return true;
   }

   public static void main(String []args){

     boolean a = true;
     boolean b = false;

     if(a||bool())
     {
        System.out.println("If condition executed"); 
     }
     else{
         System.out.println("Else condition executed");
     }

 }
}

Nesse caso, apenas alteramos o valor do lado esquerdo de se a condição adicionar a ou b.

|| Cenário, quando o lado esquerdo for verdadeiro [if (a || bool ())]

resultado "If condition executed"

|| Cenário, quando o lado esquerdo for falso [if (b || bool ())]

Resultado-

Bool
If condition executed

Conclusion of || Quando usado ||, o lado direito verifica apenas quando o lado esquerdo é falso.

| Cenário, quando o lado esquerdo for verdadeiro [if (a | bool ())]

Resultado-

Bool
If condition executed

| Cenário, quando o lado esquerdo for falso [if (b | bool ())]

Resultado-

Bool
If condition executed

Conclusion of | Quando usar |, verifique os lados esquerdo e direito.

| = bit a bit ou, || = lógica ou

normalmente eu uso quando há pré-incremento e pós-incremento. Veja o seguinte código:

package ocjpPractice;
/**
 * @author tithik
 *
 */
public class Ex1 {

    public static void main(String[] args) {
    int i=10;
    int j=9;
    int x=10;
    int y=9;
    if(i==10 | ++i>j){
        System.out.println("it will print in first if");  
        System.out.println("i is: "+i);
    }

    if(x==10 ||++x>y){
        System.out.println("it will print in second if");   
        System.out.println("x is: "+x);
    }
    }
}

resultado:

ele será impresso primeiro se
eu for: 11

ele será impresso primeiro se
x for: 10

os dois ifblocos são iguais, mas o resultado é diferente. quando houver |, ambas as condições serão avaliadas. Mas, se for ||, não avaliará a segunda condição, pois a primeira condição já é verdadeira.

Existem muitos casos de uso que sugerem por que você deveria procurar ||e não |. Alguns casos de uso precisam usar o |operador para verificar todas as condições.

Por exemplo, se você deseja verificar a validação do formulário e deseja mostrar ao usuário todos os campos inválidos com textos de erro, em vez de apenas um primeiro campo inválido.

|| operador seria,

   if(checkIfEmpty(nameField) || checkIfEmpty(phoneField) || checkIfEmpty(emailField)) {
      // invalid form with one or more empty fields
   }

   private boolean checkIfEmpty(Widget field) {
      if(field.isEmpty()) {
        field.setErrorMessage("Should not be empty!");
        return true;
      }
      return false;
   }

Portanto, com o snippet acima, se o usuário enviar o formulário com TODOS os campos vazios, APENAS nameFieldserá mostrado com mensagem de erro. Mas, se você mudar para,

   if(checkIfEmpty(nameField) | checkIfEmpty(phoneField) | checkIfEmpty(emailField)) {
      // invalid form with one or more empty fields
   }

Ele mostrará uma mensagem de erro adequada em cada campo, independentemente das truecondições.

Depois de ler atentamente, este tópico ainda não está claro para mim, se o uso |como operador lógico estiver em conformidade com as práticas padrão do Java.

Modifiquei recentemente o código em uma solicitação pull que aborda um comentário em que

if(function1() | function2()){
  ...
}

teve que ser alterado para

boolean isChanged = function1();
isChanged |= function2();
if (isChanged){
  ...
}

Qual é a versão realmente aceita?

A documentação Java não é mencionada |como um operador OR lógico, sem curto-circuito.

Não estou interessado em votar, mas mais em descobrir o padrão ?! Ambas as versões de código estão compilando e funcionando conforme o esperado.

|| é um lógico ou e | é um pouco sábio ou.

Operadores Java

| é bit a bit ou, || é lógico ou.

Dê uma olhada em:

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/operators.html

| é OR bit a bit, inclusive

|| é lógico OU

| é um operador bit a bit. || é um operador lógico.

Um vai levar dois bits e ou eles.

Determinaremos a verdade (isto ou aquilo) Se isso é verdade ou aquilo é verdade, então a resposta é verdadeira.

Ah, e as pessoas respondem a essas perguntas rapidamente.