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 +.

OperadorExpresiónFunción equivalente
++aa.unaryPlus()
--aa.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.

OperadorOperaciónExpresiónFunción Equivalente
+Sumaa+ba.plus(b)
-Restaa-ba.minus(b)
*Multiplicacióna*ba.times(b)
/Divisióna/ba.div(b)
%Residuoa%ba.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:

OperadorExpresión simplificadaExpresión CompletaFunción Equivalente
+=a+=ba=a+ba.plusAssign(b)
-=a-=ba=a-ba.minusAssign(b)
*=a*=ba=a*ba.timesAssign(b)
/=a/=ba=a/ba.divAssign(b)
%=a%=ba=a%ba.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:

OperadorEnunciadoExpresiónFunción Equivalente
==a es igual a ba==ba?.equals(b) ?: (b === null)
!=a es diferente de ba!=b!(a?.equals(b) ?: (b === null))
<a es menor que ba<ba.compareTo(b)<0
>a es mayor que ba>ba.compareTo(b)>0
<=a es menor ó igual que ba<=ba.compareTo(b)<=0
>=a es mayor o igual que ba>=ba.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.

OperadorDescripciónExpresión
&&Conjunción (and): el resultado es true si a y b son truea&&b
||Disyunción (or): el resultado es true si a o b son truea||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ónDescripciónExpresión
and()and bit a bita and b
or()or bit a bita or b
xor()xor bit a bita xor b
inv()not bit a bita.inv()
shl()Desplazamiento de bits a la izquierdaa shl b
shr()Desplazamiento de bits a la derechaa shr b
ushr()Desplazamiento de bits a la derecha sin signoa 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.

¿Ha sido útil esta publicación?