Operadores relacionales en Java | Explicado
Cómo funcionan los operadores relacionales en Java
Los operadores relacionales utilizados en Java son iguales para cualquier otro lenguaje de programación. Cada uno de los operadores relacionales se define aquí, y se proporcionaría más uso en la próxima sección.
Igual a (==): Este operador verifica la relación de igualdad entre valores/variables en Java. El símbolo del operador es "=="Y se practica siguiendo la sintaxis proporcionada a continuación:
a == b;No es igual (!=): Esto es lo opuesto al igual al operador, ya que verifica la desigualdad de dos variables/valores. El símbolo para usar este operador es "!(=) ”Y se puede seguir la siguiente sintaxis para este operador:
a!= B;Mayor que (>). El mayor que el operador verifica si el operando en el lado izquierdo es mayor que el otro o no. La sintaxis de usar el operador más grande que el operador se muestra a continuación:
a> b;Mayor o igual a (> =): Muestra si una variable es más alta o igual a otra. El "mayor o igual a" se ejerce usando el símbolo "> =" y sigue la sintaxis proporcionada a continuación.
a> = b;Menos que (<): Este operador verifica si la primera variable/valor es menor que el segundo valor/variable o no. Puede consultar la siguiente declaración para usar este operador.
aCómo usar operadores relacionales en Java
Esta sección proporciona el uso de operadores relacionales en Java. Más adelante en esta sección, también conocerá el funcionamiento de los operadores relacionales en declaraciones y bucles de Java.
Igual a (==): El siguiente código Java utiliza el operador "igual a" entre dos variables y devuelve el resultado falso ya que la variable x = 2 no es igual a y = 4.
Paquete Newpack;clase pública Relop
public static void main (string [] args)
// declarando variables
int x = 2, y = 4;
Sistema.afuera.println (x == y);
La salida del código se proporciona a continuación:
No igual a(!=): El siguiente programa Java, A = 7 no es igual a B = 9, pero el operador no igual devuelve verdadero en la salida.
Paquete Newpack;clase pública Relop
public static void main (string [] args)
// declarando variables
int a = 7, b = 9;
Sistema.afuera.println (un!= b);
La salida del código se muestra a continuación:
Menos que (<): El código proporcionado a continuación compara las variables C y D utilizando el operador relacional "Menos que". Como el valor de la variable c = 10 es menos que d = 15, Entonces la salida sería verdadera:
Paquete Newpack;clase pública Relop
public static void main (string [] args)
// declarando variables
int c = 10, d = 15;
Sistema.afuera.println (c
La salida del código se muestra a continuación:
Mayor que (>): El código Java que se proporciona a continuación utiliza el operador más grande que el operador en dos variables (E y F). El entero 18 se almacena en variable E, mientras que 12 se asigna a variable F: que muestra el valor de F es mayor que mi Pero hemos comprobado si f> e O no.
Paquete Newpack;clase pública Relop
public static void main (string [] args)
// declarando variables
int e = 18, f = 12;
Sistema.afuera.println (f> e);
La salida del código anterior es falso porque el F
Mayor o igual a (> =): El código proporcionado a continuación ejerce el mejor o igual al operador en dos variables. La condición (x> = y) definida en el código es verdadera, por lo que la salida también es verdadera:
Paquete Newpack;clase pública Relop
public static void main (string [] args)
// declarando variables
int x = 13, y = 13;
Sistema.afuera.println (x> = y);
La salida del código se muestra a continuación:
Menos que o igual a (<=): Este operador se practica en dos variables a y b. Los valores asignados a a y b son 5 y 8 respectivamente. El conjunto de condición es B<=a which is false thus the return would also be false.
Paquete Newpack;clase pública Relop
public static void main (string [] args)
// declarando variables
int a = 5, b = 8;
Sistema.afuera.println (b<=a);
La salida del código se puede ver en la imagen a continuación:
Uso de operadores relacionales en bucles y declaraciones if-else en Java
La práctica más común de los operadores relacionales es usarlos dentro de los bucles y las declaraciones condicionales if-else para construir una condición.
En bucle: El bucle for es un tipo de bucle ampliamente utilizado y el código escrito a continuación muestra el uso de bucles con operadores relacionales.
Paquete Newpack;clase pública Relop
public static void main (string [] args)
// declarando variables
int z = 2, i;
// usando para bucle y <=
para (i = 0; i<=z; i++)
Sistema.afuera.println ("condición es verdadera");
El código se describe como:
- declarando variables Z e i
- Usando para bucle y operador relacional (menos o igual a)
- Impresión de una declaración
La salida del código se muestra a continuación:
if-else y operadores relacionales: El siguiente código demuestra el uso del operador IF-Else y Relacional (>).
Paquete Newpack;clase pública Relop
public static void main (string [] args)
// declarando variables
int a = 4, b = 3;
// Uso del operador if-else y relacional
if (a> b)
Sistema.afuera.println ("La condición es verdadera");
demás
Sistema.afuera.println ("Falso!");
El código se describe aquí:
- declarando variables
- Usar el (a> b) como condición en la declaración if
- Impresión dentro de las declaraciones de IF y Else
La salida del código se muestra a continuación:
Conclusión
Los operadores relacionales en Java tienen la responsabilidad clave de verificar la condición y devolver el resultado en función de esa verificación de condición. Los operadores relacionales de Java se practican en declaraciones y bucles condicionales para tomar decisiones en programas. Este artículo demuestra el funcionamiento de los operadores relacionales. Además, se proporcionan varios ejemplos que ilustran el uso de operadores condicionales individualmente, así como en declaraciones y bucles condicionales.