Kotlin运算符

发表于 | 分类于 ， | | 本文总阅读数 次
| 字数统计: 2.1k | 阅读时长 ≈ 9
Kotlin运算符

2

Kotlin运算符

  在前面已经介绍了Kotlin的发展，这里主要介绍Kotlin的运算符，包括赋值运算符，算术运算符，关系运算符，逻辑运算符，三目运算符。

Kotlin创建变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// Kotlin中的变量创建时和Java与Python都有些类似，类似于Python不用明确指出变量的类别，编译器会进行自动推断，而且不需要在末尾写分号，但是类似于Java，也可以明确指定变量的类别，而且可以先声明，然后在使用时进行初始化。
//在Kotlin中，所有的变量都是对象，用指针表示，创建变量必须指定指针是否可变，可变用var表示，不可变用val表示。
//注意Int类型是默认的整型，如果要指定Byte、Short要使用变量名+:类型名的方式指定，如果要指定Long类型，可以使用类似Byte的方式，也可以在数字后面加上L表示Long，Float则要加上f或者F表示。
//字符串模板是指，用美元符号$括起来的变量或者表达式，会先进行计算，然后将结果作为字符串显示。

fun main() {
    var b:Byte = 0
    val s:Short
    s = 10
    var i = 200
    val l:Long = 3000L
    var f = 3.14F
    val d = 1.234567
    var c = 'A'
    val st = "Hello kotlin"
    var bo = true

    println("可变Byte类型b = ${b}")
    println("不可变Short类型s = ${s}")
    println("可变Int类型b = ${i}")
    println("不可变Long类型b = ${l}")
    println("可变Float类型b = ${f}")
    println("不可变Double类型b = ${d}")
    println("可变Char类型b = ${c}")
    println("不可变String类型b = ${st}")
    println("可变Boolean类型b = ${bo}")

    b = 1
    i = 300
    f = 3.15F
    c = 'B'
    bo = false

    println("----------修改后----------")

    println("可变Byte类型b = ${b}")
    println("可变Int类型b = ${i}")
    println("可变Float类型b = ${f}")
    println("可变Char类型b = ${c}")
    println("可变Boolean类型b = ${bo}")
}

1

Kotlin算术运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// +(加)，-(减)，*(乘)，/(除)，%(求余)，整数除法结果只能得到整数，注意字符型可以参与运算，字符型的值为ASCII码对应的值，但是布尔型不可以参与算术运算。
fun main() {
// 不能声明某一类型的变量指向其他类型，如val d2:Int = a2是错误的，可以不声明类型指向某一类型，则该变量为指向的类型
// 在计算过程中，可以根据类型范围自动转化，两个不同的类型进行计算时，结果为范围较大的类型，如val d2:Int = a2 + 0是正确的。但是要注意Char类型无法和浮点进行运算。
// 如果想将某一类型强制转换为其他类型，可以使用.to类型名的方法进行转换
    val a1:Int = 10
    val b1 = a1
    val c1 = a1.toByte()
    println("${a1.javaClass}类型a1 = ${a1}")
    println("${b1.javaClass}类型b1 = ${b1}")
    println("${c1.javaClass}类型c1 = ${c1}")

    val a2:Byte = 20
    val b2 = a2
    val c2 = a2.toInt()
    println("${a2.javaClass}类型a2 = ${a2}")
    println("${b2.javaClass}类型b2 = ${b2}")
    println("${c2.javaClass}类型c2 = ${c2}")

    val a:Byte = 9
    val b = 2
    val c = 2.0
    val d = 'a'
    println("${a.javaClass}类型${a} + ${b.javaClass}类型${b} = ${(a + b).javaClass}类型${a + b}")
    println("${a.javaClass}类型${a} - ${b.javaClass}类型${b} = ${(a - b).javaClass}类型${a - b}")
    println("${a.javaClass}类型${a} * ${c.javaClass}类型${c} = ${(a * c).javaClass}类型${a * c}")
    println("${a.javaClass}类型${a} / ${c.javaClass}类型${c} = ${(a / c).javaClass}类型${a / c}")
    println("${d.javaClass}类型${d} + ${b.javaClass}类型${b} = ${(d + b).javaClass}类型${d + b}")
}

2

Kotlin关系运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// >(大于)，<(小于)，>=(大于等于)，<=(小于等于)，==(等于)，!=(不等于)
// ==比较两个对象的值是否相等，===比较两个对象的地址是否相等
// 在a1、b1和c1的比较过程中，a1、b1和c1值相等，类型相同，并且指向同一个地址
// 在a2、b2和c2的比较过程中，a2、b2和c2值相等，但是b2和c2类型可以为空，进行了重新包装，但是在-127到128之间，所有的对象都具有同样的地址，虽然重新包装但是地址仍一样
// 在a3、b3和c3的比较过程中，a3、b3和c3值相等，并且指向同一个地址，但是b3和c3类型可以为空，进行了重新包装，不在-127到128之间，因此地址不相同
// 在a4、b4和c4的比较过程中，a4、b4和c4值相等，类型相同，并且指向同一个地址
fun main() {
    val a = 10
    val b = 20
    val c = 'c'
    println("${a} == ${b}? -> ${a == b}")
    println("${a} * 2 == ${b}? -> ${a * 2 == b}")
    println("${c} < d? -> ${c < 'd'}")

    println("--------------------")

    val a1 = 20
    val b1 = a1
    val c1 = a1
    println("b1 == c1? -> ${b1 == c1}")
    println("b1 === c1? -> ${b1 === c1}")

    println("--------------------")

    val a2 = 20
    val b2:Int? = a2
    val c2:Int? = a2
    println("b2 == c2? -> ${b2 == c2}")
    println("b2 === c2? -> ${b2 === c2}")

    println("--------------------")

    val a3 = 200
    val b3:Int? = a3
    val c3:Int? = a3
    println("b3 == c3? -> ${b3 == c3}")
    println("b3 === c3? -> ${b3 === c3}")

    println("--------------------")

    val a4:Int? = 200
    val b4:Int? = a4
    val c4:Int? = a4
    println("b4 == c4? -> ${b4 == c4}")
    println("b4 === c4? -> ${b4 === c4}")
}

4

Kotlin自增自减运算符

1
2
3
4
5
6
7
8
9
// ++(自增运算符)，--(自减运算符)，++在前代表先进行加1，然后将值代入表达式，++在后代表先将值代入表达式，然后再进行加1，自减操作符同理。
fun main() {
    var k = 1
    println("k++ = ${k++}")
    println("++k = ${++k}")
    println("--k = ${--k}")
    println("k-- = ${k--}")
    println("k = ${k}")
}

5

Kotlin逻辑运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// &&(与)，||(或)，!(非)，注意与或操作只要可以判断出最后结果则停止，具有短路效果。
//如果与操作的第一个条件为假，则不执行第二个条件，如果或操作的第一个条件为真，则不执行第二个条件。
fun main() {
    val a = 5
    val b = 6
    var i = 0
    val c = a > b || (++i > 0)
    println("i = ${i}")
    println("c = ${c}")
    val d = a > b && (++i > 0)
    println("i = ${i}")
    println("d = ${d}")
    val e = !d
    println("e = ${e}")
}

6

Kotlin三目运算符

1
2
3
4
5
6
7
8
9
//在C++和Java语言中，三目表达式为，条件?表达式1:表达式2，当条件成立时，执行表达式1的内容，否则执行表达式2的内容。
//在Python语言中，三目表达式为，表达式1 if 条件 else 表达式2
//在Kotlin语言中，三目表达式为，if (条件) 表达式1 else 表达式2
fun main() {
    val a = 10
    val b = if (a > 3) 2 else 1
    println("b = ${b}")
}

7

Kotlin位运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// and/or/xor/inv/shl/shr/ushr分别代表与/或/非/求反
// 可以对象名1.方法(对象名2)也可以对象名1 方法 对象名2，如a.and(b) 或者 a and b
// shr代表连同符号位右移，并且当前符号位和原始符号位相同，ushr代表连同符号位右移，当前符号位补0
fun main() {
    val a = -7
    println("${a} 左移两位 -> ${a.shl(2)}")
    println("${a} 右移两位 -> ${a.shr(2)}")
    println("${a} 无符号右移两位 -> ${a.ushr(2)}")

    val b = 5
    println("${b} and 3 -> ${b.and(3)}")
    println("${b} or 3 -> ${b.or(3)}")
    println("${b} xor 3 -> ${b.xor(3)}")
    println("${b} 求反 -> ${b.inv()}")
}

7

Kotlin小结

  运算符操作每种语言都大同小异，因为运算符是所有语言的基础，学习每一种语言都离不开运算操作，虽然难度较小，但是非常重要，无论以后从事什么样的研究，都是必不可少的，因此需要熟练掌握。

-------------本文结束感谢您的阅读-------------
0%