Bienvenidos a otro capítulo de este Curso Gratis de Java para Hackers – Operadores Relacionales. Comparte este articulo y síguenos para recibir más capítulos, guías y cursos gratis.
Este curso está en constante actualización. Tendrá revisiones y actualizaciones anuales y correcciones y mejoras mensuales. Este curso está en un ciclo de crecimiento y mejora constante, agradecemos su apoyo difundiendo, compartiendo, comentando o simplemente leyéndolo.
¿Te gustaría enterarte de cuando lanzamos descuentos y nuevos cursos?
Los operadores
Los operadores constituyen el componente básico de cualquier lenguaje de programación. Java también proporciona muchos tipos de operadores que se pueden utilizar según la necesidad de realizar diversos cálculos y funciones, ya sean lógicos, aritméticos, relacionales, etc. Se clasifican según la funcionalidad que proporcionan.
Tipos de operadores en Java
Java comprende varios operadores que se utilizan para realizar diferentes operaciones según los requisitos. Estos operadores se clasifican según la funcionalidad que ofrecen. Entonces, aquí hay una lista detallada de operadores de Java y su explicación. Operador en Java es un símbolo que se utiliza para realizar operaciones. Por ejemplo: +, -, *, / etc.
Como podemos ver los nombres y la agrupación de los operadores “varían” según la fuente consultada.
Hay muchos tipos de operadores en Java, nosotros los subdividiremos en estas categorías:
- Operadores aritméticos
- Operadores de Asignación
- Operadores unarios
- Operadores relacionales
- Operadores ternarios
- Operadores bit a bit
- Operadores lógicos
- Operadores de turno
Operadores relacionales
Sirven para comparar dos valores del mismo tipo, y como resultado se obtiene un tipo de dato lógico o booleano. Para la comparación de tipos lógicos, solo son válidos los operadores “==” y “!=”.
Los operadores de relación comparan 2 valores y determinan la relación entre ellos. Asignan un valor a una variable. El operador por excelencia de asignación es el operador igual (=). Existen otros operadores de asignación que tienen por objetivo abreviar la combinación de operaciones y la asignación del resultado en una variable. Cualquier expresión de la forma variable = variable operador expresión es equivalente a variable operador = expresión.
Sintaxis
operand1 relational_operator operand2
Aquí,
- operando1 es la primera variable a comparar
- operando2 es la segunda variable a comparar
- operator_relacional comprueba la relación entre los dos operandos dados, es decir, operando1 y operando2.
Veamos algunos ejemplos:
- a += b; // Operación equivalente: a = a + b;
- a != b (a diferente de b?)
- a > b, a >= b (a mayor que b, a mayor o igual que b)
- a < b, a <= b
- a = b
| Operador | Descripción | Ejemplo | Resultado |
| == | Igual que | ‘B’ == ‘b’ | false |
| ¡= | Distinto que | true ¡= false | true |
| < | Menor que | 5 < 2 | false |
| > | Mayor que | 7.2 > 10.5 | false |
| <= | Menor o igual que | ‘a’ <= ‘c’ | true |
| >= | Mayor o igual que | 5 >= 5 | true |
Los operadores relacionales
Existen los siguientes operadores relacionales compatibles con el lenguaje Java. Supongamos que la variable A tiene 10 y la variable B tiene 20, entonces:
| Operador | Descripción | Ejemplo |
| == (igual a) | Comprueba si los valores de dos operandos son iguales o no; en caso afirmativo, la condición se vuelve verdadera. | (A == B) no es cierto. |
| != (no igual a) | Comprueba si los valores de dos operandos son iguales o no; si los valores no son iguales, la condición se vuelve verdadera. | (A! = B) es cierto. |
| > (mayor que) | Comprueba si el valor del operando izquierdo es mayor que el valor del operando derecho; en caso afirmativo, la condición se vuelve verdadera. | (A > B) no es cierto. |
| < (menos que) | Comprueba si el valor del operando izquierdo es menor que el valor del operando derecho; en caso afirmativo, la condición se vuelve verdadera. | (A < B) es cierto. |
| >= (mayor o igual a) | Comprueba si el valor del operando izquierdo es mayor o igual que el valor del operando derecho; en caso afirmativo, la condición se vuelve verdadera. | (A >= B) no es cierto. |
| <= (menor o igual a) | Comprueba si el valor del operando izquierdo es menor o igual que el valor del operando derecho; en caso afirmativo, la condición se vuelve verdadera. | (A <= B) es cierto. |
Ventajas
Existen varias ventajas de utilizar operadores relacionales en Java, que incluyen:
- Fácil de entender : los operadores relacionales son simples y fáciles de entender, lo que facilita la escritura de código que realiza comparaciones.
- Versátil: los operadores relacionales se pueden utilizar para comparar valores de diferentes tipos de datos, como números enteros, números de punto flotante y cadenas.
- Esenciales para la toma de decisiones: Los operadores relacionales son esenciales para la toma de decisiones en un programa, ya que permiten controlar el flujo de un programa en función de los resultados de las comparaciones.
- Eficiente: Los operadores relacionales son eficientes, ya que realizan comparaciones de forma rápida y precisa.
- Código reutilizable : el código que utiliza operadores relacionales se puede reutilizar en diferentes partes de un programa, lo que facilita el mantenimiento y la actualización del código.
- Legibilidad de código mejorada : al utilizar operadores relacionales, puede hacer que su código sea más legible y comprensible, ya que las comparaciones están claramente indicadas en el código.
- Depuración más fácil : los operadores relacionales facilitan la depuración, ya que puede usarlos para verificar los valores de las variables y descubrir dónde ocurre un problema en su código.
Aquí, el operador relacional < comprobará si m es menor que o no y devolverá verdadero o falso .
Ejemplo:
// Java Program to implement
// Relational Operators
import java.io.*;
// Driver Class
class laprovittera {
// main function
public static void main(String[] args)
{
// Comparison operators
int a = 10;
int b = 3;
int c = 5;
System.out.println("a > b: " + (a > b));
System.out.println("a < b: " + (a < b));
System.out.println("a >= b: " + (a >= b));
System.out.println("a <= b: " + (a <= b));
System.out.println("a == c: " + (a == c));
System.out.println("a != c: " + (a != c));
}
}Producción
a > b: true
a < b: false
a >= b: true
a <= b: false
a == c: false
a != c: trueOperador 1: operador ‘Igual a’ (==)
Este operador se utiliza para comprobar si los dos operandos dados son iguales o no. El operador devuelve verdadero si el operando del lado izquierdo es igual al del lado derecho; en caso contrario, falso.
Sintaxis:
var1 == var2
Ilustración:
var1 = “hacktheplanet”
var2 = 20
var1 == var2 da como resultado falso
Ejemplo:
// Java Program to Illustrate equal to Operator
// Importing I/O classes
import java.io.*;
// Main class
class laprovittera {
// Main driver method
public static void main(String[] args)
{
// Initializing variables
int var1 = 5, var2 = 10, var3 = 5;
// Displaying var1, var2, var3
System.out.println("Var1 = " + var1);
System.out.println("Var2 = " + var2);
System.out.println("Var3 = " + var3);
// Comparing var1 and var2 and
// printing corresponding boolean value
System.out.println("var1 == var2: "
+ (var1 == var2));
// Comparing var1 and var3 and
// printing corresponding boolean value
System.out.println("var1 == var3: "
+ (var1 == var3));
}
}Producción
Var1 = 5
Var2 = 10
Var3 = 5
var1 == var2: falso
var1 == var3: verdaderoOperador 2: Operador ‘No igual a’ (!=)
Este operador se utiliza para comprobar si los dos operandos dados son iguales o no. Funciona de manera opuesta a la del operador igual. Devuelve verdadero si el operando del lado izquierdo no es igual al del lado derecho; en caso contrario, falso.
Sintaxis:
var1 != var2
Ilustración:
var1 = “HackThePlanet”
var2 = 20
var1! = var2 da como resultado verdadero
Ejemplo:
// Java Program to Illustrate No- equal-to Operator
// Importing I/O classes
import java.io.*;
// Main class
class laprovittera {
// Main driver method
public static void main(String[] args)
{
// Initializing variables
int var1 = 5, var2 = 10, var3 = 5;
// Displaying var1, var2, var3
System.out.println("Var1 = " + var1);
System.out.println("Var2 = " + var2);
System.out.println("Var3 = " + var3);
// Comparing var1 and var2 and
// printing corresponding boolean value
System.out.println("var1 != var2: "
+ (var1 != var2));
// Comparing var1 and var3 and
// printing corresponding boolean value
System.out.println("var1 != var3: "
+ (var1 != var3));
}
}Producción
Var1 = 5
Var2 = 10
Var3 = 5
var1 != var2: verdadero
var1 != var3: falsoOperador 3: operador ‘mayor que'(>)
Esto comprueba si el primer operando es mayor que el segundo operando o no. El operador devuelve verdadero cuando el operando del lado izquierdo es mayor que el del lado derecho.
Sintaxis:
var1 > var2
Ilustración:
var1 = 30
var2 = 20
var1 > var2 da como resultado verdadero
Ejemplo:
// Java code to Illustrate Greater than operator
// Importing I/O classes
import java.io.*;
// Main class
class laprovittera {
// Main driver method
public static void main(String[] args)
{
// Initializing variables
int var1 = 30, var2 = 20, var3 = 5;
// Displaying var1, var2, var3
System.out.println("Var1 = " + var1);
System.out.println("Var2 = " + var2);
System.out.println("Var3 = " + var3);
// Comparing var1 and var2 and
// printing corresponding boolean value
System.out.println("var1 > var2: " + (var1 > var2));
// Comparing var1 and var3 and
// printing corresponding boolean value
System.out.println("var3 > var1: "
+ (var3 >= var1));
}
}Producción
Var1 = 30
Var2 = 20
Var3 = 5
var1 > var2: verdadero
var3 > var1: falsoOperador 4: Operador ‘Menor que'(<)
Esto comprueba si el primer operando es menor que el segundo operando o no. El operador devuelve verdadero cuando el operando del lado izquierdo es menor que el del lado derecho. Funciona de manera opuesta a la del operador mayor que.
Sintaxis:
var1 < var2
Ilustración:
var1 = 10
var2 = 20
var1 <var2 da como resultado verdadero
Ejemplo:
// Java code to Illustrate Less than Operator
// Importing I/O classes
import java.io.*;
// Main class
class laprovittera {
// Main driver method
public static void main(String[] args)
{
// Initializing variables
int var1 = 10, var2 = 20, var3 = 5;
// Displaying var1, var2, var3
System.out.println("Var1 = " + var1);
System.out.println("Var2 = " + var2);
System.out.println("Var3 = " + var3);
// Comparing var1 and var2 and
// printing corresponding boolean value
System.out.println("var1 < var2: " + (var1 < var2));
// Comparing var2 and var3 and
// printing corresponding boolean value
System.out.println("var2 < var3: " + (var2 < var3));
}
}Producción
Var1 = 10
Var2 = 20
Var3 = 5
var1 <var2: verdadero
var2 <var3: falsoOperador 5: Mayor o igual a (>=)
Esto comprueba si el primer operando es mayor o igual que el segundo operando o no. El operador devuelve verdadero cuando el operando del lado izquierdo es mayor o igual que el del lado derecho.
Sintaxis:
var1 >= var2
Ilustración:
var1 = 20
var2 = 20
var3 = 10
var1 >= var2 da como resultado verdadero
var2 >= var3 da como resultado verdadero
Ejemplo:
// Java Program to Illustrate Greater than or equal to
// Operator
// Importing I/O classes
import java.io.*;
// Main class
class laprovittera {
// Main driver method
public static void main(String[] args)
{
// Initializing variables
int var1 = 20, var2 = 20, var3 = 10;
// Displaying var1, var2, var3
System.out.println("Var1 = " + var1);
System.out.println("Var2 = " + var2);
System.out.println("Var3 = " + var3);
// Comparing var1 and var2 and
// printing corresponding boolean value
System.out.println("var1 >= var2: "
+ (var1 >= var2));
// Comparing var2 and var3 and
// printing corresponding boolean value
System.out.println("var2 >= var3: "
+ (var2 >= var3));
}
}Producción
Var1 = 20
Var2 = 20
Var3 = 10
var1 >= var2: verdadero
var2 >= var3: verdaderoOperador 6: Menor o igual a (<=)
Esto comprueba si el primer operando es menor o igual que el segundo operando o no. El operador devuelve verdadero cuando el operando del lado izquierdo es menor o igual que el del lado derecho.
Sintaxis:
var1 <= var2
Ilustración:
var1 = 10
var2 = 10
var3 = 9
var1 <= var2 da como resultado verdadero
var2 <= var3 da como resultado falso
Ejemplo:
// Java Program to Illustrate Less
// than or equal to operator
// Importing I/O classes
import java.io.*;
// Main class
class laprovittera {
// Main driver method
public static void main(String[] args)
{
// Initializing variables
int var1 = 10, var2 = 10, var3 = 9;
// Displaying var1, var2, var3
System.out.println("Var1 = " + var1);
System.out.println("Var2 = " + var2);
System.out.println("Var3 = " + var3);
// Comparing var1 and var2 and
// printing corresponding boolean value
System.out.println("var1 <= var2: "
+ (var1 <= var2));
// Comparing var2 and var3 and
// printing corresponding boolean value
System.out.println("var2 <= var3: "
+ (var2 <= var3));
}
}Producción
Var1 = 10
Var2 = 10
Var3 = 9
var1 <= var2: verdadero
var2 <= var3: falsoPrograma que implementa todos los operadores relacionales en Java para la entrada del usuario:
import java.util.Scanner;
public class RelationalOperators {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
//System.out.println("Enter first number: ");
// int num1 = scan.nextInt();
// System.out.println("Enter second number: ");
// int num2 = scan.nextInt();
int num1 =1;
int num2 = 2;
System.out.println("num1 > num2 is " + (num1 > num2));
System.out.println("num1 < num2 is " + (num1 < num2));
System.out.println("num1 >= num2 is " + (num1 >= num2));
System.out.println("num1 <= num2 is " + (num1 <= num2));
System.out.println("num1 == num2 is " + (num1 == num2));
System.out.println("num1 != num2 is " + (num1 != num2));
}
}Producción
número1 > número2 es falso
número1 < número2 es verdadero
número1 >= número2 es falso
número1 <= número2 es verdadero
número1 == número2 es falso
número1! = número2 es verdaderoExplicación
El código anterior implementa todos los operadores relacionales en Java para la entrada del usuario. La siguiente es una explicación detallada del código:
- Importación de la clase Scanner : el código comienza importando la clase Scanner, que se utiliza para leer la entrada del usuario. La clase Scanner es parte del paquete java.util, por lo que es necesario importarla para poder utilizarla.
- Definición del método principal: Luego, el programa define el método principal, que es el punto de partida del programa. Aquí es donde se ejecuta la lógica del programa.
- Lectura de la entrada del usuario: el código utiliza el objeto Scanner para leer dos números enteros del usuario. El primer número se almacena en la variable num1 y el segundo número se almacena en la variable num2.
- Uso de operadores relacionales: el código luego usa los operadores relacionales >, <, >=, <=, == y != para comparar los valores de num1 y num2. Los resultados de estas comparaciones se almacenan en variables booleanas, que luego se muestran al usuario.
- Visualización de resultados : los resultados de las comparaciones se muestran al usuario mediante el método System.out.println. Este método se utiliza para imprimir un mensaje en la consola.
- Cerrar el objeto Scanner: finalmente, el código cierra el objeto Scanner para evitar pérdidas de memoria y garantizar que el programa finalice limpiamente.
Los operadores relacionales en Java devuelven un valor booleano verdadero o falso, según el resultado de la comparación. Por ejemplo, num1 > num2 devuelve verdadero si num1 es mayor que num2 y falso en caso contrario. De manera similar, num1 == num2 devuelve verdadero si num1 es igual a num2 y falso en caso contrario.
Ejemplo de operadores relacionales de Java en el programa
A continuación se muestra un programa de ejemplo que utiliza operadores relacionales de Java:
public class RelationalOperatorExample {
public static void main(String[] args) {
int a = 10;
int b = 5;
// Equal to (==) operator
boolean isEqual = (a == b); // Evaluates to false
// Not equal to (!=) operator
boolean isNotEqual = (a != b); // Evaluates to true
// Greater than (>) operator
boolean isGreater = (a > b); // Evaluates to true
// Less than (<) operator
boolean isLess = (a < b); // Evaluates to false
// Greater than or equal to (>=) operator
boolean isGreaterOrEqual = (a >= b); // Evaluates to true
// Less than or equal to (<=) operator
boolean isLessOrEqual = (a <= b); // Evaluates to false
// Output the results
System.out.println("a == b: " + isEqual);
System.out.println("a != b: " + isNotEqual);
System.out.println("a > b: " + isGreater);
System.out.println("a < b: " + isLess);
System.out.println("a >= b: " + isGreaterOrEqual);
System.out.println("a <= b: " + isLessOrEqual);
}
}En este programa, tenemos dos variables a y b con valores 10 y 5 respectivamente. Usamos varios operadores relacionales para comparar estos valores y almacenar los resultados en variables booleanas. Luego, enviamos los resultados a la consola.
Cuando ejecute este programa, verá los resultados booleanos de las comparaciones relacionales basadas en los valores de a y b.
Preguntas frecuentes sobre operadores relacionales de Java
¿Cuál es el resultado de una operación relacional?
El resultado de una operación relacional es siempre un valor booleano (verdadero o falso) en función de si se cumple la condición especificada.
¿Se pueden comparar diferentes tipos de datos utilizando operadores relacionales?
Los operadores relacionales se pueden utilizar para comparar valores de tipos de datos compatibles. Por ejemplo, puede comparar números enteros, números de punto flotante, caracteres y otros tipos que se pueden comparar lógicamente.
¿Cuál es la diferencia entre == y igual () para la comparación de cadenas?
El operador == comprueba si dos referencias apuntan al mismo objeto en la memoria. El método equals() compara el contenido de dos objetos de cadena.
¿Se pueden combinar varios operadores relacionales en una sola expresión?
Sí, puede combinar múltiples operadores relacionales utilizando operadores lógicos (&&, ||, !) para crear condiciones complejas para la toma de decisiones.
¿Qué es la evaluación de cortocircuito con respecto a los operadores relacionales?
La evaluación de cortocircuito es un comportamiento en Java donde la evaluación de una expresión lógica se detiene tan pronto como se puede determinar el resultado final. Por ejemplo, en una operación &&, si el operando izquierdo es falso, el operando derecho no se evalúa porque el resultado siempre será falso.
¿Puedo comparar objetos usando operadores relacionales?
Sí, puede comparar objetos usando operadores relacionales, pero el comportamiento depende de cómo la clase de los objetos define el método equals() y el método compareTo() (para objetos que implementan la interfaz Comparable).
¿Son los operadores relacionales aplicables a valores booleanos?
Técnicamente, los valores booleanos ya son el resultado de una comparación, por lo que generalmente no es necesario utilizar operadores relacionales con valores booleanos. Sin embargo, aún puede usarlos y producirán los resultados booleanos esperados.
No te detengas, sigue avanzando
Aquí tienes un propósito para este 2024 que debes considerar seriamente: si has querido mejorar tus habilidades en hacking, Ciberseguridad y programación ahora es definitivamente el momento de dar el siguiente paso. ¡Desarrolla tus habilidades aprovechando nuestros cursos a un precio increíble y avanza en tu carrera! El mundo necesita más hackers…
Universidad Hacking. Todo en Ciberseguridad. Curso Completo
Aprende Hacking Ético y Ciberseguridad sin necesitar conocimientos Previos. Practica Hacking Ético y Ciberseguridad aquí
Calificación: 4,6 de 5 (2.877 calificaciones) 15.284 estudiantes Creado por Alvaro Chirou • 1.800.000+ Enrollments Worldwide
Lo que aprenderás
- Seguridad informática
- Hacking Ético en profundidad
- Redes
- Programación (Python) (Hacking con Python)
- Análisis de Malware con laboratorios, practicas y ejecución de Malware para que veas su comportamiento.
- Cómo reforzar tu Privacidad y Anonimato
- Uso avanzado de Metasploit
- Top 10 de Owasp Web, Top 10 de Owasp mobile y Top 10 de Owasp API
- Seguridad informática para empresas
- Kali linux de 0 a 100, Veremos su suite de herramientas de hacking y como explotar fallos en sistemas.
- Termux y como hackear desde el celular
- Seguridad informática server/web, profundizaremos en WordPress
- Análisis de trafico en Wireshark
- Y mucho, pero mucho más
¿Esto que significa?
Hoy más que nunca, se necesitan personas capacitadas en este rubro para trabajar.
Por esa razón cree esta formación profesional para compartirte mis conocimientos y experiencia en la materia y puedas iniciar en este mundo del Hacking Ético y Ciberseguridad.
Te voy a estar acompañando en el proceso de aprendizaje, donde si estas empezando desde 0, sin conocimientos previos, no es un impedimento ya que iniciaremos como si no supieras nada de la materia.
Si sos una persona con conocimientos, podrás iniciar directamente en el nivel más avanzado o en el que tu elijas.
Como en todos mis cursos en udemy, tendrás muchísima practica para que materialices lo que vas aprendiendo.
Aprende con nuestros más de 100 cursos que tenemos disponibles para vos
No solo te enseñamos, tambien te guíamos para que puedas conseguir trabajo como desarrollador y hacker…
¿Te gustaría enterarte de cuando lanzamos descuentos y nuevos cursos?
Sobre los autores
Álvaro Chirou
Yo soy Álvaro Chirou, tengo más de 20 Años de experiencia trabajando en Tecnología, eh dado disertaciones en eventos internacionales como OWASP, tengo más de 1.800.000 estudiantes en Udemy y 100 formaciones profesionales impartidas en la misma. Puedes serguirme en mis redes:
Laprovittera Carlos
Soy Laprovittera Carlos. Con más de 20 años de experiencia en IT brindo Educación y Consultoría en Seguridad de la Información para profesionales, bancos y empresas. Puedes saber más de mi y de mis servicios en mi sitio web: laprovittera.com y seguirme en mis redes:
¿Quieres iniciarte en hacking y ciberseguridad pero no sabes por dónde empezar? Inicia leyendo nuestra guia gratuita: https://achirou.com/como-iniciarse-en-ciberseguridad-y-hacking-en-2024/ que te lleva de 0 a 100. Desde los fundamentos más básicos, pasando por cursos, recursos y certificaciones hasta cómo obtener tu primer empleo.