Todos los Operadores en Java con Ejemplos

Basico

Se detalla con ejemplos todos los tipos de operadores que existen en Java. Como por ejemplo: Operadores relacionales, aritméticos, lógicos, de asignación, entre otros.

Java proporciona muchos tipos de operadores que se pueden usar según la necesidad. Se clasifican según la funcionalidad que brindan. Algunos de los tipos son los siguientes:

  • Operadores aritméticos
  • Operadores unarios
  • Operador de asignación
  • Operadores relacionales
  • Operadores lógicos
  • Operador ternario
  • Operadores bit a bit
  • Operadores shift
  • Operador de instancia
  • Precedencia y Asociatividad de Operadores

Vamos a echarles un vistazo en detalle a cada uno de ellos.

1. Operadores aritméticos

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

  • *: Multiplicación
  • /: División
  • %: Modulo
  • +: Adición
  • : Resta

Ejemplo:

// Programa Java para ilustrar
// operadores aritméticos
public class operators
{
  public static void main(String[] args) 
  {
    int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
    String x = "Thank", y = "You";

    // Operador + y - 
    System.out.println("a + b = "+(a + b));
    System.out.println("a - b = "+(a - b));

    // El operador + si se usa con strings
    // concatena las cadenas dadas.
    System.out.println("x + y = "+x + y);

    // Operador * y /
    System.out.println("a * b = "+(a * b));
    System.out.println("a / b = "+(a / b));

    // operador de módulo da el resto
    // de dividir el primer operando con el segundo
    System.out.println("a % b = "+(a % b));

    // si el denominador es 0 en la división
    // System.out.println(a/c);
    // lanzaría una java.lang.ArithmeticException

  }
}

Salida:

a + b = 30
a - b = 10
x + y = ThankYou
a * b = 200
a / b = 2
a % b = 0

2. Operadores unarios

Los operadores unarios solo necesitan un operando. Se usan para incrementar, disminuir o negar un valor.

  • : Unario menos, utilizado para negar los valores.
  • +: Unario más, usado para dar valores positivos. Solo se usa cuando se convierte deliberadamente un valor negativo en positivo.
  • ++: Operador de incremento, utilizado para incrementar el valor en 1. Hay dos variedades de operador de incremento.
  1. Pre-Incremento: el valor se incrementa primero y luego se calcula el resultado.
  2. Post-Incremento: el valor se usa por primera vez para calcular el resultado y luego se incrementa.
  • : Operador de decremento , usado para incrementar el valor en 1. Hay dos variedades de operador de incremento.
  1. Pre-Decremento: el valor se disminuye primero y luego se calcula el resultado.
  2. Post-Decremento: el valor se usa por primera vez para calcular el resultado y luego se disminuye.
  • ! : Operador lógico “no”, utilizado para invertir un valor booleano.

Ejemplo:

// Programa Java para ilustrar
// operadores unarios
public class operators 
{
  public static void main(String[] args) 
  {
    int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
    boolean condition = true;

    // operador de pre-incremento
    // a = a+1 y entonces c = a;
    c = ++a;
    System.out.println("Valor de c (++a) = " + c);

    // operador de post-incremento
    // c=b entonces b=b+1 (b pasa a ser 11)
    c = b++;
    System.out.println("Valor de c (b++) = " + c);

    // operador de pre-decremento
    // d=d-1 entonces c=d
    c = --d;
    System.out.println("Valor de c (--d) = " + c);

    // operador de post-decremento
    // c=e entonces e=e-1 (e pasa a ser 39)
    c = e--;
    System.out.println("Valor de c (e--) = " + c);

    // Operador lógico not
    System.out.println("Valor de !condition = " + !condition);

  }
}

Salida:

Valor de c (++a) = 21
Valor de c (b++) = 10
Valor de c (--d) = 19
Valor de c (e--) = 40
Valor de !condition = false

3. Operador de asignación (=)

El operador de asignación se usa para asignar un valor a cualquier variable. Tiene una asociación 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.

El formato general del operador de asignación es, variable = valor;

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

int a = 5;
a += 5; // a = a + 5;
  • + = , para sumar el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
  • – = , para restar el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
  • * = , para multiplicar el operando izquierdo con el operando derecho y luego asignándolo a la variable de la izquierda.
  • / = , para dividir el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
  • ^ = , para aumentar la potencia del operando izquierdo al operando derecho y asignarlo a la variable de la izquierda.
  • % = , para asignar el módulo del operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.

Ejemplo:

// Programa Java para ilustrar
// Operadores de Asignación
public class operators 
{
    public static void main(String[] args) 
    {
        int a = 20, b = 10, c, d, e = 10, f = 4, g = 9;
 
        // operador de asignación simple
        c = b;
        System.out.println("Valor de c = " + c);
 
        // Esta siguiente declaración arrojaría una exception
        // porque el valor del operando derecho debe ser inicializado
        // antes de la asignación, entonces el programa no
        // compila.
        // c = d;
 
        // operadores de asignación simples
        a = a + 1;
        b = b - 1;
        e = e * 2;
        f = f / 2;
        System.out.println("a,b,e,f = " + a + ","
                           + b + "," + e + "," + f);
        a = a - 1;
        b = b + 1;
        e = e / 2;
        f = f * 2;
 
        // operados de asignación compuestos/cortos
        a += 1;
        b -= 1;
        e *= 2;
        f /= 2;
        System.out.println("a,b,e,f (usando operadores cortos)= " + 
                            a + "," + b + "," + e + "," + f);
    }
}

Salida:

Valor de c = 10
a,b,e,f = 21,9,20,2
a,b,e,f (usando operadores cortos)= 21,9,20,2

4. Operadores relacionales

Estos operadores se utilizan para verificar relaciones como igualdad, mayor que, menor que. Devuelven el resultado booleano después de la comparación y se usan ampliamente en las instrucciones de bucle, así como en las sentencias condicionales if/else. El formato general es, variable operador_relacion valor

Algunos de los operadores relacionales son:

  • ==, Igual a: devuelve verdadero si el valor del lado izquierdo es igual al lado derecho.
  • ! =, No igual a: devuelve verdadero si el valor del lado izquierdo no es igual al lado derecho.
  • <, menos que: el resultado verdadero si el valor del lado izquierdo es inferior al del lado derecho.
  • <=, menor o igual que: devuelve verdadero si el valor del lado izquierdo es menor o igual que el lado derecho.
  • >, Mayor que: devuelve verdadero si el valor del lado izquierdo es mayor que el lado derecho.
  • > =, Mayor que o igual a: regresa verdadero si el valor del lado izquierdo es mayor o igual que el lado derecho.

Ejemplo:

// Programa Java para ilustrar
// operadores relacionales
public class operators 
{
    public static void main(String[] args) 
    {
        int a = 20, b = 10;
        String x = "Thank", y = "Thank";
        int ar[] = { 1, 2, 3 };
        int br[] = { 1, 2, 3 };
        boolean condicion = true;
 
        //varios operadores condicionales
        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));
        System.out.println("a != b :" + (a != b));
 
        // Los Arrays no se pueden comparar con
        // operadores relacionales porque los objetos
        // almacenan referencias, mas no el valor
        System.out.println("x == y : " + (ar == br));
 
        System.out.println("condicion==true :" + (condicion == true));
    }
}

Salida:

a == b :false
a < b :false
a <= b :false
a > b :true
a >= b :true
a != b :true
x == y : false
condicion==true :true

5. Operadores lógicos

Estos operadores se utilizan para realizar operaciones “lógicas AND” y “lógicas OR”, es decir, la función similar a la puerta AND y la puerta OR en 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 usa ampliamente para probar varias condiciones para tomar una decisión.

Los operadores condicionales son:

  • &&, AND lógico: devuelve verdadero cuando ambas condiciones son verdaderas.
  • || , O lógico: devuelve verdadero si al menos una condición es verdadera.

Ejemplo:

// Programa Java para ilustrar
// operadores logicos
import java.util.Scanner;

public class operators 
{
    public static void main(String[] args) 
    {
        String x = "java";
        String y = "desdecero";
 
        Scanner s = new Scanner(System.in);
        System.out.print("Ingrese usuario:");
        String uuid = s.next();
        System.out.print("Ingrese contraseña:");
        String upwd = s.next();
 
        // Verifique si el nombre de usuario y la contraseña coinciden o no.
        if ((uuid.equals(x) && upwd.equals(y)) || 
                (uuid.equals(y) && upwd.equals(x))) {
            System.out.println("Bienvenido usuario.");
        } else {
            System.out.println("ID o Contraseña equivocada");
        }
 
    }
}

Salida:

Ingrese usuario:java
Ingrese contraseña:desdecero
Bienvenido usuario.

6. Operador ternario

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: condicion ? if true : if false

La declaración anterior significa que si la condición se evalúa como verdadera, entonces ejecuta las instrucciones después del ‘?‘ de lo contrario, ejecuta las instrucciones después de ‘:‘.

Ejemplo:

// Programa Java para ilustrar
// el máximo de tres números utilizando
// operador ternario.
public class operators 
{
    public static void main(String[] args) 
    {
        int a = 20, b = 10, c = 30, result;
 
        //el resultado obtiene el máximo de tres
        //numeros
        result = ((a > b) ? (a > c) ? a : 
                   c : (b > c) ? b : c);
        System.out.println("Máximo de tres números = "+result);
    }
}

Salida:

Máximo de tres números = 30

7. Operadores bit a bit

Los operadores a nivel de bits se utilizan para realizar la manipulación de bits individuales de un número. Se pueden usar con cualquiera de los tipos enteros. Se utilizan al realizar operaciones de actualización y consulta de árbol indexado binario.

  • &, Operador bit a bit AND: Si ambos bits de entrada son 1, establece el resultado en 1. De lo contrario da como resultado 0. El resultado binario final se muestra en decimal.
  • | , Operador bit a bit OR: Si al menos uno de los dos bits de entrada es 1, establece el resultado en 1. De lo contrario da como resultado 0. El resultado binario final se muestra en decimal.
  • ^, Operador bit a bit XOR: Si uno de los bits de entrada es 0 y el otro 1, el resultado es 1. Si ambos bits comparados son iguales, el resultado es 0. El resultado binario final se muestra en decimal.
  • ~, Operador bit a bit de complemento (NOT): este es un operador unario que devuelve la representación complementaria del valor de entrada, es decir, con todos los bits invertidos. El resultado binario final se muestra en decimal.

Ejemplo:

// Programa Java para ilustrar
// operadores bit a bit (bitwise)
public class operators 
{
    public static void main(String[] args) 
    {
 
        int a = 0x0005;
        int b = 0x0007;
 
        // bitwise AND
        // 0101 & 0111=0101
        System.out.println("a&b = " + (a & b));
 
        // bitwise or
        // 0101 | 0111=0111
        System.out.println("a|b = " + (a | b));
 
        // bitwise xor
        // 0101 ^ 0111=0010
        System.out.println("a^b = " + (a ^ b));
 
        // bitwise complemento
        // ~0101=1010
        System.out.println("~a = " + ~a);
 
        // también se puede combinar con el
        // operador de asignación
        // a=a&b
        a &= b;
        System.out.println("a= " + a);
    }
}

Salida:

a&b = 5
a|b = 7
a^b = 2
~a = -6
a= 5

8. Operadores shift

Los operadores shift de Java se usan para desplazar los bits de un número hacia la izquierda o hacia la derecha, multiplicando o dividiendo el número por dos, respectivamente. Se pueden usar cuando tenemos que multiplicar o dividir un número por dos.

  • <<, operador de desplazamiento a la izquierda : desplaza los bits del número hacia la izquierda y llena con “0” los bits desplazados. Efecto similar a la multiplicación del número con una potencia de dos.
  • >>, Operador de desplazamiento a la derecha firmado: desplaza los bits del número a la derecha y llena con “0” los bits desplazados. El bit más a la izquierda depende del signo del número inicial. Efecto similar a partir de dividir el número con alguna potencia de dos.
  • >>>, Operador de cambio a la derecha sin signo: desplaza los bits del número a la derecha y llena con “0” los bits desplazados. El bit más a la izquierda se establece en 0.

Ejemplo:

// Programa Java para ilustrar
// operadores shift
public class operators 
{
    public static void main(String[] args) 
    {
 
        int a = 0x0005;
        int b = -10;
 
        // operador de desplazamiento a la izquierda
        // 0000 0101<<2 =0001 0100(20)
        // similar a 5*(2^2)
        System.out.println("a<<2 = " + (a << 2));
 
        // operador de desplazamiento a la derecha
        // 0000 0101 >> 2 =0000 0001(1)
        // similar a 5/(2^2)
        System.out.println("a>>2 = " + (a >> 2));
         
        // operador de cambio a la derecha sin firmar
        System.out.println("b>>>2 = "+ (b >>> 2));
 
    }
}

Salida:

a<<2 = 20
a>>2 = 1
b>>>2 = 1073741821

9. Operador de Instancia (instanceof)

El operador de instancia se usa para verificar el tipo. Se puede usar para probar si un objeto es una instancia de una clase, una subclase o una interfaz.

Formato general:  objecto instanceof class/subclass/interface

Ejemplo:

// Programa Java para ilustrar
// instancia de operador
class operators 
{
    public static void main(String[] args) 
    {
 
        Person obj1 = new Person();
        Person obj2 = new Boy();
 
        // Como obj1 es de tipo Person, no es una
        // instancia de Boy o interfaz
        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));
 
        // Dado que obj2 es de tipo Boy, cuya clase padre es
        // Person e implementa la interfaz Myinterface
        // es una instancia de todas estas clases
        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 
{
 
}

Salida:

obj1 instanceof Person: true
obj1 instanceof Boy: false
obj1 instanceof MyInterface: false
obj2 instanceof Person: true
obj2 instanceof Boy: true
obj2 instanceof MyInterface: true
Nota: No se preocupe si no entiende, lo veremos más adelante en detalle. Sin embargo, es bueno que conozca que existe este tipo de operador. 

10. Precedencia de Operadores

La precedencia y las reglas asociativas se usan cuando se trata de ecuaciones híbridas que involucran a 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 como magnitud, con la parte superior representando la precedencia más alta y la inferior con la prioridad más baja.

Tabla de Precedencia y asociatividad de los operadores en Java.
OperadorAociatividad
++ —De derecha a izquierda
++ — + – !De derecha a izquierda
* / %De derecha a izquierda
+ –De derecha a izquierda
< <= > >=De derecha a izquierda
== !=De derecha a izquierda
&De derecha a izquierda
^De derecha a izquierda
|De derecha a izquierda
&&De derecha a izquierda
||De derecha a izquierda
?:De derecha a izquierda
= += -= *= /= %=De derecha a izquierda

Extra: Secuencias de Escape en Java

Los valores numéricos y de texto en los programas de Java se conocen como “literales”; no representan nada, pero son, literalmente, lo que ves.

Los literales normalmente se desprenden de las palabras clave del lenguaje Java, pero cuando se requieren comillas dobles o comillas simples dentro de un valor de String, es necesario indicar que el carácter de cita debe tratarse LITERALMENTE para evitar terminar prematuramente el String. Esto se logra fácilmente mediante el prefijo inmediato de cada carácter de comillas anidado con el operador de escape \.

Me explico mejor con el siguiente ejemplo:

String cita = " \"Java debe ser un territorio neutral, la Suiza de la tecnología informática.\"dijo James Gosling";

Además, el operador de escape \ ofrece una variedad de secuencias de escape muy útiles como son los siguientes:

Tabla de Secuencias de Escape en Java.
EscapeDescripción
\nNueva Linea.
\tTabulador.
\bBackspace
\rRetorno del carro.
\fForm feed.
\\Barra invertida (\)
\’Comilla simple
\”Comilla doble
Nota: Tanto \r como \f son caracteres de control de terminal o impresora y no tienen ningún significado en Java.

Ejemplo de Escape:

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

        String cabecera = "\n\tPRONOSTICO DE CLIMA:\n" ;
        cabecera += "\n\tDia\t\tMañana\tNoche\tCondiciones\n" ;
        cabecera += "\t---\t\t-------\t----\t-----------\n" ;

        String pronostico = "\tDomingo\t25C\t\t23C\t\tSoleado\n";
        pronostico += "\tLunes\t24C\t\t19C\t\tSoleado\n";
        pronostico += "\tMartes\t26C\t\t15C\t\tNublado\n";

        System.out.print(cabecera+pronostico) ;
    }
}

Salida:

Ejemplo de Escape en Java
Ejemplo de Escape en Java

Puede consultar más información en la Documentación Oficial de Java, o, dejarnos un comentario con cualquiera de sus dudas 🙂

Operadores en Java
  • 10/10
    Operadores con Ejemplos - 10/10
10/10

Resumen

Se detalla con ejemplos los Operadores aritméticos, Operadores unarios, Operador de asignación, Operadores relacionales, Operadores lógicos, Operador ternario, Operadores bit a bit, Operadores shift, Operador de instancia y finalmente la Precedencia y Asociatividad de Operadores.

Sobre el Autor:

Hey hola! Yo soy Alex Walton y tengo el placer de compartir conocimientos hacía ti sobre el tema de Programación en Java, desde cero, Online y Gratis.

Deja una Respuesta

*

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.