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.