Dúvida... Operadores de Trocas... Shift

Programação Java
#1

Salve, Salve Galera…

Eu entendi perfeitamente os operadores >> e <<

50 >> 2 = 12

50 em binário: 110010
remover os 2 últimos dígitos do binario
Resultado 1100.
Convertendo o resultado em decimal
temos 12.

50 << 2 = 200

50 em binário: 110010
adicionar 2 dígitos(0)
Resultado. 11001000
Convertendo o resultado em decimal
temos 200.

Beleza… agora eu não ententi o operador de troca >>> alguém pode explicar?

No dia da prova para a certificação pode utilizar a calculadora do windows? :oops:

Valeu!!!

Atn.
Dennys Fredericci

#2

huaehaue, esquece a calculadora, tu só tem direito a uma ceneta e umas folhas pra rascunho heahaehea, bem, me deram um cópo d’água tb no meu dia heahae. o >>> é simples cara, por ex, se tu tem esse numero:

0010

e usar o operador >>, assim:

0010 >> 1 = 0001

ok? agora, se tu tem esse numero:

1010 >> 1 = 1101

sacou? o numero q vai ser preenxido a esquerda, é o mesmo q ja ta na primeira posição, ou seja, se é 0, ele preenxe com zeros, se é 1, ele preenxe com uns… agora:

1010 >>> 1 = 0101

mesmo com 1 na frente, ele preenxeu com zero, moral da historia, todo numero q for usado em uma operação com >>> terá um resultado positivo!

#3

Cara… acho que isso está errado… :oops:

1010 em decimal é 10

10 >> 1

Ele cortaria o último 0, certo?

ficaria 101 que em decimal é 5!

Pode executar esta linha no em um app

que garanto que é isso!

e o operador << ele não adiciona zeros a direita?

se eu tiver o número 1010

1010 << 1

ficaria 10100 que em decimal é 20

Bom… eu tenho 80% de certeza que é isso até testei em uma
classe aqui… eu só não sei o que o operador >>> faz, entendi que ele
sempre vai retornar números positivos, mas o que acontece por no mundo obscuro dos códigos?

Atn.
Dennys Fredericci

#4

eu não levei em consideração o resultado decimal… só tentei te mostrar a operação q seria realizada nos bits, ou seja, sempre q usar >>>, ele vai deslocar para a esquerda assim como >>, mas sempre vai preenxer de 0s, ao contrário de >>

#5

O operador >>> faz um shift ignorando o sinal do número. O último bit (o mais significativo) do número é o sinal.

Por exemplo:

public class Test &#123;
    public static void main&#40;String&#91;&#93; argumentos&#41; &#123;
        int a = -1; // Em binário&#58; 11111111111111111111111111111111
        a &gt;&gt;&gt;= 1; // Resultado&#58; 01111111111111111111111111111111
        System.out.println&#40;a&#41;;        
        int b = -1; // Em binário&#58; 11111111111111111111111111111111
        b &gt;&gt;=1; // Resultado&#58; 11111111111111111111111111111111
        System.out.println&#40;b&#41;;
    &#125;
&#125;

A razão de 1010 >> 1 resultar em 0101 e não em 1101 é que o número (int pelo menos) na verdade têm 32 bits, e não 4. Sendo assim o último bit é 0 e não 1:

00000000000000000000000000001010 >> 1 resulta em:
00000000000000000000000000000101

Outra coisa:

Isso não é verdade. Em alguns casos >>> pode retornar um número negativo. Isso vai ocorrer quando o número no qual é feito o shift é negativo e o número de casas a deslocar é 0 ou múltiplo da quantidade de bits do número sendo deslocado. Veja por exemplo:

public class Test &#123;
    public static void main&#40;String&#91;&#93; argumentos&#41; &#123;
        int a = -1; // Em binário&#58; 11111111111111111111111111111111
        a &gt;&gt;&gt;= 32; // Resultado&#58; 11111111111111111111111111111111
        System.out.println&#40;a&#41;; // Imprime -1
    &#125;
&#125;
#6

hum…

mesmo assim o que vc colocou

está errado… o certo seria


1010 &gt;&gt; 1 = 101

Entendeu o que eu tentei explicar?

Atn.
Dennys Fredericci

#7

Hummmm boa tyler! agora eu entendi o operador >>>!!! não é difícil!

O problema é a canseira que dá ficar convertendo decimal para binário, binário para decimla… isso que féde…

mas beleza!

Entendi! isso que é importante! :slight_smile:

Não pode mesmo usar a calculadora do Windows? rs*** :???:

Atn.
Dennys Fredericci

#8

heahea, não, não pode…! é só papel e caneta :grin:

#9

olá a todos…
Lendo está discussão surgiu uma dúvida…

192 = 00000000 00000000 00000000 11000000;
-192= 11111111 11111111 11111111 01000000;

A dúvida é a seguinte, para calcular o 192 positivo é facil…eu elevo 2 a 6º e 2 a 8º…que vira 128+64 = 192…né isso??? pois considero a ultima sequencia…de bits…(11000000).

Já o negativo a última sequencia é (01000000) e se eu for calcular da mesma forma resulta em apenas 64…
Onde estão os outros 128…Como faço para achá-los???

:martelada: Já quebrei a cabeça e não achei…hehehehe…consegui ser claro…???

Obrigado…

#10

[quote=“Dennys”]O problema é a canseira que dá ficar convertendo decimal para binário, binário para decimla… isso que féde…
[/quote]
Não precisa ficar convertendo, vc pode usar a formula:
N / 2 z para >> ou
N * 2 z para <<
onde z(potencia) é o numero de bits q vc quer mover, tipo:

[code]10 >> 1
10 / 2(a potencia de 1)
10 / 2
5

10 << 2
10 * 2(a potencia de 2)
10 * 4
40
[/code]
Não sei colocar o <sup></sup> aqui :oops: algum moderador poderia editar? :lol:

#11

JhOnNy,

não sei se entendi sua pergunta, mas acho q vc quer saber como obter o binário de um número negativo… correto?

Espero q seja isto… hehehe… aí vai!!!

Para obter o binário de um negativo vc precisa trabalhar com o mesmo número na forma positiva. Segue seu exemplo:

192 ->
00000000000000000000000011000000

Para obter -193 vc precisa inverter os bits ->
11111111111111111111111100111111

Para obter -192 acrescente 1 ->
11111111111111111111111101000000

Segue trecho de código para vc testar e comparar.

      System.out.println(Integer.toBinaryString(192));
      System.out.println(Integer.toBinaryString(-191));
      System.out.println(Integer.toBinaryString(-192));
      System.out.println(Integer.toBinaryString(-193));

Abraço.

#12

Valeu pela dica…era isto mesmo…

Aproveitando…

para mim é facil calcular o +192

00000000000000000000000011000000
128+64 = 192

mas os negativos não…pq o inverso é -193??? e pq o -192 termina com os zeros…isso é meio confuso…

11111111111111111111111101000000

como calcular as potências de 2? eu uso todos os octetos, pq o ultimo octeto só da 64, né?!?!?!?!

Obrigado

:lol:

#13

Esquece as potências…eh mais simples fazer o caminho inverso…

por exemplo… qual eh o binário de -2?

Para obter a resposta pegue o binário de 2, inverta os bits e acrescente 1:

(2) -> 00000010
(-3) -> 11111101
(-2) -> 11111110

Isso acontece pq o domínio de valores para uma variável byte eh este:

(0) -> 00000000
(1) -> 00000001
…
(127) -> 011111111
(-128) -> 100000000
(-127) -> 100000001
(-126) -> 100000010
…
(-1) -> 111111111

ou seja, 0 eh considerado um valor positivo (bit de sinal desligado), por isso que para todos os tipos de variáveis numéricos (short, long, int, byte) o domínio de números negativos tem um número a mais que o de positivos.

Belez?

#14

Agora desceu…

Valeu mesmo!!!

#15

[quote=“Duende_Macabro”][quote=“Dennys”]O problema é a canseira que dá ficar convertendo decimal para binário, binário para decimla… isso que féde…
[/quote]
Não precisa ficar convertendo, vc pode usar a formula:
N / 2 z para >> ou
N * 2 z para <<
onde z(potencia) é o numero de bits q vc quer mover, tipo:

[code]10 >> 1
10 / 2(a potencia de 1)
10 / 2
5

10 << 2
10 * 2(a potencia de 2)
10 * 4
40
[/code]
Não sei colocar o <sup></sup> aqui :oops: algum moderador poderia editar? :lol:[/quote]

E para o Operador >>> existe algum calculo!?!

Atn.
Dennys Fredericci
http://www.dennys.eti.br

#16

Esse cálculo é só pros operadores >> e <<. Claro que se o número for positivo, >> e >>> serão o mesmo.

Agora, queria lembrar duas coisas:

Primeiro: Lembrar que nas fórmulas que o Duende_Macabro falou, A DIVISÃO É INTEIRA (claro, só se aplica os operadores shift em tipos inteiros - e o número é promovido, no mínimo, a int).

Segundo: O operador >>> NÃO resulta em positivos sempre. Caso o segundo operando seja múltiplo de 32 (para int) ou múltiplo de 64 (para long), a operação não modifica o número. Isso acontece porque numa operação do tipo x (shift) n, o cálculo é, na verdade, x (shift) (n % nº de bits do tipo).

int x = -10; x &gt;&gt;&gt;= 32; // x não é modificado!

Se falei alguma besteira, me corrijam :slight_smile: (não dá pra testar aqui)

#17

[quote=“Dennys”]hum…

mesmo assim o que vc colocou

está errado… o certo seria


1010 &gt;&gt; 1 = 101

Entendeu o que eu tentei explicar?

Atn.
Dennys Fredericci[/quote]

Dennys, só pra reforçar:

o q o matheus tentou explicar em:

1010 >> 1 = 1101

estaria certo se a palavra fosse só de 4 bits, na verdade qdo se faz um shift pra direita, não são os zeros ou uns a esquerda que são cortados, eles são empurados da esquerda pra direita n casas respeitando o tamanho da palavra, que no caso do int é 32 bits, por isso q qdo fazemos

1010 >> 1 = 101

pq é assim q ocorre

00000000000000000000000000001010 >> 1 = 00000000000000000000000000000101


nesse caso e em qualquer outro caso de números positivos o “>>” e o “>>>” terá o mesmo efeito, visto q o bit mais significativo é o sinal, que nesse caso (positivo) é sempre 0 (zero)

mas se fizermos assim:

11111111111111111111111111111111 >>> 1

qual número dá?

Será o maior número que se pode representar com 32 bits, pois continuará com 32 bits, porém moverá todos os 1s uma casa pra direita preenchendo com zero o bit mais significativo, consequentemente tornando-o positivo e máximo

entendeu?

Quanto ao calculo do numero negativo binario pra decimal, realmente não precisa ser feito, mas é bom saber como ele inverte os numero. Ele utiliza um negocim bem simples chamado ‘complemento 2’’:

vc inverte os bit e soma 1, por exemplo:

-> dado o número

00000000000000000000000000000001 = 1

seu simétrico é

11111111111111111111111111111110 + 1 => 11111111111111111111111111111111 = -1

entendeu?

#18

Jhonny,

Os números negativos são formados usando o complemento de 2. Como não seria interessante haver +0 e -0, eles são acrescidos de 1 daí o range de byte ser de -128 até 127.

Resumindo: quando você quiser avaliar um número negativo, considere os 0´s da representação em binário como sendo 1, e depois some +1 ao resultado

Assim:
0 = 0000 0000 0000 0000 0000 0000 0000 0000
-1 = 1111 1111 1111 1111 1111 1111 1111 1111
-3 = 1111 1111 1111 1111 1111 1111 1111 1101
-192 = 1111 1111 1111 1111 1111 1111 0100 0000

Ficou claro? ou compliquei? :oops:

#19

Jhonny,

Como o número é negativo ele usa os bits invertidos. Considere os 0´s como sendo 1´s e depois some 1 ao resultado. :wink:

#20