Java proporciona muchos tipos de operadores que se pueden utilizar según la necesidad. Se clasifican según la funcionalidad que proporcionan. En este artículo, aprenderemos sobre los operadores de Java y todos sus tipos.

¿Qué son los operadores de Java?

Los operadores en Java son los símbolos utilizados para realizar operaciones específicas en Java. Los operadores realizan tareas como suma, multiplicación, etc. que parecen fáciles, aunque la implementación de estas tareas es bastante compleja.

Tipos de operadores en Java

Hay varios tipos de operadores en Java, todos se mencionan a continuación:

1. Operadores aritméticos
2. Operadores unarios
3. Operador de asignación
4. Operadores relacionales
5. Operadores logicos
6. Operador ternario
7. Operadores bit a bit
8. Operadores de turno
9. instancia de operador

1. Operadores aritméticos

Se utilizan para realizar operaciones aritméticas simples en tipos de datos primitivos.

• * : Multiplicación
• / : División
• % : Modulo
• + : Suma
• – : Sustracción

Ejemplo:

// Java Program to implement // Arithmetic Operators import java.io.*; // Drive Class class GFG {  // Main Function  public static void main (String[] args) {    // Arithmetic operators  int a = 10;  int b = 3;    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 % b = ' + (a % b));    } }>

a + b = 13 a - b = 7 a * b = 30 a / b = 3 a % b = 1>

2. Operadores unarios

Los operadores unarios sólo necesitan un operando. Se utilizan para incrementar, disminuir o negar un valor.

• – : menos unario , utilizado para negar los valores.
• + : más unario indica el valor positivo (sin embargo, los números son positivos sin esto). Realiza una conversión automática a int cuando el tipo de su operando es byte, char o short. Esto se llama promoción numérica unaria.
• ++ : Operador de incremento , utilizado para incrementar el valor en 1. Hay dos variedades de operadores de incremento.
  
  • Post-incremento: El valor se utiliza primero para calcular el resultado y luego se incrementa.
  • Pre-incremento: Primero se incrementa el valor y luego se calcula el resultado.
• – – : Operador de decremento , utilizado para disminuir el valor en 1. Hay dos variedades de operadores de decremento.
  
  • Post-decremento: El valor se utiliza primero para calcular el resultado y luego se reduce.
  • Pre-Decremento: El valor primero se reduce y luego se calcula el resultado.
• ! : Operador no lógico , utilizado para invertir un valor booleano.

Ejemplo:

// Java Program to implement // Unary Operators import java.io.*; // Driver Class class GFG {  // main function  public static void main(String[] args)  {  // Interger declared  int a = 10;  int b = 10;  // Using unary operators  System.out.println('Postincrement : ' + (a++));  System.out.println('Preincrement : ' + (++a));  System.out.println('Postdecrement : ' + (b--));  System.out.println('Predecrement : ' + (--b));  } }>

Postincrement : 10 Preincrement : 12 Postdecrement : 10 Predecrement : 8>

3. Operador de asignación

‘=’ El operador de asignación se utiliza para asignar un valor a cualquier variable. Tiene asociatividad de derecha a izquierda, es decir, el valor dado en el lado derecho del operador se asigna a la variable de la izquierda y, por lo tanto, el valor del lado derecho debe declararse antes de usarlo o debe ser una constante.

ejecutar script shell

El formato general del operador de asignación es:

variable   =   value;>

En muchos casos, el operador de asignación se puede combinar con otros operadores para crear una versión más corta de la declaración llamada Declaración compuesta . Por ejemplo, en lugar de un = a+5, podemos escribir un += 5.

• += , para sumar el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
• -= , para restar el operando derecho del operando izquierdo y luego asignarlo a la variable de la izquierda.
• *= , para multiplicar el operando izquierdo por el operando derecho y luego asignarlo a la variable de la izquierda.
• /= , para dividir el operando izquierdo por el operando derecho y luego asignarlo a la variable de la izquierda.
• %= , para asignar el módulo del operando izquierdo por el operando derecho y luego asignarlo a la variable de la izquierda.

Ejemplo:

// Java Program to implement // Assignment Operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main(String[] args)  = 0b1100: ' + (f  }>

f += 3: 10 f -= 2: 8 f *= 4: 32 f /= 3: 10 f %= 2: 0 f &= 0b1010: 0 f |= 0b1100: 12 f ^= 0b1010: 6 f <>= 1: 12 f>>>= 1: 6>

4. Operadores relacionales

Estos operadores se utilizan para comprobar relaciones como igualdad, mayor que y menor que. Devuelven resultados booleanos después de la comparación y se utilizan ampliamente en declaraciones de bucle, así como en declaraciones condicionales if-else. El formato general es,

variable   relation_operator   value>

Algunos de los operadores relacionales son-

• ==, igual a devuelve verdadero si el lado izquierdo es igual al lado derecho.
• !=, No es igual a devuelve verdadero si el lado izquierdo no es igual al lado derecho.
• <, menos que: devuelve verdadero si el lado izquierdo es menor que el lado derecho.
• <=, menor o igual a devuelve verdadero si el lado izquierdo es menor o igual que el lado derecho.
• >, mayor que: devuelve verdadero si el lado izquierdo es mayor que el lado derecho.
• >=, mayor o igual a devuelve verdadero si el lado izquierdo es mayor o igual que el lado derecho.

Ejemplo:

// Java Program to implement // Relational Operators import java.io.*; // Driver Class class GFG {  // 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 + (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));  } }>

a>b: verdadero a = b: verdadero a<= b: false a == c: false a != c: true>

5. Operadores lógicos

Estos operadores se utilizan para realizar operaciones lógicas AND y OR lógicas, es decir, una función similar a la puerta AND y la puerta OR en la electrónica digital. Una cosa a tener en cuenta es que la segunda condición no se evalúa si la primera es falsa, es decir, tiene un efecto de cortocircuito. Se utiliza ampliamente para probar varias condiciones para tomar una decisión. Java también tiene un NOT lógico, que devuelve verdadero cuando la condición es falsa y viceversa.

Los operadores condicionales son:

• &&, lógico Y: devuelve verdadero cuando ambas condiciones son verdaderas.
• ||, Lógico O: devuelve verdadero si al menos una condición es verdadera.
• !, NO lógico: devuelve verdadero cuando una condición es falsa y viceversa

Ejemplo:

programas de muestra java

// Java Program to implemenet // Logical operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main (String[] args)  }>

x && y: false x || y: true !x: false>

6. Operador ternario

El operador ternario es una versión abreviada de la declaración if-else. Tiene tres operandos y de ahí el nombre Ternario.

El formato general es:

condition   ?   if true   :   if false>

La declaración anterior significa que si la condición se evalúa como verdadera, entonces ejecute las declaraciones después de '?'; de lo contrario, ejecute las declaraciones después de ':'.

Ejemplo:

// Java program to illustrate // max of three numbers using // ternary operator. public class operators {  public static void main(String[] args)  {  int a = 20, b = 10, c = 30, result;  // result holds max of three  // numbers  result  = ((a>b) ? (a> c)? a : c : (b> c)? antes de Cristo);  System.out.println('Máximo de tres números = ' + resultado);  } }>

Max of three numbers = 30>

7. Operadores bit a bit

Estos operadores se utilizan para realizar la manipulación de bits individuales de un número. Se pueden utilizar con cualquiera de los tipos de números enteros. Se utilizan al realizar operaciones de actualización y consulta de los árboles indexados binarios.

• &, operador AND bit a bit: devuelve bit a bit Y de los valores de entrada.
• |, operador OR bit a bit: devuelve bit a bit O de los valores de entrada.
• ^, operador XOR bit a bit: devuelve XOR bit a bit de los valores de entrada.
• ~, Operador de complemento bit a bit: Este es un operador unario que devuelve la representación en complemento a uno del valor de entrada, es decir, con todos los bits invertidos.

// Java Program to implement // bitwise operators import java.io.*; // Driver class class GFG {  // main function  public static void main(String[] args)    // Bitwise operators  int d = 0b1010;  int e = 0b1100;  System.out.println('d & e: ' + (d & e));  System.out.println('d  }>

d & e: 8 d | e: 14 d ^ e: 6 ~d: -11 d <>1:6 y>>> 1:6>>> 
    8. Operadores de turno    
Estos operadores se utilizan para desplazar los bits de un número hacia la izquierda o hacia la derecha, multiplicando o dividiendo así el número por dos, respectivamente. Se pueden utilizar cuando tenemos que multiplicar o dividir un número por dos. Formato general-
     <<, Operador de desplazamiento a la izquierda:    desplaza los bits del número hacia la izquierda y llena con 0 los espacios vacíos que quedan como resultado. Efecto similar al de multiplicar el número por una potencia de dos.
    >>, Operador de desplazamiento a la derecha firmado:    desplaza los bits del número hacia la derecha y, como resultado, llena con 0 los espacios vacíos que quedan. El bit más a la izquierda depende del signo del número inicial. Efecto similar a dividir el número con alguna potencia de dos.
    >>>, Operador de desplazamiento a la derecha sin firmar:    desplaza los bits del número hacia la derecha y, como resultado, llena con 0 los espacios vacíos que quedan. El bit más a la izquierda se establece en 0.
Java 
// Java Program to implement // shift operators import java.io.*; // Driver Class class GFG {  // main function  public static void main(String[] args)  {  int a = 10;    // using left shift  System.out.println('a<<1 : ' + (a << 1));    // using right shift  System.out.println('a>>1 : ' + (a>> 1));  } }>
   
  Producción  
a<<1 : 20 a>>1 : 5>
 
    9. operador de instancia    
La instancia del operador se utiliza para la verificación de tipos. Puede usarse para probar si un objeto es una instancia de una clase, una subclase o una interfaz. Formato general-
cómo cambiar el nombre de un directorio Linux
 
object   instance of   class/subclass/interface>
Java 
// Java program to illustrate // instance of operator class operators {  public static void main(String[] args)  {  Person obj1 = new Person();  Person obj2 = new Boy();  // As obj is of type person, it is not an  // instance of Boy or interface  System.out.println('obj1 instanceof Person: '  + (obj1 instanceof Person));  System.out.println('obj1 instanceof Boy: '  + (obj1 instanceof Boy));  System.out.println('obj1 instanceof MyInterface: '  + (obj1 instanceof MyInterface));  // Since obj2 is of type boy,  // whose parent class is person  // and it implements the interface Myinterface  // it is instance of all of these classes  System.out.println('obj2 instanceof Person: '  + (obj2 instanceof Person));  System.out.println('obj2 instanceof Boy: '  + (obj2 instanceof Boy));  System.out.println('obj2 instanceof MyInterface: '  + (obj2 instanceof MyInterface));  } } class Person { } class Boy extends Person implements MyInterface { } interface MyInterface { }>
   
  Producción  
obj1 instanceof Person: true obj1 instanceof Boy: false obj1 instanceof MyInterface: false obj2 instanceof Person: true obj2 instanceof Boy: true obj2 instanceof MyInterface: true>
 
Precedencia y asociatividad de los operadores de Java
Las reglas de precedencia y asociativas se utilizan cuando se trata de ecuaciones híbridas que involucran más de un tipo de operador. En tales casos, estas reglas determinan qué parte de la ecuación considerar primero, ya que puede haber muchas valoraciones diferentes para la misma ecuación. La siguiente tabla muestra la precedencia de los operadores en orden decreciente de magnitud, donde la parte superior representa la precedencia más alta y la parte inferior muestra la precedencia más baja.
 
 
 
Preguntas interesantes sobre los operadores de Java
    1. Precedencia y Asociatividad:    
A menudo existe confusión cuando se trata de ecuaciones híbridas, que son ecuaciones que tienen múltiples operadores. El problema es qué parte resolver primero. Hay una regla de oro a seguir en estas situaciones. Si los operadores tienen diferente precedencia, resuelva primero el de mayor precedencia. Si tienen la misma precedencia se resuelve según asociatividad, es decir, de derecha a izquierda o de izquierda a derecha. La explicación del siguiente programa está bien escrita en los comentarios dentro del propio programa.
Java 
public class operators {  public static void main(String[] args)  {  int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;  // precedence rules for arithmetic operators.  // (* = / = %)>(+ = -) // imprime a+(b/d) System.out.println('a+b/d = ' + (a + b / d));  // si la misma precedencia entonces se siguen // reglas asociativas.  // e/f -> b*d -> a+(b*d) -> a+(b*d)-(e/f) System.out.println('a+b*d-e/f = ' + (a + b * d - e / f));  } }>
   
  Producción  
a+b/d = 20 a+b*d-e/f = 219>
 
    2. Sea un compilador:    
El compilador de nuestros sistemas utiliza una herramienta lex para encontrar la mayor coincidencia al generar tokens. Esto crea un pequeño problema si se pasa por alto. Por ejemplo, considere la declaración    a=b+++c    ; Puede parecer que demasiados lectores crean un error de compilación. Pero esta afirmación es absolutamente correcta ya que el token creado por lex es a, =, b, ++, +, c. Por lo tanto, esta afirmación tiene un efecto similar al asignar primero b+c a a y luego incrementar b. De manera similar, a=b+++++c; generaría un error ya que los tokens generados son a, =, b, ++, ++, +, c. lo cual en realidad es un error ya que no hay ningún operando después del segundo operando unario.
Java 
public class operators {  public static void main(String[] args)  {  int a = 20, b = 10, c = 0;  // a=b+++c is compiled as  // b++ +c  // a=b+c then b=b+1  a = b++ + c;  System.out.println('Value of a(b+c), '  + ' b(b+1), c = ' + a + ', ' + b  + ', ' + c);  // a=b+++++c is compiled as  // b++ ++ +c  // which gives error.  // a=b+++++c;  // System.out.println(b+++++c);  } }>
   
  Producción  
Value of a(b+c), b(b+1), c = 10, 11, 0>
 
    3. Usando + sobre ():    
Cuando se utiliza el operador + dentro      sistema.out.println()      asegúrese de hacer la suma usando paréntesis. Si escribimos algo antes de realizar la suma, entonces se produce la suma de cadenas, es decir, la asociatividad de la suma es de izquierda a derecha y, por lo tanto, los números enteros se agregan a una cadena primero produciendo una cadena, y los objetos de cadena se concatenan cuando se usa +. Por lo tanto, puede crear resultados no deseados.
Java 
public class operators {  public static void main(String[] args)  {  int x = 5, y = 8;  // concatenates x and y as  // first x is added to 'concatenation (x+y) = '  // producing 'concatenation (x+y) = 5'  // and then 8 is further concatenated.  System.out.println('Concatenation (x+y)= ' + x + y);  // addition of x and y  System.out.println('Addition (x+y) = ' + (x + y));  } }>
   
  Producción  
Concatenation (x+y)= 58 Addition (x+y) = 13>
 
Ventajas de los operadores en Java
Las ventajas de utilizar operadores en Java se mencionan a continuación:
 
    expresividad    : Los operadores en Java proporcionan una forma concisa y legible de realizar cálculos complejos y operaciones lógicas.
    Ahorrar tiempo:    Los operadores de Java ahorran tiempo al reducir la cantidad de código necesario para realizar determinadas tareas.
    Desempeño mejorado    : El uso de operadores puede mejorar el rendimiento porque a menudo se implementan a nivel de hardware, lo que los hace más rápidos que el código Java equivalente.
Desventajas de los operadores en Java
Las desventajas de los operadores en Java se mencionan a continuación:
 
    Precedencia del operador:    Los operadores en Java tienen una precedencia definida, lo que puede generar resultados inesperados si no se usan correctamente.
    Tipo Coerción    : Java realiza conversiones de tipos implícitas cuando utiliza operadores, lo que puede generar resultados inesperados o errores si no se usa correctamente.
Preguntas frecuentes sobre operadores de Java
1. ¿Qué son los operadores en Java con un ejemplo?
Los operadores son los símbolos especiales que se utilizan para realizar determinadas operaciones. Por ejemplo, '+' se usa para la suma, donde 5+4 devolverá el valor 9.