Introdução aos operadores Java: lógicos, aritméticos, bit a bit

Vamos falar sobre operações em Java: numéricas, lógicas, bit a bit. Esta é uma base teórica definitivamente necessária para aprender a programar.

• Quais são os tipos de operadores em Java?
• Curso Operadores Java no JavaRush
• Operações numéricas em Java
• Operações Lógicas em Java
• Operações bit a bit em Java
• Precedência de operações em Java
• Exemplos úteis de uso

Quais são os tipos de operadores em Java?

Para qualquer operação precisamos de pelo menos duas coisas:

• operador;
• operando.

Um exemplo de operador seria um simples sinal de mais na operação de adição de dois números. E os números somados entre si serão operandos neste caso. Assim, com a ajuda de operadores, realizamos operações em um ou mais operandos. Operadores que realizam operações em dois operandos são chamados de binários. Por exemplo, adicionando dois números. Operadores que realizam operações em um único operando são chamados de unários. Por exemplo, um menos unário.

Curso Operadores Java no JavaRush

Várias palestras são dedicadas aos operadores Java no quarto nível da primeira missão - Sintaxe Java. Em particular, operadores condicionais como boolean . O curso contém 22 tarefas que o ajudarão a compreender o trabalho dos operadores de comparação, operadores condicionais e operadores lógicos.

Operações numéricas em Java

A operação mais comum que os programadores realizam com números é atribuir um valor numérico a uma variável. Ela, assim como a operadora, =é familiar para você:

int a = 1;
int b = 2;
int c = 3;

Existem também operações aritméticas. Eles são realizados usando operadores aritméticos binários: Tabela 1. Operadores aritméticos binários Os primeiros quatro operadores não devem levantar dúvidas: tudo é igual à matemática. O último operador, o resto da divisão, também não faz nada muito complicado. Por exemplo, se dividirmos 24 por 7, obtemos 3 números inteiros e 3 restantes. É o restante que este operador retornará:

System.out.println(24 % 7); // prints 3

Aqui estão alguns exemplos do site oficial de documentação da Oracle: Este programa produzirá o seguinte: 1 + 2 = 3 3 - 1 = 2 2 * 2 = 4 4/2 = 2 2 + 8 = 10 10 % 7 = 3 Java permite que você combinar: por exemplo, atribuições de operadores e operadores aritméticos. Vejamos um exemplo:

int x = 0;
x = x + 1; // x = 0 + 1 => x = 1
x = x + 1; // x = 1 + 1 => x = 2
x = x + 1; // x = 2 + 1 => x = 3

Aqui definimos uma variável xe atribuímos a ela o valor zero. A seguir, em cada linha atribuímos um valor xà soma do valor atual da variável xe um. Há explicações nos comentários para cada linha. Este procedimento é chamado de aumento ou incremento de uma variável. A operação de incremento do exemplo acima pode ser substituída por uma semelhante usando uma combinação de operadores:

int x = 0;
x += 1; // x = 0 + 1 => x = 1
x += 1; // x = 1 + 1 => x = 2
x += 1; // x = 2 + 1 => x = 3

Você pode combinar o operador de atribuição com qualquer operador aritmético:

int x = 0;
x += 10; // x = 0 + 10 => x = 10
x -= 5; // x = 10 - 5 => x = 5
x *= 5; // x = 5 * 5 => x = 25
x /= 5; // x = 25 / 5 => x = 5
x %= 3; // x = 5 % 3 => x = 2;

Vamos demonstrar como funciona o último exemplo: Além dos operadores binários, Java possui operadores aritméticos unários. Tabela 2. Operadores aritméticos unários: Exemplo de mais e menos unário:

int x = 0;
x = (+5) + (+15); // Parentheses for clarity, it is possible without them
System.out.println("x = " + x);

int y = -x;
System.out.println("y = " + y);

As operações de incremento e decremento são essencialmente simples. No primeiro caso a variável é aumentada em 1, no segundo a variável é diminuída em 1. O exemplo está abaixo:

int x = 9;
x++;
System.out.println(x); // 10

int y = 21;
y--;
System.out.println(y); // 20

Existem dois tipos dessas operações - postfix e prefixo. No primeiro caso, o operador é escrito depois da variável, no segundo caso, antes da variável. A única diferença é quando a operação de incremento ou decremento é executada. Exemplo e descrição na tabela abaixo. Digamos que temos uma variável:

int a = 2;

Então: Tabela 3. Operadores de incremento-decremento: Demonstração: Além da aritmética, existem operações de comparação (de dois números). O resultado sempre será verdadeiro ou falso ( true / false ). Tabela 4. Operadores de comparação Exemplos:

int a = 1;
int b = 2;

boolean comparisonResult = a == b;
System.out.println("a == b :" + comparisonResult);

comparisonResult = a != b;
System.out.println("a != b :" + comparisonResult);

comparisonResult = a > b;
System.out.println("a >  b :" + comparisonResult);

comparisonResult = a >= b;
System.out.println("a >= b :" + comparisonResult);

comparisonResult = a < b;
System.out.println("a <  b :" + comparisonResult);

comparisonResult = a <= b;
System.out.println("a <= b :" + comparisonResult);

Demonstração:

Operações Lógicas em Java

Vejamos as operações lógicas e tabelas verdade de cada uma delas:

• operação de negação ( NOT);
• operação de conjunção, AND lógico ( AND);
• operação de disjunção, OR lógico ( OR);
• operação de adição de módulo, OR exclusivo ( XOR).

O operador de negação é unário e se aplica a um único operando. Todas as outras operações são binárias. Vamos considerar as tabelas verdade dessas operações. Aqui 0 é equivalente a false em Java e 1 é equivalente a true . Tabela 5. Tabela Verdade do Operador de Negação (NOT) Tabela 6. Tabela verdade do operador de conjunção (AND) Tabela 7. Tabela verdade do operador disjunção (OR) Tabela 8. Tabela verdade do operador de adição de módulo (XOR) Java tem as mesmas operações lógicas:

• !— operador de negação;
• &&— operador lógico AND (curto);
• ||— operador lógico OR (curto);
• &— operador AND bit a bit;
• |— operador OR bit a bit;
• ^- operador OR exclusivo bit a bit.

Vejamos a diferença entre operadores bit a bit e abreviados um pouco mais abaixo, enquanto convertemos todas as tabelas verdade em código Java:

public class LogicDemo {

   public static void main(String[] args) {
    notExample();
    andExample();
    orExample();
    xorExample();
   }

   public static void notExample() {
    System.out.println("NOT EXAMPLE:");
    System.out.println("NOT false = " + !false);
       System.out.println("NOT true  = " + !true);
    System.out.println();
   }

   public static void andExample() {
    System.out.println("AND EXAMPLE:");
    System.out.println("false AND false = " + (false & false));
    System.out.println("false AND true  = " + (false & true));
    System.out.println("true  AND false = " + (true & false));
    System.out.println("true  AND true  = " + (true & true));
    System.out.println();
   }

   public static void orExample() {
    System.out.println("OR EXAMPLE:");
    System.out.println("false OR false = " + (false | false));
    System.out.println("false OR true  = " + (false | true));
    System.out.println("true  OR false = " + (true | false));
     System.out.println("true  OR true  = " + (true | true));
    System.out.println();
   }

   public static void xorExample() {
    System.out.println("XOR EXAMPLE:");
    System.out.println("false XOR false = " + (false ^ false));
    System.out.println("false XOR true  = " + (false ^ true));
    System.out.println("true  XOR false = " + (true ^ false));
    System.out.println("true  XOR true  = " + (true ^ true));
    System.out.println();
   }
}

Este programa exibirá: NÃO EXEMPLO: NÃO falso = verdadeiro NÃO verdadeiro = falso E EXEMPLO: falso E falso = falso falso E verdadeiro = falso verdadeiro E falso = falso verdadeiro E verdadeiro = verdadeiro OU EXEMPLO: falso OU falso = falso falso OU verdadeiro = verdadeiro verdadeiro OU falso = verdadeiro verdadeiro OU verdadeiro = verdadeiro XOR EXEMPLO: falso XOR falso = falso falso XOR verdadeiro = verdadeiro verdadeiro XOR falso = verdadeiro verdadeiro XOR verdadeiro = falso Os operadores lógicos aplicam-se apenas a booleanvariáveis. No nosso caso, nós os aplicamos diretamente aos valores, mas você também pode usá-los com booleanvariáveis: E para booleanas expressões: Agora, temos operadores abreviados ( &&, ||) e operadores bit a bit semelhantes ( &, |). Qual a diferença entre eles? Primeiro, bit a bit pode ser aplicado a números inteiros. Falaremos sobre isso um pouco mais tarde. E em segundo lugar, alguns são abreviados, enquanto outros não. Para entender como é a abreviatura, vejamos a expressão:

false AND x = ?
true OR x = ?

Isso xpode assumir qualquer valor booleano. E em geral, de acordo com as leis da lógica e das tabelas verdade, independentemente de ser x verdadeiro ou falso , o resultado da primeira expressão será falso e o resultado da segunda será verdadeiro . Olhar. Às vezes, o resultado de uma expressão pode ser calculado a partir do primeiro operando. Isto é o que distingue os operadores abreviados &&e ||. Em expressões semelhantes às descritas acima, não avaliam o valor do segundo operando. Aqui está um pequeno exemplo: No caso de operadores abreviados, a segunda parte da expressão não é avaliada. Mas isso só acontece quando o resultado da expressão já é óbvio desde o primeiro operando.

Operações bit a bit em Java

Bem, aqui chegamos à parte mais interessante: operações bit a bit. Como o nome sugere, são operações executadas em bits. Mas antes de mergulharmos neste tema, vale a pena falar sobre áreas relacionadas.

Representação de números no sistema numérico binário

Os números, como qualquer outra informação em um programa, são armazenados na memória do computador em código binário. O código binário é um conjunto de zeros e uns. Cada zero ou um representa uma unidade de informação chamada bit.

De acordo com a Wikipédia:

Um bit (do inglês dígito binário - número binário; também um jogo de palavras: inglês bit - pedaço, partícula) é uma unidade de medida da quantidade de informação. 1 bit de informação é um símbolo ou sinal que pode assumir dois significados: ligado ou desligado, sim ou não, alto ou baixo, carregado ou descarregado; no sistema binário é 1 (um) ou 0 (zero).

Com que tipo de dados os operadores bit a bit trabalham?

As operações bit a bit em Java são executadas apenas em números inteiros. Os inteiros são armazenados na memória do computador como um conjunto de bits. Podemos dizer que um computador converte qualquer informação em um sistema numérico binário (um conjunto de bits) e só então interage com ele. Mas como funciona o sistema numérico binário? No sistema numérico decimal temos apenas 10 símbolos: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Usamos esses símbolos para contar. Depois de 9 vem 10, depois de 19 - 20, depois de 99 - 100, depois de 749 - 750. Ou seja, usamos uma combinação dos 10 símbolos disponíveis e podemos usá-los para contar “de zero até o almoço”. No sistema numérico binário, em vez de dez símbolos, existem apenas dois - 0, 1. Mas combinando esses símbolos de acordo com o mesmo princípio do sistema decimal, podemos contar indefinidamente. Vamos demonstrar a contagem de 0 a 15 em decimal e binário: Como você pode ver, nem tudo é tão complicado. Além dos bits, existem outras unidades familiares de informação - bytes , quilobytes , megabytes , gigabytes , etc. Você provavelmente sabe que existem 8 bits em 1 byte . O que isso significa? Isso significa que 8 bits consecutivos ocupam 1 byte. Aqui estão alguns exemplos do que bytes podem ser:

00000000 - 1 byte
10110010 - 1 byte
01011011 - 1 byte

O número de possíveis combinações não repetidas de bits em um byte é 256 (2 ⁸ = 256). Mas vamos voltar mais perto de Java. Existe um tipo de dados inteiro - byte. Este tipo pode assumir valores de -128 a 127 e um número na memória do computador ocupa exatamente 8 bits, ou 1 byte. Um número desse tipo ocupa exatamente 1 bytememória do computador. E aqui os nomes não coincidem por acaso. Como lembramos, 1 byte pode armazenar 256 valores diferentes. E um número de tipo bytepode assumir 256 valores diferentes (128 negativos, 127 positivos e 1 zero). Cada valor numérico bytepossui um conjunto exclusivo de oito bits. Este é o caso não apenas de type byte, mas de todos os tipos integrais. O tipo byteé dado como exemplo como o menor. A tabela abaixo mostra todos os tipos inteiros Java e o espaço de memória que eles ocupam: Considere o tipo int. Ele pode armazenar 2147483648 valores negativos, 2147483647 valores positivos e um zero. Total:

2147483648 + 2147483647 + 1 = 4294967296.

Este tipo ocupa 32 bits na memória do computador. O número de combinações possíveis de um conjunto de 32 zeros e uns é:

232 = 4294967296.

O mesmo número que o número de valores que o tipo pode conter int. Esta é apenas uma demonstração da relação entre o intervalo de valores de um tipo de dado e seu tamanho (número de bits na memória). Qualquer número de qualquer tipo em Java pode ser convertido em binário. Vamos ver como isso pode ser feito facilmente usando a linguagem Java. Aprenderemos com o exemplo do tipo int. Este tipo possui sua própria classe wrapper - Integer. E ele tem um toBinaryString, que fará todo o trabalho para nós: Voila - não é tão complicado. Mas ainda assim, algo precisa ser esclarecido. into número leva 32 bits. Mas quando imprimimos o número 10 no exemplo acima, vemos no console 1010. Isso ocorre porque os zeros à esquerda não são impressos. Se eles fossem exibidos, em vez de 1010 veríamos no console 000000000000000000000000001010. Mas para facilitar a percepção, todos os zeros à esquerda são omitidos. Não é tão difícil até você se perguntar: e os números negativos? Ele percebe informações apenas no sistema binário. Acontece que o sinal de menos também precisa ser escrito em código binário. Isso pode ser feito usando código direto ou complementar.

Código direto

Um método de representação de números no sistema numérico binário, no qual o bit mais significativo (o bit mais à esquerda) é alocado ao sinal do número. Se o número for positivo, o bit mais à esquerda será escrito 0, se for negativo - 1. Vejamos isso usando um número de 8 bits como exemplo: A abordagem é simples e, em princípio, compreensível. Porém, apresenta desvantagens: dificuldades na realização de operações matemáticas. Por exemplo, com a adição de números negativos e positivos. Eles não podem ser dobrados a menos que sejam realizadas manipulações adicionais.

Código adicional

Usando código adicional, você pode evitar as desvantagens do código direto. Existe um algoritmo simples para obter o código adicional de um número. Vamos tentar obter o código adicional para o número -5. Vamos representar esse número usando o código de complemento de dois no sistema numérico binário. Passo 1. Obtemos a representação de um número negativo usando código direto. Para -5 será 10000101. Passo 2. Inverta todos os dígitos, exceto o dígito do sinal. Vamos substituir todos os zeros por uns e uns por zeros em todos os lugares, exceto no bit mais à esquerda.

10000101 => 11111010

Passo 3. Adicione um ao valor resultante:

11111010 + 1 = 11111011

Preparar. Obtivemos o valor de -5 no sistema numérico binário usando código de complemento de dois. Isso é importante para a compreensão do material a seguir, pois Java usa código de complemento de dois para armazenar números negativos em bits.

Tipos de operações bit a bit

Agora que tratamos de todas as introduções, vamos falar sobre operações bit a bit em Java. Uma operação bit a bit é executada em números inteiros e seu resultado é um número inteiro. No processo, o número é convertido em binário, uma operação é executada em cada bit e o resultado é convertido novamente em decimal. A lista de operações está na tabela abaixo: Como já descobrimos, os números podem ser representados como um conjunto de bits. As operações bit a bit executam operações exatamente em cada bit dessa representação. Vamos levar NOT, AND, OR, XOR. Lembre-se de que recentemente examinamos tabelas verdade apenas para operandos lógicos. Neste caso, as mesmas operações são aplicadas a cada bit do inteiro.

Operador unário bit a bit NOT ~

Este operador substitui todos os zeros por uns e todos os uns por zeros. Digamos que temos o número 10 em notação decimal. Em binário, esse número é 1010. Se aplicarmos o operador unário de negação bit a bit a esse número, obteremos algo assim: Vamos dar uma olhada em sua aparência no código Java:

public static void main(String[] args) {
   int a = 10;

   System.out.println(" a = " + a + "; binary string: " + Integer.toBinaryString(a));
   System.out.println("~a = " + ~a + "; binary string: " + Integer.toBinaryString(~a));
}

Agora vamos ver o que é exibido no console: Na primeira linha obtivemos o valor no sistema numérico binário sem zeros à esquerda. Mesmo que não os vejamos, eles estão lá. Isso é evidenciado pela segunda linha, em que todos os bits foram transformados em reversos. É por isso que vemos tantas unidades líderes. Esses são os antigos zeros à esquerda que foram ignorados pelo compilador quando impressos na primeira linha. Aqui está um pequeno programa que também exibe zeros à esquerda para maior clareza.

Operador AND bit a bit

Este operador se aplica a dois números. Ele executa uma operação ANDentre os bits de cada número. Vejamos um exemplo: Esta operação é realizada em dois números. Exemplo em código Java:

Operador OR bit a bit

OR se aplica a dois números. Ele executa uma operação OR entre os bits de cada número: Agora vamos dar uma olhada em como ficaria no IDEA:

Operação bit a bit, OR exclusivo (XOR)

Vejamos o mesmo exemplo, mas com uma nova operação: Código de exemplo:

Deslocamento bit a bit para a esquerda

Este operador é aplicável a dois operandos, ou seja, na operação x << y, os bits do número xdeslocarão yposições para a esquerda. O que isso significa? Vejamos o exemplo da operação, 10 << 1 o resultado da operação será o número 20 no sistema decimal. Como você pode ver no diagrama acima, todos os bits são deslocados 1 para a esquerda. Durante esta operação, o valor do bit mais significativo (o bit mais à esquerda) é perdido. E o bit menos significativo (o bit mais à direita) é preenchido com zero. O que você pode dizer sobre esta operação?

1. Ao deslocar os bits de um número Xpor Nbits para a esquerda, multiplicamos o número Xpor 2 ^N .

   Aqui está um exemplo:

2. Mas! O sinal do número pode mudar se o bit com valor 1 ocupar a posição mais à esquerda.

3. Se você deslocar para a esquerda indefinidamente, o número simplesmente se transformará em 0. Vamos demonstrar os pontos 2 e 3:

Deslocamento bit a bit para a direita

Este operador se aplica a dois operandos. Aqueles. na operação x >> y, os bits do número xmudarão yde posição para a direita. Vejamos outro exemplo. Vamos analisar esquematicamente a operação 10 >> 1. Vamos deslocar todos os bits do número 10 uma posição para a direita: Durante a operação de deslocamento, perdemos os bits certos. Eles simplesmente desaparecem. O bit mais à esquerda é o sinal do número (0 é positivo, 1 é negativo). Portanto, no valor final ele é colocado igual ao número original. Exemplo com número negativo: O bit mais à direita é perdido e o bit mais à esquerda é copiado do número original, como sinal honorário do número. Como fazer tudo isso no IDEA? Em princípio nada complicado, basta pegar e mexer: Agora. O que você pode dizer sobre os números deslocados para a direita? Eles são divisíveis por 2. Cada vez que deslocamos um bit para a direita, dividimos o número original por 2. Se o número não for divisível por 2, o resultado será arredondado para menos infinito (para baixo). Mas isso só funciona se deslocarmos os bits exatamente por 1. E se for por 2 bits, divida por 4. Por 3 bits, divida por 8. Por 4 bits, divida por 16. Viu? Potências de 2... Quando deslocamos um número Xpara Na direita em bits, dividimos o número Xpor 2 elevado a 2 N. Demonstração:

public class BitOperationsDemo {

   public static void main(String[] args) {

    for (int i = 1; i <= 10; i++) {

        int shiftOperationResult = 2048 >> i;
        int devideOperationResult = 2048 / (int) Math.pow(2, i);


           System.out.println(shiftOperationResult + " - " + devideOperationResult);
    }

   }

}

O que está acontecendo aqui?

1. Um loop no qual a variável i é incrementada de 1 a 10.

2. Cada iteração calculamos 2 valores:

• Escrevemos na variável shiftOperationResulto resultado do deslocamento do número 2048 em i bits para a direita;

• devideOperationResultEscrevemos o resultado da divisão do número 2048 por 2 elevado à potência i em uma variável .

3. Exibimos os dois valores obtidos em pares.

O resultado da execução do programa é o seguinte: 1024 - 1024 512 - 512 256 - 256 128 - 128 64 - 64 32 - 32 16 - 16 8 - 8 4 - 4 2 - 2

Deslocamento bit a bit para a direita com preenchimento zero

Embora um deslocamento normal para a direita preserve o sinal do número (o bit mais significativo mantém seu valor), um deslocamento para a direita com preenchimento de zero não o faz. E o bit mais significativo é preenchido com zero. Vamos ver como é:

Precedência de operações em Java

Assim como a matemática, Java tem precedência de operações. A tabela abaixo mostra a prioridade (da mais alta para a mais baixa) das operações que consideramos.

Exemplos úteis de uso

Determinando a paridade de um número

Encontrando o elemento máximo em um array

Para encontrar o elemento mínimo, basta alterar o sinal de comparação no lugar certo.