函数的定义与调用

一、在kotlin中建立集合

---

kotlin没有本身专门的集合类，而是采用的java的集合类，不过书写方式不同。

val set=hashSetOf(1,7,53) //对应hashset
val list=arrayListOf(1,7,53)   //ArrayList
val map=hashMapOf(1 to "one",7 to "seven",53 to "fifty-three")//HashMap

不过kotlin有本身新增的方法：last()，max()集合中最后一个元素和最大的元素。

二、让函数更好调用

---

java的集合都有一个默认的toString()实现，可是它的输出格式是固定的。

val list=listOf(1,2,3)//listOf对应的是（Arrays内部类ArrayList）
println(list)
结果：[1,2,3]

上面的结果是固定格式的，默认实现了toString().

fun <T> joinToString(collection:Collection<T>,separator:String,prefix:String,postfix:String):String{
    val result=StringBuilder(prefix)
    for((index,element) in collection.withIndex()){
    if(index>0) result.append(separator)
    result.append(element)
    }
    result.append(postfix)
    return result.toString()
}

val list=listOf(1,2,3)
println(joinToString(list,"; ","(",")"))
结果：（1；2；3）

当咱们想要改变集合输出格式的时候能够自定义，像上面这样：逗号变分号。

2.1 命名参数

在上面的例子中，咱们单看这一句joinToString(list,"; ","(",")")会发现咱们必需要找到上面对应的函数声明才能更好的理解咱们写的是啥。
为了解决这个问题，kotlin引出了命名参数:当调用一个kotlin自定义的函数时，能够显式地标明一些参数的名称。

joinToString(list,separator=";",prefix="(",postfix=")")

2.2 默认参数值

在声明函数的时候，指定参数的默认值，能够避免建立重载的函数。

fun <T> joinToString(collection:Collection<T>,separator:String,prefix:String,postfix:String):String

当你调用的时候能够用全部参数来调用这个函数，也能够省略掉部分参数。

三、扩展函数和属性

---

Kotlin 能够对一个类的属性和方法进行扩展，且不须要继承或使用 Decorator 模式。
扩展是一种静态行为，对被扩展的类代码自己不会形成任何影响。

3.1 导入和扩展函数

扩展函数能够在已有类中添加新的方法，不会对原类作修改.
扩展函数定义形式：

fun receiverType.functionName(params){
    body
}

• receiverType：表示函数的接收者，也就是函数扩展的对象
• functionName：扩展函数的名称
• params：扩展函数的参数，能够为NULL
  如下实例扩展 User 类 ：

class User(var name:String)

/**扩展函数**/
fun User.Print(){
    print("用户名 $name")
}

fun main(arg:Array<String>){
    var user = User("Runoob")
    user.Print()
}
实例执行输出结果为：
用户名 Runoob

下面代码为 MutableList 添加一个swap 函数：

// 扩展函数 swap,调换不一样位置的值
fun MutableList<Int>.swap(index1: Int, index2: Int) {
    val tmp = this[index1]     //  this 对应该列表
    this[index1] = this[index2]
    this[index2] = tmp
}

fun main(args: Array<String>) {

    val l = mutableListOf(1, 2, 3)
    // 位置 0 和 2 的值作了互换
    l.swap(0, 2) // 'swap()' 函数内的 'this' 将指向 'l' 的值

    println(l.toString())
}
实例执行输出结果为：
[3, 2, 1]

3.2 不可重写的扩展函数

扩展函数是静态解析的，并非接收者类型的虚拟成员，在调用扩展函数时，具体被调用的的是哪个函数，由调用函数的的对象表达式来决定的，而不是动态的类型决定的:

open class C

class D: C()

fun C.foo() = "c"   // 扩展函数 foo

fun D.foo() = "d"   // 扩展函数 foo

fun printFoo(c: C) {
    println(c.foo())  // 类型是 C 类
}

fun main(arg:Array<String>){
    printFoo(D())
}
实例执行输出结果为：
c

若扩展函数和成员函数一致，则使用该函数时，会优先使用成员函数。

class C {
    fun foo() { println("成员函数") }
}

fun C.foo() { println("扩展函数") }

fun main(arg:Array<String>){
    var c = C()
    c.foo()
}
实例执行输出结果为：
成员函数

3.3 扩展属性

除了函数，Kotlin 也支持属性对属性进行扩展:

val <T> List<T>.lastIndex: Int
    get() = size - 1

扩展属性容许定义在类或者kotlin文件中，不容许定义在函数中。初始化属性由于属性没有后端字段（backing field），因此不容许被初始化，只能由显式提供的 getter/setter 定义。

val Foo.bar = 1 // 错误：扩展属性不能有初始化器

扩展属性只能被声明为 val。

四、可变参数、中缀调用和库的支持

---

4.1 扩展java集合的API

fun <T> List<T>.last():T//返回最后一个元素
fun Collection<Int>.max():Int//返回集合中的最大值

为何kotlin用的是java的集合，却能给它添加本身又增长的方法？
函数last和max都被声明成了扩展函数。

4.2 可变参数：让函数支持任意数量的参数

可变参数的关键字vararg，能够用来声明一个函数将可能有任意数量的参数
fun listOf (vararg values:T):List {...}
kotlin库中是这样定义listOf()函数的，正由于这样咱们调用它时才能够传递任意个数的参数给它
kotlin和java的另外一个区别是：当须要传递的参数已经包装在数组中时，调用该函数的语法。
在java中能够按原样传递数组，kotlin要求你显式地解包数组。这个叫作展开运算符，在参数前面加*

fun main(args:Array<String>){
    val list=listOf("args: ",*args)
    println(list)
}

4.3 键值对的处理：中缀调用和重构声明

val map=mapOf(1 to "one",7 to "seven",53 to "fifty-three")

这行代码中的单词to不是内置结构，而是一种特殊的函数调用，被称为中缀调用。

重构声明：
中缀调用能够与只有一个参数的函数一块儿使用，不管是普通的函数仍是扩展函数。要容许使用中缀符合调用函数，须要使用infix修饰符来标记它。

infix fun Any.to(other:Any)=Pair(this,other)

咱们能够直接用Pair的内容来初始化两个变量。
val （number,name)=1 to "one"
这个功能称为解构声明。

五、字符串和正则表达式的处理

---

5.1 分割字符串

println("12.345-6.A".split("\\.|-".toRegex()))
结果：[12,345,6,A]

kotlin提供了一些名为split的，具备不一样参数的重载的扩展函数。用来承载正则表达式的值须要一个Regex类型，而不是String。上面例子中就是使用扩展函数toRegex将字符串转换为正则表达式。
可是对于一些简单的状况，不须要使用正则表达式。kotlin中的split扩展函数的其余重载支持任意数量的纯文本字符串分隔符：

println("12.345-6.A".split(".","-"))
[12,345,6,A]

5.2 正则表达式和三重引号的字符串

咱们解析一个文件路径：/Users/yole/kolin-book/chapter.doc
①使用String的扩展函数来解析文件路径

fun parsePath(path:String){
    val directory=path.substringBeforeLast("/")
    val fullName=path.substringAfterLast("/")
    val fileName=fullName.subStringBeforeLast(".")
    val extension=fullName.subStringAfterLast(".")
    println("Dir:$directory,name:$fileName,ext:$extension")
}
parsePath("/Users/yole/kolin-book/chapter.doc")
结果：Dir:Users/yole/kolin-book,name:chapter,ext:doc

②使用正则表达式来解析文件路径

fun parsePath(path:String){
    val regex="""(.+)/(.+)\.(.+)""".toRegex()
    val matchResult=regex.matchEntire(path)
    if(matchResult!=null){
        val (directory,filename,extension)=matchResult.destructured
        println("Dir:$directory，name:$fileName,ext:$extension"）
    }
}

三重引号字符串不须要对任何字符进行转义。第一个（.+)包含最后一个斜线前的字串。第二个包含最后一个点前的字串，第三个包含剩余部分。

5.3 多行三重引号的字符串

三重引号字符串不只能够避免转义字符，并且它能够包含任意字符，包括换行符。并且它提供了一种简单的方法把包含换行符的文本嵌入到程序中。

val kotlinLogo="""| //
                 .|//
                 .|/ \"""
println(kotlinLogo.trimMargin("."))
结果： | //
      |//
      |/ \