Un operador es un personaje que representa una acción, por ejemplo, + es un operador aritmético que representa la suma.

Tipos de operadores en Java

1) Operadores aritméticos básicos
2) Operadores de asignación
3) Operadores automáticos de incremento y decremento
4) Operadores lógicos
5) Operadores de comparación (relacionales)
6) operadores bit a bit
7) Operador ternario

1) Operadores aritméticos básicos

Los operadores aritméticos básicos son: +, -, *, /,%
+ es para añadir.

es para restar.

* es para multiplicar.

/ es para la división.

% es por módulo.
Nota: El operador de módulo devuelve el resto, por ejemplo, 10% 5 devolverá 0

Ejemplo de operadores aritméticos

public class ArithmeticOperatorDemo {
   public static void main(String args[]) {
      int num1 = 100;
      int num2 = 20;

      System.out.println("num1 + num2: " + (num1 + num2) );
      System.out.println("num1 - num2: " + (num1 - num2) );
      System.out.println("num1 * num2: " + (num1 * num2) ); 
      System.out.println("num1 / num2: " + (num1 / num2) );
      System.out.println("num1 % num2: " + (num1 % num2) );
   }
}

Producción:

num1 + num2: 120
num1 - num2: 80
num1 * num2: 2000
num1 / num2: 5
num1 % num2: 0

Consulte estos programas de Java relacionados con los operadores aritméticos en Java:

  1. Programa Java para sumar dos números
  2. Programa Java para multiplicar dos números

2) Operadores de asignación

Los operadores de asignación en Java son: =, + =, – =, * =, / =,% =
num2 = num1 asignaría el valor de la variable num1 a la variable.

num2 + = num1 es igual a num2 = num2 + num1

num2- = num1 es igual a num2 = num2-num1

num2 * = num1 es igual a num2 = num2 * num1

num2 / = num1 es igual a num2 = num2 / num1

num2% = num1 es igual a num2 = num2% num1

Ejemplo de operadores de asignación

public class AssignmentOperatorDemo {
   public static void main(String args[]) {
      int num1 = 10;
      int num2 = 20;

      num2 = num1;
      System.out.println("= Output: "+num2);

      num2 += num1;
      System.out.println("+= Output: "+num2);
	      
      num2 -= num1;
      System.out.println("-= Output: "+num2);
	      
      num2 *= num1;
      System.out.println("*= Output: "+num2);
	      
      num2 /= num1;
      System.out.println("/= Output: "+num2);
	      
      num2 %= num1;
      System.out.println("%= Output: "+num2);
   }
}

Producción:

= Output: 10
+= Output: 20
-= Output: 10
*= Output: 100
/= Output: 10
%= Output: 0

3) Operadores automáticos de incremento y decremento

++ y –
num ++ es equivalente a num=num+1;

num–- es equivalente a num=num-1;

Ejemplo de operadores de incremento y decremento automáticos

public class AutoOperatorDemo {
   public static void main(String args[]){
      int num1=100;
      int num2=200;
      num1++;
      num2--;
      System.out.println("num1++ is: "+num1);
      System.out.println("num2-- is: "+num2);
   }
}

Producción:

num1++ is: 101
num2-- is: 199

4) Operadores lógicos

Los operadores lógicos se utilizan con variables binarias. Se utilizan principalmente en declaraciones condicionales y bucles para evaluar una condición.

leer  Tipos de datos en Java

Los operadores lógicos en java son: &&, ||,!

Suponga que tenemos dos variables booleanas b1 y b2.

b1 && b2 devolverá verdadero si tanto b1 como b2 son verdaderos; de lo contrario, devolverá falso.

b1 || b2 devolverá falso si b1 y b2 son falsos, de lo contrario devolverá verdadero.

! b1 devolvería lo contrario de b1, lo que significa que sería verdadero si b1 es falso y devolvería falso si b1 es verdadero.

Ejemplo de operadores lógicos

public class LogicalOperatorDemo {
   public static void main(String args[]) {
      boolean b1 = true;
      boolean b2 = false;

      System.out.println("b1 && b2: " + (b1&&b2));
      System.out.println("b1 || b2: " + (b1||b2));
      System.out.println("!(b1 && b2): " + !(b1&&b2));
   }
}

Producción:

b1 && b2: false
b1 || b2: true
!(b1 && b2): true

5) Operadores de comparación (relacionales)

Tenemos seis operadores relacionales en Java: ==,! =,>, <,> =, <=

== devuelve verdadero si los lados izquierdo y derecho son iguales

! = devuelve verdadero si el lado izquierdo no es igual al lado derecho del operador.

> devuelve verdadero si el lado izquierdo es mayor que el lado derecho.

< devuelve verdadero si el lado izquierdo es más pequeño que el lado derecho.

> = devuelve verdadero si el lado izquierdo es mayor o igual que el lado derecho.

<= devuelve verdadero si el lado izquierdo es menor o igual que el lado derecho.

Ejemplo de operadores relacionales

Nota: Este ejemplo usa la declaración if-else, que es nuestro próximo tutorial, si tiene problemas para entender, consulte if-else en Java.

public class RelationalOperatorDemo {
   public static void main(String args[]) {
      int num1 = 10;
      int num2 = 50;
      if (num1==num2) {
	 System.out.println("num1 and num2 are equal");
      }
      else{
	 System.out.println("num1 and num2 are not equal");
      }

      if( num1 != num2 ){
	 System.out.println("num1 and num2 are not equal");
      }
      else{
	 System.out.println("num1 and num2 are equal");
      }

      if( num1 > num2 ){
	 System.out.println("num1 is greater than num2");
      }
      else{
	 System.out.println("num1 is not greater than num2");
      }

      if( num1 >= num2 ){
	 System.out.println("num1 is greater than or equal to num2");
      }
      else{
	 System.out.println("num1 is less than num2");
      }

      if( num1 < num2 ){
	 System.out.println("num1 is less than num2");
      }
      else{
	 System.out.println("num1 is not less than num2");
      }

      if( num1 <= num2){
	 System.out.println("num1 is less than or equal to num2");
      }
      else{
	 System.out.println("num1 is greater than num2");
      }
   }
}

Producción:

num1 and num2 are not equal
num1 and num2 are not equal
num1 is not greater than num2
num1 is less than num2
num1 is less than num2
num1 is less than or equal to num2

Consulte estos programas Java relacionados relacionados con los operadores relacionales:

  1. Programa Java para comprobar si el número es positivo o negativo.
  2. Programa Java para comprobar si el número es par o impar
leer  Cómo compilar y ejecutar su primer programa Java

6) operadores bit a bit

Hay seis operadores bit a bit: &, |, ^, ~,<, >>

num1 = 11; / * igual a 00001011 * /
num2 = 22; / * igual a 00010110 * /

El operador bit a bit realiza el procesamiento bit a bit.
num1 y num2 compara los bits correspondientes de num1 y num2 y genera 1 si ambos bits son iguales, de lo contrario devuelve 0. En nuestro caso devolvería: 2 que es 00000010 porque en la forma binaria de num1 y num2 solo los penúltimos bits coinciden.

num1 | num2 compara los bits correspondientes de num1 y num2 y genera 1 si uno de los dos bits es 1, de lo contrario devuelve 0. En nuestro caso, devolvería 31 que es 00011111

num1 ^ num2 compara los bits correspondientes de num1 y num2 y genera 1 si no son iguales, de lo contrario devuelve 0. En nuestro ejemplo, devolvería 29 que es equivalente a 00011101

~ num1 es un operador de complemento que simplemente cambia el bit de 0 a 1 y de 1 a 0. En nuestro ejemplo, devolvería -12, que tiene un signo de 8 bits equivalente a 11110100

num1 << 2 es el operador de desplazamiento a la izquierda que desplaza los bits a la izquierda, descarta el bit más a la izquierda y asigna al bit más a la derecha un valor de 0. En nuestro caso, la salida es 44 que es equivalente a 00101100

Nota: En el siguiente ejemplo, proporcionamos 2 en el lado derecho de este operador de cambio, por lo que los bits se desplazan dos lugares en el lado izquierdo. Podemos cambiar este número y los bits se desplazarán según el número de bits especificado en el lado derecho del operador. Lo mismo ocurre con el operador del lado derecho.

num1 >> 2 es un operador de desplazamiento a la derecha que desplaza los bits a la derecha, descarta el bit más a la derecha y asigna al bit más a la izquierda un valor de 0. En nuestro caso, la salida es 2, que es equivalente a 00000010

leer  Declaración de ruptura en Java con ejemplo

Ejemplo de operadores bit a bit

public class BitwiseOperatorDemo {
  public static void main(String args[]) {

     int num1 = 11;  /* 11 = 00001011 */
     int num2 = 22;  /* 22 = 00010110 */
     int result = 0;

     result = num1 & num2;   
     System.out.println("num1 & num2: "+result);

     result = num1 | num2;   
     System.out.println("num1 | num2: "+result);
    
     result = num1 ^ num2;   
     System.out.println("num1 ^ num2: "+result);
    
     result = ~num1;   
     System.out.println("~num1: "+result);
    
     result = num1 << 2;   
     System.out.println("num1 << 2: "+result); result = num1 >> 2;   
     System.out.println("num1 >> 2: "+result);
  }
}

Producción:

num1 & num2: 2
num1 | num2: 31
num1 ^ num2: 29
~num1: -12
num1 << 2: 44 num1 >> 2: 2

Echa un vistazo a este programa: programa Java para intercambiar dos números utilizando el operador bit a bit

7) Operador ternario

Este operador evalúa una expresión booleana y asigna el valor según el resultado.
Sintaxis:

variable num1 = (expression) ? value if true : value if false

Si la expresión es verdadera, el primer valor antes de los dos puntos (:) se asigna a la variable num1; de lo contrario, el segundo valor se asigna a num1.

Ejemplo de un operador ternario

public class TernaryOperatorDemo {

   public static void main(String args[]) {
        int num1, num2;
        num1 = 25;
        /* num1 is not equal to 10 that's why
	 * the second value after colon is assigned
	 * to the variable num2
	 */
	num2 = (num1 == 10) ? 100: 200;
	System.out.println( "num2: "+num2);

	/* num1 is equal to 25 that's why
	 * the first value is assigned
	 * to the variable num2
	 */
	num2 = (num1 == 25) ? 100: 200;
	System.out.println( "num2: "+num2);
   }
}

Producción:

num2: 200
num2: 100

Consulte estos programas Java relacionados:

  1. Programa Java para encontrar el mayor de tres números utilizando el operador ternario
  2. Programa Java para encontrar el menor de tres números usando el operador ternario

Precedencia de operadores en Java

Esto determina qué operador debe evaluarse primero si una expresión tiene más de un operador. Operador con mayor precedencia en la parte superior e inferior con precedencia en la parte inferior.
Operadores unarios
++ – -! ~

Multiplicativo
* /%

Aditivo
+ –

Intercambio
<< >> >>>

Relacional
>> = << =

Igualdad
==! =

Y bit a bit
Y

XOR bit a bit
^

O bit a bit
|

Y lógico
&&

OR lógico
||

Ternario
?:

Asignación
= + = – = * = / =% = >> = << = & = ^ = | =

Por avivcas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *