Boa tarde pessoas, como estão? Espero que bem
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.
É 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.
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éticasE e OU e também operações lógicas E e OU.
Já os operadores && e || servem somente para realizar a operações lógicasE 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;
}
}
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
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.
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 |.
