Operadores Java

En este tutorial, aprenderá sobre diferentes tipos de operadores en Java, su sintaxis y cómo usarlos con la ayuda de ejemplos.

Los operadores son símbolos que realizan operaciones en variables y valores. Por ejemplo, + es un operador usado para la suma, mientras que * también es un operador usado para la multiplicación.

Los operadores en Java se pueden clasificar en 5 tipos:

Operadores aritméticos
Operadores de asignación
Operadores relacionales
Operadores lógicos
Operadores unarios
Operadores bit a bit

1. Operadores aritméticos de Java

Los operadores aritméticos se utilizan para realizar operaciones aritméticas en variables y datos. Por ejemplo,

a + b;

Aquí, el + El operador se usa para agregar dos variables a y b . Del mismo modo, hay varios otros operadores aritméticos en Java.

Operador	Operación
`+`	Adición
`-`	Sustracción
`*`	Multiplicación
`/`	División
`%`	Operación de módulo (resto después de la división)

Ejemplo 1:Operadores aritméticos

class Main {
  public static void main(String[] args) {
    
    // declare variables
    int a = 12, b = 5;

    // addition operator
    System.out.println("a + b = " + (a + b));

    // subtraction operator
    System.out.println("a - b = " + (a - b));

    // multiplication operator
    System.out.println("a * b = " + (a * b));

    // division operator
    System.out.println("a / b = " + (a / b));

    // modulo operator
    System.out.println("a % b = " + (a % b));
  }
}

Salida

a + b = 17
a - b = 7 
a * b = 60
a / b = 2 
a % b = 2

En el ejemplo anterior, hemos usado + , - y * operadores para calcular operaciones de suma, resta y multiplicación.

/ Operador de división

Tenga en cuenta la operación, a / b en nuestro programa. El / operador es el operador de división.

Si usamos el operador de división con dos números enteros, entonces el cociente resultante también será un número entero. Y, si uno de los operandos es un número de coma flotante, obtendremos el resultado también en coma flotante.

In Java,

(9 / 2) is 4
(9.0 / 2) is 4.5
(9 / 2.0) is 4.5
(9.0 / 2.0) is 4.5

Operador de módulo %

El operador módulo % calcula el resto. Cuando a = 7 se divide por b = 4 , el resto es 3 .

Nota :El % El operador se usa principalmente con números enteros.

2. Operadores de asignación de Java

Los operadores de asignación se utilizan en Java para asignar valores a las variables. Por ejemplo,

int age;
age = 5;

Aquí, = es el operador de asignación. Asigna el valor de su derecha a la variable de su izquierda. Es decir, 5 se asigna a la variable edad .

Veamos algunos operadores de asignación más disponibles en Java.

Operador	Ejemplo	Equivalente a
`=`	`a = b;`	`a = b;`
`+=`	`a += b;`	`a = a + b;`
`-=`	`a -= b;`	`a = a - b;`
`*=`	`a *= b;`	`a = a * b;`
`/=`	`a /= b;`	`a = a / b;`
`%=`	`a %= b;`	`a = a % b;`

Ejemplo 2:Operadores de asignación

class Main {
  public static void main(String[] args) {
    
    // create variables
    int a = 4;
    int var;

    // assign value using =
    var = a;
    System.out.println("var using =: " + var);

    // assign value using =+
    var += a;
    System.out.println("var using +=: " + var);

    // assign value using =*
    var *= a;
    System.out.println("var using *=: " + var);
  }
}

Salida

var using =: 4
var using +=: 8 
var using *=: 32

3. Operadores relacionales de Java

Los operadores relacionales se utilizan para comprobar la relación entre dos operandos. Por ejemplo,

// check if a is less than b
a < b;

Aquí, < operador es el operador relacional. Comprueba si a es menor que b o no.

Devuelve true o false .

Operador	Descripción	Ejemplo
`==`	es igual a	`3 == 5` devuelve falso
`!=`	No es igual a	`3 != 5` devuelve verdadero
`>`	Mayor que	`3 > 5` devuelve falso
`<`	Menor que	`3 < 5` devuelve verdadero
`>=`	Mayor o igual que	`3 >= 5` devuelve falso
`<=`	Menor o igual que	`3 <= 5` devuelve verdadero

Ejemplo 3:Operadores relacionales

class Main {
  public static void main(String[] args) {
    
    // create variables
    int a = 7, b = 11;

    // value of a and b
    System.out.println("a is " + a + " and b is " + b);

    // == operator
    System.out.println(a == b);  // false

    // != operator
    System.out.println(a != b);  // true

    // > operator
    System.out.println(a > b);  // false

    // < operator
    System.out.println(a < b);  // true

    // >= operator
    System.out.println(a >= b);  // false

    // <= operator
    System.out.println(a <= b);  // true
  }
}

Nota :Los operadores relacionales se utilizan en la toma de decisiones y bucles.

4. Operadores lógicos Java

Los operadores lógicos se utilizan para verificar si una expresión es true o false . Se utilizan en la toma de decisiones.

Operador	Ejemplo	Significado
`&&` (Y lógico)	expresión1 && expresión2	`true` solo si ambos `expresión1` y `expresión2` son `true`
`\|\|` (OR lógico)	expresión1 \|\| expresión2	`true` si `expresión1` o `expresión2` es `true`
`!` (NO lógico)	! expresión	`true` si `expresión` es `false` y viceversa

Ejemplo 4:Operadores Lógicos

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

    // && operator
    System.out.println((5 > 3) && (8 > 5));  // true
    System.out.println((5 > 3) && (8 < 5));  // false

    // || operator
    System.out.println((5 < 3) || (8 > 5));  // true
    System.out.println((5 > 3) || (8 < 5));  // true
    System.out.println((5 < 3) || (8 < 5));  // false

    // ! operator
    System.out.println(!(5 == 3));  // true
    System.out.println(!(5 > 3));  // false
  }
}

Funcionamiento del programa

(5 > 3) && (8 > 5) devuelve true porque ambos (5 > 3) y (8 > 5) son true .
(5 > 3) && (8 < 5) devuelve false porque la expresión (8 < 5) es false .
(5 < 3) || (8 > 5) devuelve true porque la expresión (8 > 5) es true .
(5 > 3) && (8 > 5) devuelve true porque la expresión (5 > 3) es true .
(5 > 3) && (8 > 5) devuelve false porque ambos (5 < 3) y (8 < 5) son false .
!(5 == 3) devuelve verdadero porque 5 == 3 es false .
!(5 > 3) devuelve falso porque 5 > 3 es true .

5. Operadores unarios de Java

Los operadores unarios se utilizan con un solo operando. Por ejemplo, ++ es un operador unario que incrementa el valor de una variable en 1 . Es decir, ++5 devolverá 6 .

Los diferentes tipos de operadores unarios son:

Operador	Significado
`+`	Más unario :no es necesario usarlo ya que los números son positivos sin usarlo
`-`	Menos unario :invierte el signo de una expresión
`++`	Operador de incremento :incrementa el valor en 1
`--`	Operador de decremento :decrementa el valor en 1
`!`	Operador de complemento lógico :invierte el valor de un booleano

Operadores de incremento y decremento

Java también proporciona operadores de incremento y decremento:++ y -- respectivamente. ++ aumenta el valor del operando en 1 , mientras que -- disminuirlo en 1 . Por ejemplo,

int num = 5;

// increase num by 1
++num;

Aquí, el valor de num aumenta a 6 de su valor inicial de 5 .

Ejemplo 5:Operadores de incremento y decremento

class Main {
  public static void main(String[] args) {
    
    // declare variables
    int a = 12, b = 12;
    int result1, result2;

    // original value
    System.out.println("Value of a: " + a);

    // increment operator
    result1 = ++a;
    System.out.println("After increment: " + result1);

    System.out.println("Value of b: " + b);

    // decrement operator
    result2 = --b;
    System.out.println("After decrement: " + result2);
  }
}

Salida

Value of a: 12
After increment: 13
Value of b: 12     
After decrement: 11

En el programa anterior, hemos usado los operadores ++ y -- como prefijos (++a, --b) . También podemos usar estos operadores como postfix (a++, b++) .

Hay una ligera diferencia cuando estos operadores se usan como prefijo y cuando se usan como sufijo.

Para obtener más información sobre estos operadores, visite Operadores de incremento y decremento.

6. Operadores bit a bit de Java

Los operadores bit a bit en Java se utilizan para realizar operaciones en bits individuales. Por ejemplo,

Bitwise complement Operation of 35

35 = 00100011 (In Binary)

~ 00100011 
  ________
   11011100  = 220 (In decimal)

Aquí, ~ es un operador bit a bit. Invierte el valor de cada bit (0 a 1 y 1 a 0 ).

Los diversos operadores bit a bit presentes en Java son:

Operador	Descripción
`~`	Complemento bit a bit
`<<`	Desplazamiento a la izquierda
`>>`	Desplazamiento a la derecha
`>>>`	Desplazamiento a la derecha sin firmar
`&`	Bitbit Y
`^`	Exclusivo bit a bit O

Estos operadores generalmente no se usan en Java. Para obtener más información, visite Operadores Java Bitwise y Bit Shift.

Otros operadores

Además de estos operadores, existen otros operadores adicionales en Java.

Operador de instancia de Java

El instanceof El operador comprueba si un objeto es una instancia de una clase particular. Por ejemplo,

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

    String str = "Programiz";
    boolean result;

    // checks if str is an instance of
    // the String class
    result = str instanceof String;
    System.out.println("Is str an object of String? " + result);
  }
}

Salida

Is str an object of String? true

Aquí, str es una instancia del String clase. Por lo tanto, el instanceof el operador devuelve true . Para obtener más información, visite instancia de Java.

Operador ternario de Java

El operador ternario (operador condicional) es la abreviatura de if-then-else declaración. Por ejemplo,

variable = Expression ? expression1 : expression2

Así es como funciona.

Si el Expression es true , expression1 se asigna a la variable .
Si el Expression es false , expression2 se asigna a la variable .

Veamos un ejemplo de un operador ternario.

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

    int februaryDays = 29;
    String result;

    // ternary operator
    result = (februaryDays == 28) ? "Not a leap year" : "Leap year";
    System.out.println(result);
  }
}

Salida

Leap year

En el ejemplo anterior, hemos utilizado el operador ternario para comprobar si el año es bisiesto o no. Para obtener más información, visite el operador ternario de Java.

Ahora que conoce los operadores de Java, es hora de conocer el orden en que se evalúan los operadores. Para obtener más información, visite Precedencia de operadores de Java.

Tipos de datos Java (primitivos) Entrada y salida básica de Java

Java