¿Que es bitwise?
Son operaciones que podemos aplicar a cada uno de los bits. Donde cada bit puede ser ‘1’ o ‘0’ en la memoria de un ordenador, estos bits no siempre representan números, sino que también letras, imágenes, fechas, vídeos etc.
Operadores bit a bit o bitwise
Los operadores bitwise cuando trabajan (o son ejecutados) internamente en la computadora no lo hacen con los números decimales que nosotros insertamos sino con su equivalente en binario.
Estos operadores son aplicados a cada número binario, luego el resultado es convertido nuevamente a decimal.
Operadores lógicos a nivel de bits
Operador AND ( & ): Nos devuelve ‘1’ si y solo si en la misma posición, los bits de ambos operandos es ‘1’.
Ejemplo de AND en java
import java.util.Scanner;
import java.util.*;
/*
* Como un byte tiene 8bits el máximo valor que podemos
* introducir en A y B es 127 porque según mis observaciones 1bits es
* reservado para el signo.
* Para convertir decimales negativos a binario
* Tomamos el valor decimal en positivo y lo negamos
* (o hacemos complemento a 1)
* al resultado le sumamos 1 y con eso obtenemos el número negativo en
* binario de un decimal.
*
* Ejemplo
* 13 = 00001101
* ~13= 11110010
* + 00000001 --> sumamos uno a la resultado de negar 13
* 11110011 --> -13 en binario
* binario decimal
* A = 0 1 1 0 0 1 1 1 -> 103
* B = 0 0 0 0 1 0 1 0 -> 10
* A&B=0 0 0 0 0 0 1 0 -> 2
* A = 1 1 0 1 0 1 1 0 -> -42 en binario no confundir con 214
* B = 1 1 0 1 1 1 0 1 -> 35
* A&B=1 1 0 1 0 1 0 0 -> -44
* A = 1 0 0 0 0 0 0 1 -> -127 en binario no confundir con 129
* B = 0 0 0 0 1 0 0 1 -> 9
* A&B=0 0 0 0 0 0 0 1 -> 1
*/
public class OperadorAND{
/*
*Función que retorna el resultado (en string) del operador "And" en 2
* operandos o variables
*/
static String Operador_And(byte A, byte B){
System.out.print(A + "\n");
System.out.print(B + "\n");
return String.valueOf(A & B);
}
public static void main(String[] args){
/*Insertamos el valor "A" por la terminal*/
Scanner teclado = new Scanner(System.in);
System.out.print( "Introduzca cantidad una numérica: " );
byte A = (byte) teclado.nextInt();
/*Insertamos el valor "B" por la terminal*/
System.out.print( "Introduzca cantidad de numérica: " );
byte B = (byte) teclado.nextInt();
/*Inserta los valores a los parámetros y muestra el resultado*/
System.out.print(Operador_And(A,B)+ "\n");
}
}
Operador OR ( | ): Retorna ‘1’ si y solo si en las mismas posiciones de ambos números binarios hay al menos un ‘1’.
Ejemplo de OR en java
import java.util.Scanner;
import java.util.*;
/*
*Como un byte tiene 8bits el máximo valor que podemos
*introducir en A y B es 127 porque según mis observaciones 1bits es
*reservado para el signo.
*
* binario decimal
*A = 0 1 1 0 0 1 0 0 -> 100
*B = 0 0 1 1 0 1 0 1 -> 53
*A|B=0 1 1 1 0 1 0 1 -> 117
*A = 1 1 0 1 0 1 1 0 -> -42 en binario no confundir con 214
*B = 0 0 1 0 0 1 0 1 -> 37
*A|B=1 1 1 1 0 1 1 1 -> -9 en binario no confundir con 247
*A = 0 0 0 1 0 0 0 1 -> 17
*B = 0 0 1 0 0 1 0 0 -> 36
*A|B=0 0 1 1 0 1 0 1 -> 53
*/
public class OperadorOR{
/*
*Función que retorna el resultado (en string) del operador "Or" en 2
* operandos o variables
*/
static String Operador_Or(byte A, byte B){
System.out.print(A + "\n");
System.out.print(B + "\n");
return String.valueOf(A|B);
}
public static void main(String[] args){
/*Insertamos el valor "A" por la terminal*/
Scanner teclado = new Scanner(System.in);
System.out.print( "Introduzca cantidad una numérica: " );
byte A = (byte) teclado.nextInt();
/*Insertamos el valor "B" por la terminal*/
System.out.print( "Introduzca cantidad de numérica: " );
byte B = (byte) teclado.nextInt();
/*Inserta los valores a los parámetros y muestra el resultado*/
System.out.print(Operador_Or(A,B)+ "\n");
}
}
Operador XOR ( ^ ): Devuelve ‘1’ si y solo si, cuando en los bits de ambos operandos que se encuentran en la misma posición tienen valores distintos.
Ejemplo de XOR en java
import java.util.Scanner;
import java.util.*;
/*
*Como un byte tiene 8bits el máximo valor que podemos
*introducir en A y B es 127 porque según mis observaciones 1bits es
*reservado para el signo.
*
* binario decimal
*A = 0 0 0 1 1 0 0 0 -> 24
*B = 0 1 0 1 1 0 0 0 -> 88
*A^B=0 1 0 0 0 0 0 0 -> 64
*
*A = 1 1 1 1 1 1 1 1 -> -1 en binario, no confundir con 255
*B = 1 1 1 1 1 1 0 0 -> -4 en binario, no confundir con 252
*A^B=0 0 0 0 0 0 1 1 -> 3
*
*A = 1 1 1 1 1 1 0 1 -> -3 en binario, no confundir con 253
*B = 0 1 1 1 1 1 1 1 -> 127
*A^B=1 0 0 0 0 0 1 0 -> -126 en binario, no confundir con 130
*/
public class OperadorXOR{
/*
*Función que retorna el resultado (en string) del operador "Xor" en 2
* operandos o variables
*/
static String Operador_Xor(byte A, byte B){
System.out.print(A + "\n");
System.out.print(B + "\n");
return String.valueOf(A ^ B);
}
public static void main(String[] args){
/*Insertamos el valor "A" por la terminal*/
Scanner teclado = new Scanner(System.in);
System.out.print( "Introduzca cantidad una numérica: " );
byte A = (byte) teclado.nextInt();
/*Insertamos el valor "B" por la terminal*/
System.out.print( "Introduzca cantidad de numérica: " );
byte B = (byte) teclado.nextInt();
/*Inserta los valores a los parametros y muestra el resultado*/
System.out.print(Operador_Xor(A,B)+ "\n");
}
}
Operador NOT ( ~ ): Invierte todos los valores de los bits (o de los números vinarios).
Ejemplo de NOT en java
import java.util.Scanner;
import java.util.*;
/*
*Como un byte tiene 8bits el máximo valor que podemos
*introducir en A y B es 127 porque según mis observaciones 1bits es
*reservado para el signo.
*
* binario decimal
*A = 0 0 0 0 1 0 0 1 -> 9
*~A= 1 1 1 1 0 1 1 0 -> -10 en binario, no confundir con 252
*
*A = 0 1 1 1 1 0 1 0 -> 122
*~A= 1 1 1 1 1 1 0 0 -> -123 en binario, no confundir con 124
*
*A = 1 1 1 1 1 1 1 1 -> -1 en binario, no confundir con 255
*~A= 0 0 0 0 0 0 0 0 -> 0
*/
public class OperadorNOT{
/*
*Función que retorna el resultado (en string) del operador "Not" en 1
* operandor o variable.
*/
static String Operador_Not(byte A){
System.out.print(" ~" + A + "\n");
return String.valueOf("Resultado:" + ~A);
}
public static void main(String[] args){
/*Insertamos el valor "A" por la terminal*/
Scanner teclado = new Scanner(System.in);
System.out.print( "Introduzca cantidad una numérica: " );
byte A = (byte) teclado.nextInt();
/*Inserta los valores a los parámetros y muestra el resultado*/
System.out.print(Operador_Not(A)+ "\n");
}
}
Operadores de desplazamiento a nivel de bits
Estos operadores tratan al valor guardado en un espacio de memoria no como una cantidad sino como una serie o grupo de números que pueden desplazarse (moverse) tanto a la izquierda como a la derecha.
Operador SHL o left shift (<<): Desplaza todos los valores de los bits a la izquierda la cantidad de veces que se le indica, luego automáticamente el espacio vació a la derecha es llenado con ‘0’.
Los bits que salgan del espacio de memoria reservado al ser desplazados a la izquierda se pierden.
Ejemplo de SHL en java
import java.util.Scanner;
import java.util.*;
/*
*
* binario decimal
*A = 1 1 1 1 1 1 0 0 -> -4 en binario, no confundir con 252
*A<<3= 1 1 1 0 0 0 0 0 -> -32 en binario, no confundir con 224
*
*A = 0 0 0 0 0 0 0 1 -> 2
*A<<2= 0 0 0 0 0 1 0 0 -> 4
*
*A = 0 0 0 1 0 1 0 1 -> 21
*A<<1= 0 0 1 0 1 0 1 0 -> 42
*
*En este ultimo podemos ver que al parecer el '1' desplazador
*no llega a perderse por eso retorna el 272.
*A = 0 0 0 1 0 0 0 1 -> 17
*A<<4=1 0 0 0 1 0 0 0 0 -> 272
*/
public class OperadorSHL{
/*
*Función que retorna el resultado (en string) del operador "Shl" en 1
* operador o variable.
*/
static String Operador_Shl(byte A, byte n){
System.out.print(A + "<<" + n + "\n");
/*Valor << n --> esta operación debe ir entre paracentesis, para
*no interferir con la conversión*/
return String.valueOf("Resultado:" + (A << n));
}
public static void main(String[] args){
/*Insertamos el valor "Valor" por la terminal*/
Scanner teclado = new Scanner(System.in);
System.out.print( "Introduzca un valor: " );
byte Valor = (byte) teclado.nextInt();
/*Insertamos el valor "n" por la terminal*/
System.out.print( "Introduzca el desplazador: " );
byte n = (byte) teclado.nextInt();
/*Inserta los valores a los parámetros y muestra el resultado*/
System.out.print(Operador_Shl(Valor ,n)+ "\n");
}
}
Operador SHR o Right shift (>>): Desplaza todos los valores de los bits a la derecha según la cantidad que se indique.
Si el número es positivo, el ultimo numero a a la izquierda es ‘0’, entonces los espacios vacíos luego del desplazamiento son llenados con ‘0’.
Si el número es negativo necesariamente el ultimo digito de la izquierda es 1, entonces luego de desplazar ‘n’ veces a la derecha los siguientes dígitos son rellenados con ‘1’.
Ejemplo de SHR en java
import java.util.Scanner;
import java.util.*;
/*
*Como un byte tiene 8bits el máximo valor que podemos
*introducir en A y B es 127 porque según mis observaciones 1bits es
*reservado para el signo.
*
* binario decimal
*A = 0 0 0 0 1 1 1 1 -> 15
*A>>1= 0 0 0 0 0 1 1 1 -> 7 podemos ver que al parecer el '1' desplazado si llega a perderse por eso retorna el 7
*
*A = 0 1 0 0 0 1 0 0 -> 68
*A>>2= 0 0 0 1 0 0 0 1-> 17
*
*A = 1 1 0 0 0 0 0 0 -> -64 en binario, no confundir con 192
*A>>3= 1 1 1 1 1 0 0 0 -> -8 en binario, no confundir con 248
*/
public class OperadorSHR{
/*
*Función que retorna el resultado (en string) del operador "Shr" en
*los operadores o variables.
*/
static String Operador_Shr(byte A, byte n){
System.out.print(A + ">>" + n + "\n");
/*A << n --> esta operación deve ir entre paréntesis, para
*no interferir con la conversión*/
return String.valueOf("Resultado:" + (A >> n));
}
public static void main(String[] args){
/*Insertamos un valor en "A" por la terminal*/
Scanner teclado = new Scanner(System.in);
System.out.print( "Introduzca un valor: " );
byte A = (byte) teclado.nextInt();
/*Insertamos el valor desplazador "n" por la terminal*/
System.out.print( "Introduzca el desplazador: " );
byte n = (byte) teclado.nextInt();
/*Inserta los valores a los parámetros y muestra el resultado*/
System.out.print(Operador_Shr(A ,n)+ "\n");
}
}
Operador SHSR o Unsigned Right Shift (>>>): Este operador también desplaza los bits a la derecha con la diferencia de que los espacios vacíos a la izquierda son llenados unicamente con ‘0’, por ello el resultados siempre es positivo.
Ejemplo de SHSR en java
import java.util.Scanner;
import java.util.*;
/*
*Como un byte tiene 8bits el máximo valor que podemos
*introducir en A y B es 127 porque según mis observaciones 1bits es
*reservado para el signo.
*
* binario decimal
*A = 0 0 0 0 0 1 0 0 -> 4
*A>>>1= 0 0 0 0 0 0 1 0 -> 2
*
*A = 0 1 1 1 1 1 1 1 -> 127
*A>>>1= 0 0 0 1 1 1 1 1-> 63
*
*A = 0 1 0 1 1 0 1 0 -> 90
*A>>>4= 0 0 0 0 0 1 0 1 -> 5
*/
public class OperadorSHSR{
/*
*Función que retorna el resultado (en string) del operador "Shr" en
*los operandores o variables.
*/
static String Operador_Shsr(byte A, byte n){
System.out.print(A + ">>>" + n + "\n");
/*A << n --> esta operacion deve ir entre parentecis, para
*no interferir con la conversion*/
return String.valueOf("Resultado:" + (A >>> n));
}
public static void main(String[] args){
/*Insertamos un valor en "A" por la terminal*/
Scanner teclado = new Scanner(System.in);
System.out.print( "Introduzca un valor: " );
byte A = (byte) teclado.nextInt();
/*Insertamos el valor desplazador "n" por la terminal*/
System.out.print( "Introduzca el desplazador: " );
byte n = (byte) teclado.nextInt();
/*Inserta los valores a los parámetros y muestra el resultado*/
System.out.print(Operador_Shsr(A ,n)+ "\n");
}
}
Si encuentras algún error o algún otro detalle que se me hubiera escapado🤯, por favor déjalo en los comentarios, para que pueda corregirlo.
Hermoso tu blog , no dejes de postear me gusta y sigue compartiendo mas sobre java