&& tem a mesma funçao de & e || tem a mesma funçao de | ?

Boa tarde pessoas, como estão? Espero que bem :slight_smile:
Estou estudando JAVA, uso Ubuntu e W10. Em ambos os sistemas uso o Notepad++ e executo no Terminal/CMD.

Estou praticando sistemas de decisoes um pouco mais complexos e me deparei em uma situação que deveria usar algum operador com função de “e” ou “ou”.
Pesquisando nos sites e apostilas descobri o |, ||, & e &&. Mas me veio a dúvida: “Qual a diferença entre || e | e entre & e && ?”.

Fiz varios testes e cheguei a comclusão de que || e | são a mesma coisa e que & e && também são a mesma coisa, operam da mesma forma.

Alguem com experiencia em JAVA pode confirmar essa informação ?

|| é o operador ou lógico
&& é o operador e lógico
|| é o operador ou aritmético
& é o operador e aritmético

Os operadores logísticos só funcionam com operandos boolean
Já os operadores aritméticos funcionam com operandos byte, short, int e long e, como o nome sugere, servem para realizar operações aritméticas.

Outra diferença é ao utilizar em esses operadores em um if ou em um operador ternário com operandos boolean:

  • Ao usar o operador &&, se o primeiro operando for false, o segundo operando nem é avaliado. Entretanto ao utilizar o operador &, ambos os operadores sempre são avaliados.
  • Ao usar o operador ||, se o primeiro operando for true, o segundo operando nem é avaliado. Entretanto ao utilizar o operador |, ambos os operadores sempre são avaliados.
3 curtidas

É aí que quero chegar. Eu fiz vários teste dentro de um IF para ver as diferenças entre & e &&.
Olha esse codigo simples que fiz de exemplo:
public static void main(String args[]) {
int x, y, z;
x = 10; y = 25; z = x+y;

    if(x == 15 & y == 25){
    System.out.println("Sum of x+y = " + z);
    }
	 System.out.println("CODE ENDED");
} 

Quando eu uso & e minha primeira conidção é falsa o IF devia avaliar a segunda condição e ver se é verdadeira. No caso desse trecho a segunda condição é verdadeira e, sendo assim, a maquina deveria imprimir: "Sum of x+y = " + z. Mas isso não acontece. A maquina pula direto para CODE ENDED.

Estou fazendo algo de errado? O que ficou dubentendido por mim?

& é aritimético, && operador lógico, logo, o correto é

if (x == 15 && y == 25){ // Se x for igual a 15 e y igual a 25.
sout("A soma de x + y é = " + z); //Acontece a resposta.
} else { //Senão:
sout("Fim do código"); //Fim do código.
}

Mas ele faz isso, ele só não entra no if pois a expressão num todo retorna false.
É uma operação e, só vai entrar no if quando ambos os operandos forem verdade.

Então o código tá correto?

Sim, a única diferença é que esta condição:

if (x == 15 && y == 25)

É mais rápida do que esta:

if (x == 15 & y == 25)
1 curtida

Se a única diferença é essa, existe algum motivo para esse operador não ser descontinuado? Afinal, se o && é até o padrão ensinado nas faculdades e ainda é superior em performance…

Essa é a única diferença na operação lógica postada acima.

Os operadores & e | servem para realizar a operações aritméticas E e OU e também operações lógicas E e OU.
Já os operadores && e || servem somente para realizar a operações lógicas E e OU.

Operações lógicas possuem operandos boolean.
Operações aritméticas possuem operadores byte, short, int ou long.

Pesquise por Álgebra de Boole.
Execute o exemplo abaixo para entender:

public class Exemplo {

    public static void main(String[] args) throws Exception {
        Exemplo programa = new Exemplo();
        programa.executar();
    }

    private int x = 10;
    private int y = 25;

    public void executar() {
        operacao_E_logica();
        operacao_E_aritmetica();
        outra_operacao_E_aritmetica();
    }

    private void operacao_E_logica() {
        System.out.println("executando E logico {");
        if (condicao1() && condicao2()) {
            System.out.println("  entrou no if");
        } else {
            System.out.println("  nao entrou no if");
        }
        System.out.println("}");
    }

    private void operacao_E_aritmetica() {
        System.out.println("executando E aritmetico {");
        if (condicao1() & condicao2()) {
            System.out.println("  entrou no if");
        } else {
            System.out.println("  nao entrou no if");
        }
        System.out.println("}");
    }

    private void outra_operacao_E_aritmetica() {
        System.out.println("executando outro E aritmetico {");
        int z = x & y;
        System.out.println("  x <- " + x + "    x = " + bits(x));
        System.out.println("  y <- " + y + "    y = " + bits(y));
        System.out.println("  z <-  " + z + "    z = " + bits(z));
        System.out.println("}");
    }

    private String bits(int n) {
        return String.format("%8s", Integer.toBinaryString(n)).replace(' ', '0');
    }

    private boolean condicao1() {
        int valor = 15;
        boolean resultado = x == valor;
        System.out.println("  condicao 1:    x <- " + x + "    x == " + valor + " -> " + resultado);
        return resultado;
    }

    private boolean condicao2() {
        int valor = 25;
        boolean resultado = y == valor;
        System.out.println("  condicao 2:    y <- " + y + "    y == " + valor + " -> " + resultado);
        return resultado;
    }
}
6 curtidas

Mas isso desmente o

dito anteriormente :confused:

Me desculpa se não estou sendo compreensivo. É que fiz vários testes pesquisas em diferentes foruns e plataformas mas ainda não achei a resposta para essa minha dúvida.

Se a for diferente de b, a comparação de c e d nem vai ser executada

if(a == b && c == d) {}

Se a for diferente de b, a comparação de c e d vai ser executada e mesmo que de true, não vai entrar no if, pois as duas condições teriam que ser verdade

if(a == b & c == d) {}
1 curtida

Eu acho que o seu conceito de avaliação das condições está equivocado.
Quando você disse:

Quando eu uso & e minha primeira conidção é falsa o IF devia avaliar a segunda condição e ver se é verdadeira. No caso desse trecho a segunda condição é verdadeira e, sendo assim, a maquina deveria imprimir: "Sum of x+y = " + z. Mas isso não acontece. A maquina pula direto para CODE ENDED.

O operador E (tanto o && quanto o &) só vão retornar VERDADEIRO se ambas as afirmações são verdadeiras.
Utilizando seu próprio código como exemplo:

public class Exemplo{
    public static void main (String[] args){
        int x, y, z;
        x = 10; y = 25; z = x + y;
            if(x == 15 & y == 25){
                System.out.println("Sum of x+y = " + z);
            }
            System.out.println("CODE ENDED");
            }
        }

Nesse programa você está verificando SE a variável x é igual a 15 E a variável y é igual a 25, correto?
Foi atribuído o valor de x como sendo 10, logo é diferente de 15, então x == 15 vai retornar FALSO.
Se você utilizar &&, a segunda parte ( y == 25) não será analisada pelo programa, e vai para

System.out.println(“CODE ENDED”);

Já se você utilizar &, a segunda parte será analisada pelo programa e também vai para

System.out.println(“CODE ENDED”);

Isso porque só vai entrar no IF se x == 15 E y == 25.
Independente de qual operador você utilizar, PARA ESSE PROGRAMA não mudará o resultado.

Acredito que valha a pena você dar uma pesquisada sobre tabela verdade, pode ajudar.

Espero ter ajudado

1 curtida

Show! Agora sim entendi o que me foi dito desde as primeiras respostas :smiley:
Muito obrigado.
Para finalizar:

É mais rápido apenas porque && não confere a segunda condição ?
Qual seria a(s) vantagem, além da rapidez ?

Não precisa se desculpar, você está aprendendo.

Você já estudou álgebra de Boole?

Sabe como funcionam as operações lógicas OU e E?

Veja as tabelas verdade abaixo:

Operação OU

     LÓGICA ( A || B )            ARITMÉTICA (A | B)
+-------+-------+-------+    +-------+-------+-------+
|   A   |   B   | Result|    |   A   |   B   | Result|
+-------+-------+-------+    +-------+-------+-------+
| false | false | false |    |   0   |   0   |   0   |
+-------+-------+-------+    +-------+-------+-------+
| false | true  | true  |    |   0   |   1   |   1   |
+-------+-------+-------+    +-------+-------+-------+
| true  | false | true  |    |   1   |   0   |   1   |
+-------+-------+-------+    +-------+-------+-------+
| true  | true  | true  |    |   1   |   1   |   1   |
+-------+-------+-------+    +-------+-------+-------+

Operação E

     LÓGICA ( A && B )            ARITMÉTICA (A & B)
+-------+-------+-------+    +-------+-------+-------+
|   A   |   B   | Result|    |   A   |   B   | Result|
+-------+-------+-------+    +-------+-------+-------+
| false | false | false |    |   0   |   0   |   0   |
+-------+-------+-------+    +-------+-------+-------+
| false | true  | false |    |   0   |   1   |   0   |
+-------+-------+-------+    +-------+-------+-------+
| true  | false | false |    |   1   |   0   |   0   |
+-------+-------+-------+    +-------+-------+-------+
| true  | true  | true  |    |   1   |   1   |   1   |
+-------+-------+-------+    +-------+-------+-------+

No seu exemplo você inicializa duas variáveis:

x = 10
y = 25

E você tem duas condições:

x == 15
y == 25

Aí você escreveu um if com a seguinte expressão:

if (x == 15 & y == 25) {
    // condição verdadeira
} else {
    // condição falsa
}

Vamos dizer que:

x == 15 é a condição A
y == 25 é a condição B

Então podemos deduzir que:

A = false
B = true

Se você olhar as tabelas verdade acima, qual é o resultado da seguinte expressão?

A && B

Será false, por isso ele não entra no if

Se você prestar atenção nas tabelas verdade, a operação E só é true quando tanto o A quanto o B forem true
Se um dos dois for false a expressão toda é false

Você não está notando a diferença pois está fazendo uma operação aritmética com operandos boolean

A && B é uma operação lógica, quando o A for false ele nem vai avaliar o B pois, conforme a tabela verdade, basta ter um false para o resultado ser false

A & B é uma operação aritmética.

Um boolean de valor false nada mais é do que um byte de valor 0, ou seja, os seguinte 8 bits: 00000000

Um boolean de valor true nada mais é do que um byte de valor 1, ou seja, os seguinte 8 bits: 00000001

Então o processador vai realizar a operação E com os bits do A e do B, isto é: 00000000 & 00000001 = 00000000

Os bits 00000000 equivalem à um byte de valor 0, que equivale à um boolean de valor false

Resumindo:

Quando quiser fazer testes LÓGICOS, utilize os operadores LÓGICOS && e ||

Quando quiser fazer operações aritméticas com os bits de variáveis inteiras, utilize os operadores ARITMÉTICOS & e |.

3 curtidas

Estou dando uma olhada aqui. Lembra um pouco a matéria de conjuntos do colégio.

Vou fechar a tópico por aqui.
Muito obrigado a todos, as respostas de vocês me foram muito esclarecedoras.
Valeu :wink:

2 curtidas