Operadores Lógicos

Os operadores lógicos são utilizados para construir expressões que retornam um resultado booleano (true ou false).

Com exceção dos operadores if-then-else ternário e o NOT unário lógico, todos os demais envolvem dois operandos.

\|	OR lógico
\|\|	OR dinâmico
&	AND lógico
&&	AND dinâmico
^	XOR lógico
!	NOT unário lógico
\|=	Atribuição de OR
&=	Atribuição de AND
^=	Atribuição de XOR
?:	if-then-else ternário

Os operadores lógicos &, | e ^, podem ser aplicados em valores numéricos e booleanos.

Quando eles são aplicados no tipo boolean, eles são utilizados como operadores lógicos. Se forem aplicados no tipo numérico são utilizados como operadores bitwise. Você não precisa saber como funciona o bitwise no exame. https://www.vivaolinux.com.br/artigo/Bitwise-Escovando-os-bits

Temos os operadores lógicos && e || que muitas vezes são chamados de operadores short-circuit. Os operadores short-circuit são quase idênticos aos operadores bitwise & e |.

Table of Contents

Diferença entre os operadores lógico

Os operadores &&, || são lógicos, normalmente utilizados para avaliação de expressões lógicas.

Os operadores & e | são bit-wse, e operam com a lógica binária no nível de bits. Onde 0 equivale a falso e 1 a verdadeiro.

Exemplo:

0x55 & 0xf0 => 0x50.

Os operadores && e || atuam com o conceito de curto circuito.
Dependendo do resultado da primeira operação as segundas não são avaliadas. Exemplo:

true || ? == sempre true (não avalia o segundo operando).
false && ? == sempre false (não avalia o segundo operando).

public class OperadorLogico {

  public static void dievalGuizelini(){

    System.out.println("avaliando &");
    System.out.println(cond("1",true) & cond("1",false));
    System.out.println(cond("2",false) & cond("2",true));
    System.out.println(cond("3",true) & cond("3",true));
    
    System.out.println("avaliando &&");
    System.out.println(cond("1",true) && cond("1",false));
    System.out.println(cond("2",false) && cond("2",true));
    System.out.println(cond("3",true) && cond("3",true));
    
    // expressões numéricas
    System.out.println( 0x55 & 0x0f );
    System.out.println( 0x02 | 0x01 );
    System.out.println( 0x03 ^ 0x01 );

  }

  private static boolean cond(String caso, boolean p) {
    System.out.println("Avaliando "+ caso + " - " + p);
    return p;
  }

}

public class OperadorLogico {

public static void dievalGuizelini(){

System.out.println("avaliando &");

System.out.println(cond("1",true) & cond("1",false));

System.out.println(cond("2",false) & cond("2",true));

System.out.println(cond("3",true) & cond("3",true));

System.out.println("avaliando &&");

System.out.println(cond("1",true) && cond("1",false));

System.out.println(cond("2",false) && cond("2",true));

System.out.println(cond("3",true) && cond("3",true));

// expressões numéricas

System.out.println( 0x55 & 0x0f );

System.out.println( 0x02 | 0x01 );

System.out.println( 0x03 ^ 0x01 );

}

private static boolean cond(String caso, boolean p) {

System.out.println("Avaliando "+ caso + " - " + p);

return p;

}

Programar em Java – Operadores Lógicos && e ||

XOR Lógico (^)

O operador lógico XOR retorna verdadeiro apenas se os dois operandos forem diferentes (true/false ou false/true). Se os operandos forem iguais (true/true ou false/false) o retorno dele é false.

Tabela verdade do XOR

1 2 Res
F F False
T F True
F T True
T T False

    /*
    resultados iguais serão false
    resultados diferentes serão true
    */
    System.out.print((2<3) + "^" + (4>3) + " = ");
    System.out.println((2<3)^(4>3));
    System.out.print((2<3) + "^" + (4<3) + " = ");
		System.out.println((2<3)^(4<3));

resultados iguais serão false

resultados diferentes serão true

System.out.print((2<3) + "^" + (4>3) + " = ");

System.out.println((2<3)^(4>3));

System.out.print((2<3) + "^" + (4<3) + " = ");

System.out.println((2<3)^(4<3));

NOT Unário Lógico (!)

! Operador unário lógico de negação – nega o valor de uma expressão booleana.

    boolean success = false;
    System.out.println(success);
    System.out.println(!success);

boolean success = false;

System.out.println(success);

System.out.println(!success);

Atribuição de OR (|=)

O operador binário OR, ou disjunção binária devolve um bit 1 sempre que pelo menos um dos operandos seja ‘1’.

    int a = 60; //   60 = 0011 1100 
    int b = 13; //   13 = 0000 1101 
    int r = (a|b); // 61 =0011 1101
    System.out.println(r);

    System.out.println(a|=b);
    System.out.println(a);

int a = 60; // 60 = 0011 1100

int b = 13; // 13 = 0000 1101

int r = (a|b); // 61 =0011 1101

System.out.println(r);

System.out.println(a|=b);

System.out.println(a);

A conta é feita dessa maneira:

0011 110<strong>0</strong> representa o número 60 na forma binária
0000 110<strong>1</strong> representa o número 13 na forma binária
0011 110<strong>1</strong> representa o número 61 na forma binária (resultado)

faça a conta no sentido vertical da direita para a esquerda. Onde houver o número 1 o resultado será 1, só será 0 quando os dois resultados for 0.

0011 1100 representa o número 60 na forma binária

0000 1101 representa o número 13 na forma binária

0011 1101 representa o número 61 na forma binária (resultado)

faça a conta no sentido vertical da direita para a esquerda. Onde houver o número 1 o resultado será 1, só será 0 quando os dois resultados for 0.

Outro exemplo:

    int c = 11; //   11 = 0000 1011 
    int d = 29; //   29 = 0001 1101
                //   31 = 0001 1111
    System.out.println(c|=d);

int c = 11; // 11 = 0000 1011

int d = 29; // 29 = 0001 1101

// 31 = 0001 1111

System.out.println(c|=d);

Vamos pegar o primeiro exemplo a|=b é a mesma coisa de escrever a = a | b. O valor de a é 60 e depois da atribuição a|=b o valor de a recebe o valor 61.

http://professor.unisinos.br/ltonietto/tsi/ica/LogicaBinaria.pdf

Atribuição de And (&=)

O operador binário OR, ou disjunção binária devolve um bit 1 sempre que pelo menos dois dos operandos seja ‘1’.

    int a = 60; //   60 = 0011 1100 
    int b = 13; //   13 = 0000 1101 
    int r = (a&b); // 12 =0000 1100
    System.out.println(r);

    System.out.println(a&=b);
    System.out.println(a);

    int c = 11; //   11 = 0000 1011 
    int d = 29; //   29 = 0001 1101
                //   9 =  0000 1001
    System.out.println(c&=d);

int a = 60; // 60 = 0011 1100

int b = 13; // 13 = 0000 1101

int r = (a&b); // 12 =0000 1100

System.out.println(r);

System.out.println(a&=b);

System.out.println(a);

int c = 11; // 11 = 0000 1011

int d = 29; // 29 = 0001 1101

// 9 = 0000 1001

System.out.println(c&=d);

Atribuição de XOR (^=)

O operador binário XOR, ou disjunção binária devolve um bit 1 sempre que os operandos sejam diferentes.

    int a = 60; //   60 = 0011 1100 
    int b = 13; //   13 = 0000 1101 
    int r = (a^b); //49 = 0011 0001 
    System.out.println(r);

    System.out.println(a^=b);
    System.out.println(a);

    int c = 11; //   11 = 0000 1011 
    int d = 29; //   29 = 0001 1101
                //   22 = 0001 0110 
    System.out.println(c^=d);

int a = 60; // 60 = 0011 1100

int b = 13; // 13 = 0000 1101

int r = (a^b); //49 = 0011 0001

System.out.println(r);

System.out.println(a^=b);

System.out.println(a);

int c = 11; // 11 = 0000 1011

int d = 29; // 29 = 0001 1101

// 22 = 0001 0110

System.out.println(c^=d);

if-then-else ternário (?:)

O operador ternário é um recurso para tomada de decisões com objetivo similar ao do if/else, mas que é codificado em apenas uma linha.

    int numeroDias = new Random().nextInt(30) + 1;
    System.out.println("Dia " + numeroDias);
    System.out.println((numeroDias <= 15) ? "Primeira quinzena" : "Segunda quinzena");