Operadores de Java – Parte 2 (Final)

5 minuto(s)

Continuemos con la parte anterior llamada Operadores de Java – Parte 1 en donde explicamos un poco acerca de los operadores de Java, asimismo vimos los 2 primeros grupos de operadores, Operadores aritméticos y Operadores de asignación, en este Parte 2 y última veremos los siguientes tipos de operadores con los cuales podemos trabajar en Java, vamos con ello.

Partes

Parte 1
Parte 2 (Final)

Antes de continuar te invito a leer los siguientes artículos:

Que es Java y otros Detalles
Los 6 mejores IDEs para programar en Java en este 2020
Top de los 5 mejores Frameworks para el Desarrollo de Aplicaciones Web con Java
Como eliminar el primero elemento de un ArrayList en Java
Puedes leer más artículos en la categoría Java

Asimismo te invito a escuchar el Podcast: “5 Consejos para ser un Programador más Productivo” (No son los clásicos consejos técnicos de programación, si no de rutinas y buenos hábitos cotidianos):

Spotify:	Sound Cloud:

Bien ahora continuemos con el Post: Operadores de Java – Parte 2 (Final).

Los operadores también los podemos encontrar en otros Lenguajes de Programación, no es exclusivo de Java y suelen ser diferentes en cada Lenguaje, veamos a continuación los últimos grupos de operadores en Java.

Operadores de Comparación

Este tipo de operadores se utilizan para realizar una comparación entre valores.

Operador (==)

Con este operador verificamos si un valor es igual a otro valor, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    int b = 10;
    System.out.println(a == b); 
  }
} 

// Devuelve 
false (El valor de 'a' no es igual al valor de 'b')

public class MiClase {

public static void main(String[] args) {

int a = 15;

int b = 10;

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

}

// Devuelve

false (El valor de 'a' no es igual al valor de 'b')

Operador (!=)

Este operador nos permite verificar si un valor no es igual a otro, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    int b = 10;
    System.out.println(a != b); 
  }
} 

// Devuelve 
true (El valor de 'a' no es igual al valor de 'b')

public class MiClase {

public static void main(String[] args) {

int a = 15;

int b = 10;

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

}

// Devuelve

true (El valor de 'a' no es igual al valor de 'b')

Operador (>)

Este operador sirve para verificar si un valor es mayor que otro valor, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    int b = 10;
    System.out.println(a > b); 
  }
} 

// Devuelve 
true (El valor de 'a' es mayor al valor de 'b')

public class MiClase {

public static void main(String[] args) {

int a = 15;

int b = 10;

System.out.println(a > b);

}

// Devuelve

true (El valor de 'a' es mayor al valor de 'b')

Operador (<)

Este operador hace lo contrario del anterior, sirve para verificar si un valor es menor que otro valor, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    int b = 10;
    System.out.println(a < b); 
  }
} 

// Devuelve 
false (El valor de 'a' no es menor al valor de 'b')

public class MiClase {

public static void main(String[] args) {

int a = 15;

int b = 10;

System.out.println(a < b);

}

// Devuelve

false (El valor de 'a' no es menor al valor de 'b')

Operador (>=)

Este nos permite verificar si un valor es mayor o igual a otro valor, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    int b = 10;
    System.out.println(a >= b); 
  }
} 

// Devuelve 
true (El valor de 'a' es mayor al valor de 'b')

public class MiClase {

public static void main(String[] args) {

int a = 15;

int b = 10;

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

}

// Devuelve

true (El valor de 'a' es mayor al valor de 'b')

Operador (<=)

Este operador, hace lo contrario del operador anterior, nos permite verificar si un valor es menor o igual a otro valor, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    int b = 10;
    System.out.println(a <= b); 
  }
} 

// Devuelve 
false (El valor de 'a' no es menor al valor de 'b')

public class MiClase {

public static void main(String[] args) {

int a = 15;

int b = 10;

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

}

// Devuelve

false (El valor de 'a' no es menor al valor de 'b')

Bien hasta aquí terminamos con los operadores de comparación, pasemos al siguiente grupo de operadores.

Operadores lógicos

Con este tipo de operadores, podemos determinar la lógica entre 2 valores o variables, veamos los operadores que existen en este grupo.

Operador (&&)

Este operador verifica si ambas afirmaciones son verdaderas, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    System.out.println(a > 10 && a < 20); 
  }
} 

// Devuelve 
true (El valor de 'a' es mayor que 10 y menor que 20)

public class MiClase {

public static void main(String[] args) {

int a = 15;

System.out.println(a > 10 && a < 20);

}

// Devuelve

true (El valor de 'a' es mayor que 10 y menor que 20)

Operador (||)

Este operador verifica si una de las declaraciones es verdadera, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    System.out.println(a > 10 || a < 13); 
  }
} 

// Devuelve 
true (Al menos el valor de 'a' es mayor que 10)

public class MiClase {

public static void main(String[] args) {

int a = 15;

System.out.println(a > 10 || a < 13);

}

// Devuelve

true (Al menos el valor de 'a' es mayor que 10)

Operador (!)

Este operador invierte el resultado, devuelve false si el resultado es verdadero, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    System.out.println(!(a > 10 || a < 13));
  }
} 

// Devuelve 
false (El resultado es 'true' pero este operador lo invierte a 'false')

public class MiClase {

public static void main(String[] args) {

int a = 15;

System.out.println(!(a > 10 || a < 13));

}

// Devuelve

false (El resultado es 'true' pero este operador lo invierte a 'false')

Bien estos son los operadores lógicos en Java, veamos el siguiente grupo de operadores.

Operadores Bitwise o de Bits

Este tipo de operadores se utilizan para realizar una lógica binaria con los bits de un número entero o un número entero largo, veamos los operadores que hay en este grupo.

Operador (&)

Este operador significa AND, establece cada bit en 1 si es que ambos bits son 1, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 0001;
    int b = 0011;
    System.out.println(Integer.toBinaryString(a & b));
  }
} 

// Devuelve 
1

public class MiClase {

public static void main(String[] args) {

int a = 0001;

int b = 0011;

System.out.println(Integer.toBinaryString(a & b));

}

// Devuelve

Operador (|)

Este operador significa OR, establece cada bit en 1 si alguno de los dos bits es 1, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 0001;
    int b = 0011;
    System.out.println(Integer.toBinaryString(a | b)); 
  }
} 

// Devuelve 
1001

public class MiClase {

public static void main(String[] args) {

int a = 0001;

int b = 0011;

System.out.println(Integer.toBinaryString(a | b));

}

// Devuelve

1001

Operador (~)

Este operador significa NOT, invierte todos los bits, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 0001;
    System.out.println(Integer.toBinaryString(~a)); 
  }
} 

// Devuelve 
1110

public class MiClase {

public static void main(String[] args) {

int a = 0001;

System.out.println(Integer.toBinaryString(~a));

}

// Devuelve

1110

Operador (^)

Este operador significa XOR, establece cada bit en 1 si solo uno de los dos bits es 1, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 0001;
    int b = 0011;
    System.out.println(Integer.toBinaryString(a ^ b));
  }
} 

// Devuelve 
1000

public class MiClase {

public static void main(String[] args) {

int a = 0001;

int b = 0011;

System.out.println(Integer.toBinaryString(a ^ b));

}

// Devuelve

1000

Operador (<<)

Este operador significa Zero-fill left shift, hace un desplazamiento a la izquierda presionando los ceros desde la derecha y dejando caer los bits más a la izquierda, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 0001;
    int b = 0011;
    System.out.println(Integer.toBinaryString(a << b)); 
  }
} 

// Devuelve 
11110000000000

public class MiClase {

public static void main(String[] args) {

int a = 0001;

int b = 0011;

System.out.println(Integer.toBinaryString(a << b));

}

// Devuelve

11110000000000

Operador (>>)

Este operador significa Signed right shift, cambia a la derecha empujando copias del bit más a la izquierda desde la izquierda y dejando caer los bits más a la derecha, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 0001;
    int b = 0011;
    System.out.println(Integer.toBinaryString(a >> b)); 
  }
} 

// Devuelve 
0

public class MiClase {

public static void main(String[] args) {

int a = 0001;

int b = 0011;

System.out.println(Integer.toBinaryString(a >> b));

}

// Devuelve

Operador (>>>)

Este operador significa Zero-fill right shift, cambia a la derecha presionando ceros desde la izquierda y dejando caer los bits más a la derecha, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 0001;
    int b = 0011;
    System.out.println(Integer.toBinaryString(a >>> b)); 
  }
} 

// Devuelve 
0

public class MiClase {

public static void main(String[] args) {

int a = 0001;

int b = 0011;

System.out.println(Integer.toBinaryString(a >>> b));

}

// Devuelve

Bien estos son todos los operadores Bitwise que nos permiten trabajar con bits, asimismo terminamos con todos los operadores que podemos usar en Java.

Conclusión

En este Post hemos aprendido acerca de los operadores de Java, hemos visto ejemplos de como funcionan o como se usan, es importante que los conozcas bien si es que piensas trabajar con Java, la mejor manera de aprenderlos, es poniéndolos en práctica.

Nota(s)

Los códigos expuestos en este Post, pueden dejar de estar vigentes, ser eliminados o continuar vigentes, esto no depende de mi, si no de los Desarrolladores que dan soporte a Java.
No olvides que debemos usar la Tecnología para hacer cosas Buenas por el Mundo.

Síguenos en nuestras Redes Sociales para que no te pierdas nuestros próximos contenido.

Java
12-07-2020
13-07-2020
Crear un Post - Eventos Devs - Foro

Operadores de Java – Parte 2 (Final)

Partes

Operadores de Comparación

Operador (==)

Operador (!=)

Operador (>)

Operador (<)

Operador (>=)

Operador (<=)

Operadores lógicos

Operador (&&)

Operador (||)

Operador (!)

Operadores Bitwise o de Bits

Operador (&)

Operador (|)

Operador (~)

Operador (^)

Operador (<<)

Operador (>>)

Operador (>>>)

Conclusión

Nota(s)

Todas Nuestras Páginas y Categorías:

Partners