13 - Operadores Lógicos

Em Java, os operadores lógicos e bit a bit são essenciais para a realização de comparações e manipulação de valores. Eles são amplamente utilizados em estruturas de controle, manipulação de dados e em diversos algoritmos.

1. Operadores Lógicos

Os operadores lógicos em Java são utilizados para combinar expressões booleanas. As expressões retornam valores true ou false e são amplamente usados em estruturas de controle de fluxo, como if, while, entre outras.

1.1 Operador AND Lógico (&&)

O operador && retorna true somente quando ambas as expressões forem verdadeiras.

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

        if (a && b) {
            System.out.println("Ambas as expressões são verdadeiras.");
        } else {
            System.out.println("Pelo menos uma expressão é falsa.");
        }
    }
}
        
    

Saída: Pelo menos uma expressão é falsa.

1.2 Operador OR Lógico (||)

O operador || retorna true se pelo menos uma das expressões for verdadeira.

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

        if (a || b) {
            System.out.println("Pelo menos uma expressão é verdadeira.");
        } else {
            System.out.println("Ambas as expressões são falsas.");
        }
    }
}
        
    

Saída: Pelo menos uma expressão é verdadeira.

1.3 Operador NOT Lógico (!)

O operador ! inverte o valor de uma expressão booleana. Se a expressão for true, o operador retorna false e vice-versa.

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

        System.out.println("Valor de a: " + a);
        System.out.println("Valor de !a: " + !a);
    }
}
        
    

Saída: Valor de a: true
Valor de !a: false

2. Operadores Bit a Bit

Os operadores bit a bit são utilizados para realizar operações diretamente nos bits de números inteiros. Eles permitem manipular dados em nível mais baixo, muitas vezes sendo utilizados em sistemas embarcados, criptografia, e manipulação de dados binários.

2.1 Operador OR Bit a Bit (|)

O operador | realiza uma operação **OR bit a bit** entre dois números. Para cada bit, se pelo menos um dos bits for 1, o resultado será 1; caso contrário, o resultado será 0.

        
public class OrBitABit {
    public static void main(String[] args) {
        int a = 5;  // Representação binária: 0101
        int b = 3;  // Representação binária: 0011

        int resultado = a | b; // 0101 | 0011 = 0111 (7 em decimal)

        System.out.println("Resultado de a | b: " + resultado);
    }
}
        
    

Saída: Resultado de a | b: 7

2.2 Operador AND Bit a Bit (&)

O operador & realiza uma operação **AND bit a bit** entre dois números. Para cada bit, o resultado será 1 apenas se ambos os bits forem 1. Caso contrário, o resultado será 0.

        
public class AndBitABit {
    public static void main(String[] args) {
        int a = 5;  // Representação binária: 0101
        int b = 3;  // Representação binária: 0011

        int resultado = a & b; // 0101 & 0011 = 0001 (1 em decimal)

        System.out.println("Resultado de a & b: " + resultado);
    }
}
        
    

Saída: Resultado de a & b: 1

3. Diferença Entre Operadores Lógicos e Bit a Bit

A principal diferença é que os operadores lógicos operam com valores booleanos (true ou false), enquanto os operadores bit a bit manipulam diretamente os bits de valores inteiros.

Conclusão

Os operadores lógicos são ideais para verificar condições e tomar decisões no fluxo do programa, enquanto os operadores bit a bit são mais utilizados para manipulação de dados em nível binário, onde cada bit é crucial. Ambos são essenciais para trabalhar com estruturas de controle de fluxo e algoritmos mais avançados.

Tabela Resumo dos Operadores

Operador	Descrição	Exemplo
&&	AND lógico (verifica se ambas as condições são verdadeiras)	a && b
||	OR lógico (verifica se pelo menos uma condição é verdadeira)	a || b
!	NOT lógico (inverte o valor da condição)	!a
|	OR bit a bit (pelo menos um bit 1)	a | b
&	AND bit a bit (ambos os bits 1)	a & b

Acompanhe essa aula no YouTube: