Kotlin知识点

kotlin - 基础

2019-02-20  本文已影响3人  前行的乌龟

kotlin 一直我只是记录实际写法，但是我发现有些点总是忘，不写不行了，所以下面我记录的是容易忘或是忽略的部分

基础数据类型

val oneMillion = 1_000_000
val creditCardNumber = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010

== / ===

kotlin 的 == 等同于 .equals , === 是引用比较

var book11: Book = Book("book")
var book12: Book = Book("book")

Log.d("BBB", " book11  == book12 : " + (book11 == book12))
Log.d("BBB", " book11  === book12 : " + (book11 === book12))

02-20 15:53:36.856 13992-13992/com.bloodcrown.kotlintest D/BBB:  book11  == book12 : true
02-20 15:53:36.856 13992-13992/com.bloodcrown.kotlintest D/BBB:  book11  === book12 : false

字符串模板

val a=10
val s1 = "a is $a"
val s2="a+1 is ${a+1}"

var a: String = "a"
var b: String = "b"
Toast.makeText(this, "$a\n$b", Toast.LENGTH_SHORT).show()

字符串显示格式

kotlin 对于 字符串显示 有自己的套路

直接换行+空格，不用再加转意符了，直接写成我们想要的文本格式

        var a: String = "a"
        var b: String = "b"
        var c: String = """
                            $a
                            $b
                        """
        Toast.makeText(this, c, Toast.LENGTH_SHORT).show()

用 trimMargin 去掉 | 标记的行空格

        var a: String = "a"
        var b: String = "b"
        var c: String = """
                            |$a
                            $b
                        """.trimMargin()
        Toast.makeText(this, c, Toast.LENGTH_SHORT).show()

支持嵌套注释 

/* 这是一个多行的
   块注释。 */
Kotlin块注释支持嵌套，代码如下：

/* 
这是一个多行的
块注释。
    /*再嵌套一个
      块注释 */
*/

条件表达式

kotlin 的条件表达式可以充当返回值

fun maxOf(a: Int, b: Int) = if (a > b) a else b

Unit

Unit 表示 method 没有返回值，一般我们可以不用写 Unit ，但是有的时候我们必须写，记住这个单词

fun abc(): Unit{}

null 操作

val name: String?
name = if(Random.nextBoolean()) "Ann" else null

//加上？则只在name不为null的时候会调用，得到的len1类型也是有问号的，即Int?
val len1 = name?.length

// ?: 相当于添加默认值
val len2 = name?.length?:0

//加上双感叹号其实就是java什么都不加的写法了，如果为null会报空指针异常
val len3 = name!!.length

when 函数

kotlin 的 when 支持任何数据类型，不想 java 只支持 int；另一个是 kotlin 的 when 在满足条件的分支执行后，会终止 when 语句执行，所以不用像 switch 语句那样每一个 case 都加上 break

        // 标准样式
        var a = 0
        when (a) {
            0 -> { }
            1 -> { }
            else -> { }
        }

        // 支持任意类型
        when (obj) {
            1 -> "One"
            "Hello" -> "Greeting"
            is Long -> "Long"
            !is String -> "Not a string"
            else -> "Unknown"
        }

        // 可以是表达式
        val items = setOf("apple", "banana", "kiwi")
        when {  //when中内容省略了
            "orange" in items -> println("juicy")
            "apple" in items -> println("apple is fine too")
        }

in 范围

kotlin 特性，in 可以指定范围，也可以参与 if 判断在不在


        // 参与 if 判断，判断在不在
        val list= setOf("apple", "banana", "kiwi")

        var name:String = ""
        if ( name in items ) {}

        // 遍历 1 - 5 ，数据全包，含开始和结尾数据
        for (x in 1..5) { print(x) }
      
        // step 指定步长
        for (x in 1..10 step 2) { print(x) }

        // downTo 指定递减
        for (x in 9 downTo 0 step 3) { print(x) }

        // until 表示左闭右开区间
        for (i in 1 until 100) { …… }

集合

kotlin 的集合份2种，一种可以修改的，另一个是不能修改的，java 传统的 list，set，map 在 kotin 中都是不能修改的集合类型，能修改的是 mutableList 这样加 mutable 的类型

基础用法:

var list: List<Int> = listOf<Int>()
var set: Set<Int> = setOf<Int>()
var map: Map<String, Int> = mapOf<String, Int>()

var mutableList: MutableList<Int> = mutableListOf()
mutableList.add(1)
mutableList.remove(1)
mutableList.get(2)
mutableList.clear()

var mutableSet: MutableSet<Int> = mutableSetOf()
mutableSet.add(1)
mutableSet.remove(1)
mutableSet.contains(2)
mutableSet.clear()

var mutableMap: MutableMap<String, Int> = mutableMapOf()
mutableMap.put("1", 1)
mutableMap.remove("1")
mutableMap.get("2")
mutableMap.clear()

// 可变和不可变集合转换
val mList: List<Int> = listOf(1, 3, 5, 7, 9)
val mMutableList = mList.toMutableList()

kotlin 可以直接打印集合

        val items = setOf("apple", "banana", "kiwi")
        println( items )

遍历：

        // list 
        val items = listOf("apple", "banana", "kiwi")  //kotlin的一个函数
        for (item in items) { println(item) }
        for (i in items.indices) { println(items[I]) }
        //index是索引，value是值
        for ((index, value) in items.withIndex()) { println("the element at $index is $value")    }

        // map 
        val map = mapOf("a" to "A", "b" to "B", "c" to "C")
        for ((k, v) in map) { println(""+ k + v) }

集合的操作符：

val mList1 = mutableListOf(0, 1, 3, 5, 7, 9)
val mList2 = mutableListOf(0, 2, 4, 6, 8, 10)
mList1.retainAll( mList2 )
println( mList1 )

[0]

println(mList1.contains(0))
println(mList1.contains(30))

true 
false

println("下标为5的元素值:${mList1.elementAt(5)}")

下标为5的元素值:5

val mList = mutableListOf(0,1,2,3,4,5)
println(mList.elementAtOrElse(5, {0}))
println(mList.elementAtOrElse(6, {0}))

5 
0

val mList = mutableListOf(0,1,2,3,4,5)
println(mList.elementAtOrNull(

null

first() 返回集合第1个元素，如果是空集，抛出异常

val mList = mutableListOf(0,1,2,3,4,5)
println(mList.first())

0

val mList = listOf(1, 2, 3)
println(mList.first { it % 2 == 0 })

2

firstOrNull() 返回集合第1个元素，如果是空集, 对空指针异常处理的函数，如果集合为空，则返回 null

val mList = mutableListOf()
println(mList.first())

null

val mList = listOf(1, 2, 3)
println(mList.indexOf(3))
println(mList.indexOf(0))

2 
-1

val mList = listOf(1, 2, 3)
println(mList.indexOfFirst { it == 2})

1

val mList1 = arrayListOf(1, 2, 3, 4, 5)
val mList2: ArrayList<Int> = arrayListOf()
println(mList1.any())
println(mList2.any())

true 
false

val mList = arrayListOf(1, 2, 2, 3, 4, 5)
println(mList.any { it == 2})

true

val mList = arrayListOf(0, 2, 4, 6, 8)
println(mList.all { it % 2 == 0 })

val mList = arrayListOf(0, 1, 2, 3, 4)
println(mList.all { it % 2 == 0 })

true
false

val mList = arrayListOf(0, 1, 2, 3, 4)
println(mList.none())

false

val mList = arrayListOf(0, 1, 2, 3, 4)
println(mList.none { it == 5 })

true

val mList = arrayListOf(0, 1, 2, 3, 4)
println(mList.count { it % 2 == 0 })

3

val mList = arrayListOf(0, 1, 2, 3)
println(mList.max())
println(mList.min())

3 
0

val mList = arrayListOf(0, 1, 2, 3)
val mNewList = mList.take(2)
println(mNewList)

[0, 1]

val mList = mutableListOf(1, 3, 2, 4)
println(mList.map { it + 1 })

[2, 4, 3, 5]

val mList = mutableListOf(1, null, 3, null, 2, 4)
println(mList.mapNotNull { it })

[1, 3, 2, 4]

val mList = listOf(1, 3, 2, 4)
println(mList.reversed())

[4, 2, 3, 1]

val mList = listOf(1, 3, 2, 4)
println(mList.sorted())
println(mList.sortedDescending())

[1, 2, 3, 4] 
[4, 3, 2, 1]

val mList = mutableListOf(1, 3, 2, 4)
println(mList.sorted())
println(mList.sortedDescending())

[1, 2, 3, 4] 
[4, 3, 2, 1]

val mList3 = arrayListOf("x1", "x2", "x3", "x4")
val mList4 = arrayListOf("y1", "y2", "y3")
println(mList3.zip(mList4))

[(x1, y1), (x2, y2), (x3, y3)]

val mList1 = arrayListOf(0, 1, 2, 3)
val mList2 = arrayListOf(4, 5, 6, 7, 8)
println(mList1.plus(mList2))

[0, 1, 2, 3, 4, 5, 6, 7, 8]

参考文章：

loop@ for(i in 1..100) {
for (j in 1..100) {
if (……) break@loop
}
}

上一篇 下一篇

猜你喜欢

热点阅读