Fazendo alguns testes obtive o mesmo resultado usando:
if((arg0 | arg1 | arg2 | arg3)>=0){}e
if((arg0>=0) && (arg1>=0) && (arg2>=0) && (arg3>=0)){}
//código corrigido
foi apenas coincidência ou os dois modos estão corretos , pois ouvi falar que o primeiro é operador binário!?
Você não testou direito. Se pelo menos um de arg0, arg1, arg2 ou arg3 for negativo, o resultado do “OR” de todos esses valores será negativo. (Isso fica como exercício).
O operador de curto circuito ‘||’ ele verifica a primeira condição e já determina a resposta, pois se um for verdadeiro… as outras condiçoes não interessa, vai ser verdadeiro.
Já no operador ‘|’ ele vai verificar todas as condições, ai você faz o teste pra ver os resultados…
Opa , digitei o segundo código errado. >.<
if((arg0>=0) && (arg1>=0) && (arg2>=0) && (arg3>=0)){}ai ta corrigido , mas valeu pela resposta!
mas o primeiro seria operador binário!?
Vlw!
É um operador binário( bitwise) , ele compara bits também.
Lucas, ele não está usando o operador “|” com o tipo booleano. Ele está usando o operador “|” com inteiros, e o que ele está perguntando é o que ocorre se eu combinar uma porção de inteiros usando um “|” bit-a-bit . Do jeito que ele fez, se pelo menos um dos argumentos for negativo, o resultado vai dar diferente do esperado no segundo “if”.
O resultado foi o mesmo , mas o porque de funcionar se era uma verificação bit-a-bit!?
Estou com essa questão , foi coincidência ou esta correto!?
O operador ‘|’ é operador binário mesmo… Exemplo:
int a = 8, b = 1, c = (a | b);
System.out.println(c); //imprime 9Explicação:
1000 //8 em binário
0001 //1 em binário
-----------------------
1001 //pois (0 ou 1 = 1) ,(1 ou 0 = 1) e (0 ou 0 = 0)Então cuidado, que se você não souber como o ‘&’ e o ‘|’ funcionam as vezes a comparaçao vai dar certo e outras nao!
Entendeu?
[quote=geovanni.]O resultado foi o mesmo , mas o porque de funcionar se era uma verificação bit-a-bit!?
Estou com essa questão , foi coincidência ou esta correto!?[/quote]
Coincidência coisa nenhuma. O seu teste está incompleto. Rode o teste abaixo.
class TesteOr {
public static void teste (int arg0, int arg1, int arg2, int arg3) {
System.out.printf ("arg0 = %d, arg1 = %d, arg2 = %d, arg3 = %d %n", arg0, arg1, arg2, arg3);
if ((arg0 | arg1 | arg2 | arg3) >= 0) {
System.out.println ("A) Pelo menos um dos argumentos eh maior ou igual a zero");
}
System.out.println ("O valor de arg0|arg1|arg2|arg3 eh " + (arg0 | arg1 | arg2 | arg3));
if (arg0 >= 0 || arg1 >= 0 || arg2 >= 0 || arg2 >= 0) {
System.out.println ("B) Pelo menos um dos argumentos eh maior ou igual a zero");
}
System.out.println ();
}
public static void main (String[] args) {
teste (-1, 0, 0, 0);
teste (-1, 3, 0, 0);
teste (0, 0, 0, 0);
teste (10, 20, 30, 40);
teste (-1, -2, -3, -4);
}
}Se as expressões fossem equivalentes, para cada conjunto de números, deveria aparecer para todos os casos "A) Pelo menos um dos argumentos eh maior ou igual a zero" e "B) Pelo menos um dos argumentos eh maior ou igual a zero". Mas não é isso que acontece.
arg0 = -1, arg1 = 0, arg2 = 0, arg3 = 0
O valor de arg0|arg1|arg2|arg3 eh -1
B) Pelo menos um dos argumentos eh maior ou igual a zero
arg0 = -1, arg1 = 3, arg2 = 0, arg3 = 0
O valor de arg0|arg1|arg2|arg3 eh -1
B) Pelo menos um dos argumentos eh maior ou igual a zero
arg0 = 0, arg1 = 0, arg2 = 0, arg3 = 0
A) Pelo menos um dos argumentos eh maior ou igual a zero
O valor de arg0|arg1|arg2|arg3 eh 0
B) Pelo menos um dos argumentos eh maior ou igual a zero
arg0 = 10, arg1 = 20, arg2 = 30, arg3 = 40
A) Pelo menos um dos argumentos eh maior ou igual a zero
O valor de arg0|arg1|arg2|arg3 eh 62
B) Pelo menos um dos argumentos eh maior ou igual a zero
arg0 = -1, arg1 = -2, arg2 = -3, arg3 = -4
O valor de arg0|arg1|arg2|arg3 eh -1Possivelmente os resultados estão dando igual pois como ele ta verificando se todas as variáveis são positivas (ou zero), e devido ao complemento de 2 que o java utiliza para os tipos numéricos a comparação bit a bit sera negativa se um dos números for negativo. vamos a um exemplo:
para os números -1, 2, 0 e 1, como se daria o OU
11111111111111111111111111111111 = -1
00000000000000000000000000000010 = 2
00000000000000000000000000000000 = 0
00000000000000000000000000000001 = 1
-------------------------------- OU
11111111111111111111111111111111 = -1
ou seja devido ou primeiro bit de um numero negativo ser 1 (ligado) ele faz com que a resposta tenha o primeiro bit ligado sendo assim a resposta da um numero negativo que não validando a condição >=0.
Muita sorte, fazer um if com operadores binário que de a resposta esperada.
Até!
[quote=fernandosavio]O operador ‘|’ é operador binário mesmo… Exemplo:
int a = 8, b = 1, c = (a | b);
System.out.println(c); //imprime 9Explicação:
1000 //8 em binário
0001 //1 em binário
-----------------------
1001 //pois (0 ou 1 = 1) ,(1 ou 0 = 1) e (0 ou 0 = 0)Então cuidado, que se você não souber como o ‘&’ e o ‘|’ funcionam as vezes a comparaçao vai dar certo e outras nao!
Entendeu?[/quote]
Você está certo. Funciona porque o o OR binário realiza uma soma. Se for feito isso: if ((1 | 3 | 4) == 7) System.out.println("Valor certo")É a mesma coisa que fazer isso: if ((1 + 3 + 4) == 7) System.out.println("Valor certo")Só se deve usar operadores bit a bit (|, &, ^, ~) quando se sabe o que está fazendo.
Operadores bit a bit é muito usado na cadeira de Organização de computadores, para quem já fez ou vai fazer facu.
Na verdade, o OR não é uma soma… ele só “seta” os bits que estão desligados
( 1 + 3 + 4 = 8 e não a 7)
Como o entanglement já tinha citado no post dele, um valor negativo já invalidaria essa lógica, portanto não use esta forma como atalho.
Não confunda a cabeça da pobre criança 
Enquanto ele não aprender álgebra booleana, é melhor não dizer que AND é equivalente a um produto e OR é equivalenet a uma soma.
entanglement eu ja corrigi o código lá , de uma olhada , tinha digitado errado.
mas obrigado pelas respostas.
[quote=AbelBueno][quote=x@ndy]
Se for feito isso: if ((1 | 3 | 4) == 7) System.out.println("Valor certo")
É a mesma coisa que fazer isso: if ((1 + 3 + 4) == 7) System.out.println("Valor certo")
Só se deve usar operadores bit a bit (|, &, ^, ~) quando se sabe o que está fazendo.
[/quote]
Na verdade, o OR não é uma soma… ele só “seta” os bits que estão desligados
( 1 + 3 + 4 = 8 e não a 7)
Como o entanglement já tinha citado no post dele, um valor negativo já invalidaria essa lógica, portanto não use esta forma como atalho.[/quote]
Realmente eu errei não é 7 é 8, falha minha. O certo seria
if ((1 | 3 | 4) == 8) System.out.println("Valor certo")[/code][code]if ((1 + 3 + 4) == 8) System.out.println("Valor certo")[/code]ou[code]if ((1 | 3 | 4) == (1 + 3 + 4)) System.out.println("Valor certo")Só que o OR binario realiza uma soma sim, isso é Álgebra Booleana .
Pessoal, programar não é só escrever código e participar de fórum, vamos estudar…
[quote=entanglement][quote]
Funciona porque o o OR binário realiza uma soma.
[/quote]
Não confunda a cabeça da pobre criança
Enquanto ele não aprender álgebra booleana, é melhor não dizer que AND é equivalente a um produto e OR é equivalenet a uma soma.
[/quote]
Mas ai quando ele vai apreender? Creio que isso o instigue a buscar mais informações, já que, como já disse antes aqui, programar não é só escrever código e participar de fóruns.
[quote=x@ndy]
Realmente eu errei não é 7 é 8, falha minha. O certo seria
if ((1 | 3 | 4) == 8) System.out.println("Valor certo")[/code][code]if ((1 + 3 + 4) == 8) System.out.println("Valor certo")[/code]ou[code]if ((1 | 3 | 4) == (1 + 3 + 4)) System.out.println("Valor certo")Só que o OR binario realiza uma soma sim, isso é Álgebra Booleana .
Pessoal, programar não é só escrever código e participar de fórum, vamos estudar…[/quote]
Você chegou a rodar esse código antes de postar?
A tabela verdade de um OR é:
0 0 = 0
0 1 = 1
1 0 = 1
1 1 = 1
Quando você faz 1 | 3 | 4 está fazendo:
0111 = 7
Um teste bem simples? Rode o código:
System.out.println((1 | 3 | 4) );
System.out.println((1 + 3 + 4) );Valeu pelas respostas , deu de intender mais ou menos como funciona! =D