Los operadores son los símbolos especiales que realizan diferentes operaciones en los operandos. Por ejemplo + y – son operadores que realizan sumas y restas respectivamente. Al igual que Java, Kotlin contiene diferentes tipos de operadores.
- operador aritmético
- operador de relación
- Operador de asignación
- operador unario
- operador lógico
- Operador bit a bit
Operadores aritméticos –
| Operadores | Sentido | Expresión | Traducir a |
|---|---|---|---|
| + | Suma | a + b | a.más(b) |
| – | Sustracción | un-b | a.menos(b) |
| * | Multiplicación | un * segundo | a.veces(b) |
| / | División | un / b | a.div(b) |
| % | Módulo | un % segundo | a.rem(b) |
Kotlin
fun main(args: Array<String>)
{
var a = 20 var b = 4 println("a + b = " + (a + b))
println("a - b = " + (a - b))
println("a * b = " + (a.times(b)))
println("a / b = " + (a / b))
println("a % b = " + (a.rem(b)))
}
Producción:
a + b = 24 a - b = 16 a * b = 80 a / b = 5 a % b = 0
Operadores relacionales –
| Operadores | Sentido | Expresión | Traducir a |
|---|---|---|---|
| > | mas grande que | a > b | a.comparar con(b) > 0 |
| < | menos que | un < segundo | a.comparar con(b) < 0 |
| >= | Mayor qué o igual a | un >= segundo | a.comparar con(b) >= 0 |
| <= | Menos que o igual a | un <= segundo | a.comparar con(b) <= 0 |
| == | es igual a | un == segundo | a?.es igual a(b) ?: (b === nulo) |
| != | no igual a | un != segundo | !(a?.es igual a(b) ?: (b === nulo)) > 0 |
Kotlin
fun main(args: Array<String>)
{
var c = 30
var d = 40
println("c > d = "+(c>d))
println("c < d = "+(c.compareTo(d) < 0))
println("c >= d = "+(c>=d))
println("c <= d = "+(c.compareTo(d) <= 0))
println("c == d = "+(c==d))
println("c != d = "+(!(c?.equals(d) ?: (d === null))))
}
Producción:
c > d = false c < d = true c >= d = false c <= d = true c == d = false c != d = true
Operadores de Asignación –
| Operadores | Expresión | Traducir a |
|---|---|---|
| += | una = una + segundo | a.plusAssign(b) > 0 |
| -= | a = a – b | a.minusAssign(b) < 0 |
| *= | un = un * segundo | a.timesAssign(b)>= 0 |
| /= | un = un / segundo | a.divAssign(b) <= 0 |
| %= | a = a % b | a.remAssign(b) |
Kotlin
fun main(args : Array<String>){
var a = 10
var b = 5
a+=b
println(a)
a-=b
println(a)
a*=b
println(a)
a/=b
println(a)
a%=b
println(a)
}
Producción:
15 10 50 10 0
Operadores Unarios –
| Operadores | Expresión | Traducir a |
|---|---|---|
| ++ | ++a o a++ | a.inc() |
| — | –a o a– | a.dec() |
Kotlin
fun main(args : Array<String>){
var e=10
var flag = true
println("First print then increment: "+ e++)
println("First increment then print: "+ ++e)
println("First print then decrement: "+ e--)
println("First decrement then print: "+ --e)
}
Producción:
First print then increment: 10 First increment then print: 12 First print then decrement: 12 First decrement then print: 10
Operadores logicos –
| Operadores | Sentido | Expresión |
|---|---|---|
| && | devuelve verdadero si todas las expresiones son verdaderas | (a>b) && (a>c) |
| || | devuelve verdadero si alguna de las expresiones es verdadera | (a>b) || (a > c) |
| ! | complemento de retorno de la expresión | a.no() |
Kotlin
fun main(args : Array<String>){
var x = 100
var y = 25
var z = 10
var result = false
if(x > y && x > z)
println(x)
if(x < y || x > z)
println(y)
if( result.not())
println("Logical operators")
}
Producción:
100 25 Logical operators
Operadores bit a bit –
| Operadores | Sentido | Expresión |
|---|---|---|
| shl | desplazamiento firmado a la izquierda | a.shl(b) |
| shr | desplazamiento firmado a la derecha | a.shr(b) |
| ujier | desplazamiento sin firmar a la derecha | a.ushr() |
| y | bit a bit y | a y B) |
| o | bit a bit o | a.o() |
| xor | bit a bit xor | a.xor() |
| inversión | bit a bit inversa | a.inv() |
Kotlin
fun main(args: Array<String>)
{
println("5 signed shift left by 1 bit: " + 5.shl(1))
println("10 signed shift right by 2 bits: : " + 10.shr(2))
println("12 unsigned shift right by 2 bits: " + 12.ushr(2))
println("36 bitwise and 22: " + 36.and(22))
println("36 bitwise or 22: " + 36.or(22))
println("36 bitwise xor 22: " + 36.xor(22))
println("14 bitwise inverse is: " + 14.inv())
}
Producción:
5 signed shift left by 1 bit: 10 10 signed shift right by 2 bits: : 2 12 unsigned shift right by 2 bits: 3 36 bitwise and 22: 4 36 bitwise or 22: 54 36 bitwise xor 22: 50 14 bitwise inverse is: -15
Publicación traducida automáticamente
Artículo escrito por Praveenruhil y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA