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:
- Programa Java para sumar dos números
- 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.
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:
- Programa Java para comprobar si el número es positivo o negativo.
- Programa Java para comprobar si el número es par o impar
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
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:
- Programa Java para encontrar el mayor de tres números utilizando el operador ternario
- 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
= + = – = * = / =% = >> = << = & = ^ = | =