日韩精品久久久肉伦网站,欧美精品亚洲精品日韩专区一,日本高清视频网站www

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

字符串模板

java 里我們用起來還是有些麻煩的

MessageFormat.format("{0}xivehribuher{1}xhvihuehewogweg",para0,para2);

kotlin 就省事多了

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

我們繼續來擴展一下思路， ?: 賦予我們可以在 ? 左邊為 null 時把右邊的值賦值給目標對象，其實？右邊我們不光可以給一個具體的值，更可以提供一個有返回值的方法

    fun test() {
        var sk: Int ?= 22
        var ak: Int = sk ?: awp()
    }

    fun awp(): Int {
        return 58
    }

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]

枚舉

enum class Sex (var isMan: Boolean) {

    MAN(true), WOMAN(false)
}

匿名內部類/實現類

object:Callback {

    override fun onSuccess() {

    }

    override fun onFail() {

    }
}

可變參數


fun add(vararg array: Int) : Int {
    var count = 0

    array.forEach {
        count += it
    }
    return count
}

參考文章：

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

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

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

kotlin - 基礎語法