kotlin - 基础

作者: 前行的乌龟 | 来源:发表于2019-02-20 20:53 被阅读3次

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

基础数据类型

kotin 对应的基本数据类型如下：
在 kotlin 中没有 java 的数据类型默认转换，所有的 kotlin 基本数据类型必须显示的手动转换
kotlin支持十进制（123），十六进制（0x0F），二进制（0b00001011），不支持八进制
1.1 起允许使用下划线，使数字常量更易读

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) }

集合的操作符：

retainAll - 取交集
contains - 是否包含
elementAt / elementAtOrNull / elementAtOrElse - 下标对应的元素，没有就是 null ,带默认值,
first / firstOrNull / first(predicate) / firstOrNull (element) - 返回第一个元素或是符合条件的第一个元素
last() / lastOrNull / last(predicate) / lastOrNull(predicate) - 返回最后一个元素或是符合条件的最后一个元素
single / single(predicate:) / singleOrNull / singleOrNull(predicate) - 判断集合内容是不是唯一，或者取符合条件的单个元素，如果未找到符合的元素或找到多个元素，则返回null
indexOf / indexOfFirst(predicate) / indexOfLast(predicate) / lastIndexOf(predicate) - 返回指定或满足条件的元素下标，没有就返回-1
any - 如果集合为空，返回false, 集合中存有一个或多个元素时返回true
any(predicate) - 如果集合为空或者没有符号条件的元素返回false, 集合中存有一个或多个元素符合条件时返回true
all(predicate) - 当且仅当该集合中所有元素都满足条件时，返回true；否则都返回false
none - 如果集合中没有元素，则返回true，否则返回false
none(predicate) - 如果集合中没有符合匹配条件的元素，返回true，否则返回false
count(predicate) - 返回符合匹配条件的元素的个数
max, min - 查询最大，最小元素，空集返回null
take - 截取指定个数的元素成子集合
map - 统一变换处理
mapNotNull - 过滤 null 元素
reversed - 降序排序
sorted / sortedDescending - 升序排序和降序排序
sortedBy / sortedByDescending - 可变集合MutableList的升序排序和降序排序
zip - 合并元素
plus - 合集合

retainAll
取2个集合的交集

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

[0]

contains
是否包含指定元素

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

true 
false

elementAt
查找下标对应的元素

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

下标为5的元素值:5

elementAtOrElse
查找下标对应元素，如果越界会根据方法返回默认值

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

5 
0

elementAtOrNull
查找下标对应元素，如果越界就返回 null

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())

first(predicate)
返回符合条件的第一个元素，没有则抛异常

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

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

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

null

firstOrNull(predicate)
同上，没有返回 null
indexOf
返回指定元素的下标，没有就返回-1

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

2 
-1

indexOfFirst(predicate)
返回第一个符合条件的元素的下标，没有就返回-1 。

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

indexOfLast(predicate)
同上，返回的是最后一个符合条件的元素的下标
last() / lastOrNull / last(predicate) / lastOrNull(predicate)
同 frist ，我就不写啦
lastIndexOf(predicate) = indexOfLast(predicate)
single / single(predicate:) / singleOrNull / singleOrNull(predicate:)
又是一长串，基础是判断集合内容是不是唯一，加上条件就是取符合条件单个元素，如果未找到符合的元素或找到多个元素，则返回null
any
判断集合元素，如果集合为空，返回false,

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

true 
false

any(predicate)
判断集合元素，如果集合为空或者没有符号条件的元素返回false, 集合中存有一个或多个元素符合条件时返回true

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

true

all(predicate)
当且仅当该集合中所有元素都满足条件时，返回true；否则都返回false。

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

none
如果集合中没有元素，则返回true，否则返回false。

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

false

none(predicate)
如果集合中没有符合匹配条件的元素，返回true，否则返回false 。

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

true

count(predicate)
返回符合匹配条件的元素的个数

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

max, min
查询最大，最小元素，空集返回null

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

3 
0

take
截取前n个元素为子集合

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

[0, 1]

map(transform)
将集合中的元素通过转换函数transform映射后的结果，存到一个集合中返回

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

[2, 4, 3, 5]

mapNotNull(transform)
遍历集合每个元素，得到通过函数算子transform映射之后的值，剔除掉这些值中的null，返回一个无null元素的集合

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

[1, 3, 2, 4]

reversed
倒序排列

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

[4, 2, 3, 1]

sorted() / sortedDescending
升序排序和降序排序。

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

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

sortedBy / sortedByDescending
可变集合MutableList的排序操作。根据函数映射的结果进行升序排序和降序排序。

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

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

zip
合并元素

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

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

plus
合并两个List

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]

参考文章：

kotlin集合(List)使用方法整理

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

网友评论

Kotlin知识点

本文标题：kotlin - 基础

本文链接：https://www.haomeiwen.com/subject/bvehyqtx.html

延伸阅读

深度阅读

您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！