Operadores En Kotlin

En este tutorial, aprenderás acerca de los operadores en Kotlin y cómo usarlos para crear expresiones con variables.

Operadores De Signo

Comenzamos con los operadores unarios que representan la propiedad de un número de ser negativo, representado por -, o positivo, representado por +.

Operador	Expresión	Función equivalente
+	+a	a.unaryPlus()
-	-a	a.unaryMinus()

Ejemplo: Negar una variable con el valor de -3

fun main() {
    val a = -3

    println("a=${-a}")
}

Por ley de signos la salida será:

a=3

Operadores Aritméticos

Te permiten expresar operaciones aritméticas entre dos operandos.

Operador	Operación	Expresión	Función Equivalente
+	Suma	a+b	a.plus(b)
-	Resta	a-b	a.minus(b)
*	Multiplicación	a*b	a.times(b)
/	División	a/b	a.div(b)
%	Residuo	a%b	a.rem(b)

Ejemplo: Imprimir el resultado de todas las operaciones aritméticas con los números 10 y 20.

fun main() {
    val a = 10
    val b = 20

    println("($a + $b)= ${a + b}")
    println("($a - $b)= ${a - b}")
    println("($a x $b)= ${a * b}")
    println("($a / $b)= ${a / b}")
    println("($a % $b)= ${a % b}")
}

El resultado sería:

(10 + 20)= 30
(10 - 20)= -10
(10 x 20)= 200
(10 / 20)= 0
(10 % 20)= 10

Como ves, al dividir dos enteros, se conserva la parte entera como resultado y se descartan lo decimales.

Operadores De Asignación Compuesta

Estos operadores son la combinación entre el operador de asignación y los operadores aritméticos, con el fin de usar como operando la variable de resultado.

Por ejemplo: si quieres acumular el valor de b en a, la abreviación para el operador compuesto de suma es la siguiente:

a += b // a = a + b

De esta manera, la siguiente tabla resume a los demás:

Operador	Expresión simplificada	Expresión Completa	Función Equivalente
+=	a+=b	a=a+b	a.plusAssign(b)
-=	a-=b	a=a-b	a.minusAssign(b)
*=	a*=b	a=a*b	a.timesAssign(b)
/=	a/=b	a=a/b	a.divAssign(b)
%=	a%=b	a=a%b	a.remAssign(b)

Ejemplo: Aplicar todos los operadores de asignación compuesta con un operando de 5 sobre un valor de 100. Al final imprimir el resultado.

fun main() {
    var a = 100
    val b = 5

    a += b
    println("+= $a")
    a -= b
    println("-= $a")
    a *= b
    println("*= $a")
    a /= b
    println("/= $a")
    a %= b
    println("%= $a")

}

La salida de la ejecución será:

+= 105
-= 100
*= 500
/= 100
%= 0

Operadores De Incremento Y Decremento

El operador de incremento, representado por dos signos de suma (++), incrementa en la unidad al operando.

monstersKilled++

Análogamente, el operador de decremento, doble signo menos (--), disminuye en la unidad al operando.

hearts--

El incremento depende de si el operador es prefijo o sufijo del operando:

• Prefijo: Se realiza el incremento sobre la variable y luego es usada en la expresión que la contiene.
• Sufijo: Se usa la variable en la expresión y luego si se aplica el incremento.

Ejemplo: Declarar una variable entera con el valor de 2 e imprimir su valor luego de incrementar con prefijo y decrementar con sufijo.

fun main() {
    var a = 2

    println("De $a a ${++a}")
    println("De $a a ${a--}")
    println("Valor final > $a")
}

El resultado será:

De 2 a 3
De 3 a 3
Valor final > 2

Aunque el valor es disminuido en la segunda impresión, este no se hace efectivo sino hasta que se termina la línea. Por eso el resultado final es 2 en la tercera impresión.

Operadores Relacionales

Los operadores relacionales te permiten verificar enunciados de igualdad y desigualdad entre dos valores. El tipo de dato resultante de la expresión es Boolean, indicando la veracidad del enunciado expresado.

Aquí hay una la tabla de estos operadores:

Operador	Enunciado	Expresión	Función Equivalente
==	a es igual a b	a==b	a?.equals(b) ?: (b === null)
!=	a es diferente de b	a!=b	!(a?.equals(b) ?: (b === null))
<	a es menor que b	a<b	a.compareTo(b)<0
>	a es mayor que b	a>b	a.compareTo(b)>0
<=	a es menor ó igual que b	a<=b	a.compareTo(b)<=0
>=	a es mayor o igual que b	a>=b	a.compareTo(b)>=0

Ejemplo: Usar los operadores relacionales entre los números 17 y 20.

fun main() {
    val a = 17
    val b = 20

    println("$a es igual a $b: ${a == b}")
    println("$a es diferente a $b: ${a != b}")
    println("$a es menor que $b: ${a < b}")
    println("$a es mayor que $b: ${a > b}")
    println("$a es menor o igual que $b: ${a <= b}")
    println("$a es mayor o igual que $b: ${a >= b}")
}

La salida será:

17 es igual a 20: false
17 es diferente a 20: true
17 es menor que 20: true
17 es mayor que 20: false
17 es menor o igual que 20: true
17 es mayor o igual que 20: false

Operadores Lógicos

Los operadores lógicos te permiten crear expresiones de lógica proposicional como lo son conjunción, disyunción y negación.

Operador	Descripción	Expresión
&&	Conjunción (and): el resultado es true si a y b son true	a&&b
||	Disyunción (or): el resultado es true si a o b son true	a||b
!	Negación (not): el resultado es false si a es true, o viceversa	!a

Ejemplo: Usar las proposiciones «5 mayor que 0» y «5 es par» para comprobar el funcionamiento de los operadores lógicos.

fun main() {
    val input = 5
    var res: Boolean

    val greaterThanZero = input > 0
    val isEven = input % 2 == 0

    res = greaterThanZero && isEven
    println("Es mayor que cero y par:$res")

    res = greaterThanZero || isEven
    println("Es mayor que cero o par:$res")

    res = greaterThanZero && !isEven
    println("Es mayor que cero e impar:$res")
}

Operadores A Nivel De Bits

Kotlin provee funciones para los tipos primitivos enteros, que actúan como operadores a nivel de bits.

Función	Descripción	Expresión
and()	and bit a bit	a and b
or()	or bit a bit	a or b
xor()	xor bit a bit	a xor b
inv()	not bit a bit	a.inv()
shl()	Desplazamiento de bits a la izquierda	a shl b
shr()	Desplazamiento de bits a la derecha	a shr b
ushr()	Desplazamiento de bits a la derecha sin signo	a ushr b

Ejemplo: Operar a nivel de bits los números enteros 5 y 7.

fun main() {
    val a = 5
    val b = 7

    println("a and b: ${a and b}")
    println("a or b: ${a or b}")
    println("a xor b: ${a xor b}")
    println("a.inv(): ${a.inv()}")
    println("a shl b: ${a shl b}")
    println("a shr b: ${a shr b}")
    println("a ushr b: ${a ushr b}")
}

El resultado de las operaciones a nivel de bits sería:

a and b: 5
a or b: 7
a xor b: 2
a.inv(): -6
a shl b: 640
a shr b: 0
a ushr b: 0

¿Qué Sigue?

Una vez discutido el uso de operadores en Kotlin el siguiente paso es aprender sobre la conversión de tipos en el lenguaje.