Operadores de Java – Parte 1

Nube Colectiva

hace 4 años

Java se encuentra entre los Lenguajes de Programación más potentes del medio, ojo no estoy diciendo que es el único, porque hay otros lenguajes como Python, C#, etc. En muchas ocasiones debemos saber que operadores usar en Java, hay muchos problemas en el código que podemos solucionarlo haciendo uso de estos operadores y en este Post te compartiré los operadores con los que cuenta Java, te mostraré algunos ejemplos y otros detalles.

Partes

Parte 1
Parte 2 (Final)

Antes de continuar te invito a leer los siguientes artículos:

Que es Java y otros Detalles
Los 6 mejores IDEs para programar en Java en este 2020
Top de los 5 mejores Frameworks para el Desarrollo de Aplicaciones Web con Java
Como eliminar el primero elemento de un ArrayList en Java
Puedes leer más artículos en la categoría Java

Asimismo te invito a escuchar el Podcast: “Con Que Lenguaje De Programación Comenzar Para El Desarrollo Web”:

Spotify:	Sound Cloud:

Bien ahora continuemos con el Post: Operadores de Java – Parte 1.

Los operadores en Java se utilizan en la mayoría de casos para realizar operaciones entre variables y valores determinados, podemos realizar operaciones básicas como sumar, restar, multiplicar y dividir, pero hay ocasiones en que necesitamos realizar otro tipo de operaciones o tareas, para eso existen otros tipos de operadores.

En Java los operadores se dividen en Operadores aritméticos, Operadores de Asignación, Operadores de comparación, Operadores lógicos y Operadores bit a bit, veamos todos ellos a continuación.

Operadores Aritméticos

Estos tipos de operadores nos permiten realizar operaciones matemáticas esenciales.

Operador de suma (+)

Este operador permite sumar 2 o más valores, veamos el siguiente ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    int b = 10;
    System.out.println(a + b);
  }
} 

// Devuelve 
25

public class MiClase {

public static void main(String[] args) {

int a = 15;

int b = 10;

System.out.println(a + b);

}

// Devuelve

Operador de resta (-)

Este operador nos permite restar valores en Java, veamos el siguiente ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    int b = 10;
    System.out.println(a - b);
  }
} 

// Devuelve 
5

public class MiClase {

public static void main(String[] args) {

int a = 15;

int b = 10;

System.out.println(a - b);

}

// Devuelve

Operador de multiplicación (*)

Con este operador podemos realizar multiplicaciones entre elementos, veamos el siguiente ejemplo para entender mejor como funciona.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    int b = 10;
    System.out.println(a * b);
  }
} 

// Devuelve 
150

public class MiClase {

public static void main(String[] args) {

int a = 15;

int b = 10;

System.out.println(a * b);

}

// Devuelve

150

Operador de división (/)

Con este operador podemos dividir 2 valores en Java, veamos el siguiente ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 21;
    int b = 7;
    System.out.println(a / b); 
  }
} 

// Devuelve 
3

public class MiClase {

public static void main(String[] args) {

int a = 21;

int b = 7;

System.out.println(a / b);

}

// Devuelve

Operador de módulo (%)

Este operador calcula el resto después de dividir el primer valor con otro segundo valor, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    int b = 10;
    System.out.println(a % b); 
  }
} 

// Devuelve 
5

public class MiClase {

public static void main(String[] args) {

int a = 15;

int b = 10;

System.out.println(a % b);

}

// Devuelve

Operador de incremento (++)

Este operador permite aumentar el valor de una variable en 1, veamos el siguiente ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 6;
    ++a;
    System.out.println(a);
  }
} 

// Devuelve 
7

public class MiClase {

public static void main(String[] args) {

int a = 6;

++a;

System.out.println(a);

}

// Devuelve

Operador de decremento (–)

Este operador hace lo contrario del operador anterior, permite disminuir el valor de una variable en 1, veamos el siguiente ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 6;
    --a;
    System.out.println(a);
  }
} 

// Devuelve 
5

public class MiClase {

public static void main(String[] args) {

int a = 6;

--a;

System.out.println(a);

}

// Devuelve

Todos estos son los operadores aritméticos que podemos usar en Java, pasemos al siguiente grupo de operadores.

Operadores de asignación

Este tipo de operadores se suelen utilizar para asignar valores a las variables en Java.

Operador (=)

Este operador nos permite asignar un determinado valor a una variable, veamos el ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    System.out.println(a);
  }
} 

// El resultado lo asignamos al valor de la variable 'a' 
int a = 15

public class MiClase {

public static void main(String[] args) {

int a = 15;

System.out.println(a);

}

// El resultado lo asignamos al valor de la variable 'a'

int a = 15

Operador (+=)

Este operador suma el valor del lado izquierdo con el derecho y asigna un nuevo valor a la variable, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    a += 10;
    System.out.println(a);
  }
} 

// El resultado lo asignamos al valor de la variable 'a' 
a = 25

public class MiClase {

public static void main(String[] args) {

int a = 15;

a += 10;

System.out.println(a);

}

// El resultado lo asignamos al valor de la variable 'a'

a = 25

Operador (-=)

Este operador resta el valor del lado izquierdo con el derecho y asigna el resultado como valor a la variable.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    a -= 10;
    System.out.println(a);
  }
} 

// El resultado lo asignamos al valor de a variable 'a'  
a = 5

public class MiClase {

public static void main(String[] args) {

int a = 15;

a -= 10;

System.out.println(a);

}

// El resultado lo asignamos al valor de a variable 'a'

a = 5

Operador *=

Con este operador multiplicamos el valor derecho con el izquierdo y el resultado será el valor de la variable, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    a *= 10;
    System.out.println(a);
  }
} 

// El resultado lo asignamos al valor de la variable 'a'  
a = 150

public class MiClase {

public static void main(String[] args) {

int a = 15;

a *= 10;

System.out.println(a);

}

// El resultado lo asignamos al valor de la variable 'a'

a = 150

Operador /=

Con este operador realizamos una división de 2 valores y el resultado sera el valor de la variable.


public class MiClase {
  public static void main(String[] args) {
    int a = 21;
    a /= 7;
    System.out.println(a);
  }
} 

// El resultado lo asignamos al valor de la variable 'a' 
a = 3

public class MiClase {

public static void main(String[] args) {

int a = 21;

a /= 7;

System.out.println(a);

}

// El resultado lo asignamos al valor de la variable 'a'

a = 3

Operador %=

Con este operador se calcula el resto después de dividir el primer valor con otro segundo valor, y ese resultado se asigna como valor a una variable, veamos un ejemplo.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    a /= 10;
    System.out.println(a);
  }
} 

// El resultado lo asignamos al valor de la variable 'a' 
a = 5

public class MiClase {

public static void main(String[] args) {

int a = 15;

a /= 10;

System.out.println(a);

}

// El resultado lo asignamos al valor de la variable 'a'

a = 5

Operador &=

Si lo consideramos como un operador Bitwise o de Bits, es el Operador AND, establece cada bit en 1 si ambos bits son 1 y el resultado es asignado como valor de la variable.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    a &= 10; 
    System.out.println(Integer.toBinaryString(a));
  }
} 

// El resultado lo asignamos al valor de la variable 'a' 
a = 1010

public class MiClase {

public static void main(String[] args) {

int a = 15;

a &= 10;

System.out.println(Integer.toBinaryString(a));

}

// El resultado lo asignamos al valor de la variable 'a'

a = 1010

Operador |=

Si lo consideramos como un operador Bitwise o de Bits, es el Operador OR, establece cada bit en 1 si alguno de los dos bits es 1 y el resultado es asignado como valor de la variable.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    a |= 10; 
    System.out.println(Integer.toBinaryString(a));
  }
} 

// El resultado lo asignamos al valor de la variable 'a' 
a = 1111

public class MiClase {

public static void main(String[] args) {

int a = 15;

a |= 10;

System.out.println(Integer.toBinaryString(a));

}

// El resultado lo asignamos al valor de la variable 'a'

a = 1111

Operador ^=

Si lo consideramos como un operador Bitwise o de Bits, es el Operador XOR, establece cada bit en 1 si solo uno de los dos bits es 1 y el resultado es asignado como valor de la variable.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    a ^= 10; 
    System.out.println(Integer.toBinaryString(a));
  }
} 

// El resultado lo asignamos al valor de la variable 'a' 
a = 101

public class MiClase {

public static void main(String[] args) {

int a = 15;

a ^= 10;

System.out.println(Integer.toBinaryString(a));

}

// El resultado lo asignamos al valor de la variable 'a'

a = 101

Operador >>=

Si lo consideramos como un operador Bitwise o de Bits, este operador cambia a la derecha empujando copias del bit más a la izquierda desde la izquierda y dejando caer los bits más a la derecha y el resultado es asignado como valor de la variable.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    a >>= 10; 
    System.out.println(Integer.toBinaryString(a));
  }
} 

// El resultado lo asignamos al valor de la variable 'a' 
a = 0

public class MiClase {

public static void main(String[] args) {

int a = 15;

a >>= 10;

System.out.println(Integer.toBinaryString(a));

}

// El resultado lo asignamos al valor de la variable 'a'

a = 0

Operador <<=

Si lo consideramos como un operador Bitwise o de Bits, este operador desplaza hacia la izquierda presionando ceros desde la derecha y dejando caer los bits más a la izquierda y el resultado es asignado como valor de la variable.


public class MiClase {
  public static void main(String[] args) {
    int a = 15;
    a <<= 10; 
    System.out.println(Integer.toBinaryString(a));
  }
} 

// El resultado lo asignamos al valor de la variable 'a' 
a = 11110000000000

public class MiClase {

public static void main(String[] args) {

int a = 15;

a <<= 10;

System.out.println(Integer.toBinaryString(a));

}

// El resultado lo asignamos al valor de la variable 'a'

a = 11110000000000

Bueno estos son los 2 primeros grupos de operadores de Java.

Nota(s)

En la siguiente parte continuaremos revisando otros operadores de Java.
No olvides que debemos usar la Tecnología para hacer cosas Buenas por el Mundo.

Síguenos en nuestras Redes Sociales para que no te pierdas nuestros próximos contenido.