Kotlin实战(二) 函数的定义与调用_kotlin substringafterlast

1 在kotlin中创建集合

fun test1() {
    //1 创建Set
    val set = hashSetOf(1, 7, 53)

    //2 创建list
    val list = arrayListOf(1, 7, 53)

    //3 创建map
    val map = hashMapOf(1 to "one", 7 to "seven", 53 to "fifty-three")

    println("set.javaClass = " + set.javaClass)
    println("list.javaClass = " + list.javaClass)
    println("map.javaClass = " + map.javaClass)

    //4 获取列表中的最后一个元素
    val strings = listOf("first", "second", "fourteenth")
    println("strings.last() = " + strings.last())

    val numbers = setOf(1, 14, 2)
    println("numbers.max() = " + numbers.max())

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

输出结果

set.javaClass = class java.util.HashSet
list.javaClass = class java.util.ArrayList
map.javaClass = class java.util.HashMap
strings.last() = fourteenth
numbers.max() = 14
1
2
3
4
5

2 让函数更好调用

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()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

fun test2() {
    //1 打印集合
    val list = listOf(1, 2, 3)
    println("list = " + list)

    //2 自定义输出格式
    println(joinToString(list, "; ", "(", ")"))
}
1
2
3
4
5
6
7
8

list = [1, 2, 3]
(1; 2; 3)
1
2

2.1 命名参数

fun test3() {
    //1 显示标明参数名称，避免混淆
    val list = listOf(1, 2, 3)
    joinToString(list, separator = "", prefix = "", postFix = "")
}
1
2
3
4
5

2.2 默认参数值

fun defaultValue(string1: String, string2: String = "", string3: String = "") {
    println("string1 = " + string1 + ", string2 = " + string2 + ", string3 = " + string3)
}

fun test4() {
    defaultValue("1")
    defaultValue("1", "2")
    defaultValue("1", "2", "3")
}
1
2
3
4
5
6
7
8
9

string1 = 1, string2 = , string3 =
string1 = 1, string2 = 2, string3 =
string1 = 1, string2 = 2, string3 = 3
1
2
3

2.3 顶层函数和属性

//修改文件类名
@file:JvmName("StringFunctions")
package com.yl.lib.kt.chapter_2

fun joinToStringTest(): String {
    return "null"
}

var opCount = 0
fun performOperation() {
    opCount++
}

fun String.lastChar(): Char = this.get(this.length - 1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

public static void test5() {
        //1 顶层函数 不添加修改文件名的声明时
        //JoinKt.joinToStringTest();

		//2 修改文件类名 @file:JvmName("StringFunctions")
        StringFunctions.joinToStringTest();
        
        //3 顶层属性
        for (int i = 0; i < 5; i++) {
            StringFunctions.performOperation();
        }
        System.out.println("StringFunctions.opCount = " + StringFunctions.getOpCount());
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

输出结果

StringFunctions.opCount = 5
1

3 扩展函数和属性

3.1 导入和扩展函数

//导入函数 
import com.yl.lib.kt.chapter_2.lastChar

fun test5() {
    println("Kotlin".lastChar())
}
1
2
3
4
5
6
7

3.2 从java中调用扩展函数

 public static void test6(){
        char c = StringFunctions.lastChar("Java");
        System.out.println("c = " + c);
    }
1
2
3
4

输出结果

c = a
1

3.3 作为扩展函数的工具函数

fun test6() {
    var list = listOf(1, 2, 3)
    println(list.joinToStringTest(separator = ";", prefix = "(", postfix = ")"))
}
1
2
3
4

(1;2;3)
1

3.4 不可重写的扩展函数

//1 重写成员函数
open class View {
    open fun click() = println("View clicked")
}

class Button : View() {
    override fun click() = println("Button clicked")
}

fun test7() {
    val view: View = Button()
    view.click()
}
1
2
3
4
5
6
7
8
9
10
11
12
13

输出结果

Button clicked
1

//1 此处的扩展函数会编译成静态函数，所以不能重写

//2 此处的扩展函数声明在类的外部
fun View.showOff() = println("I'm a view!")

fun Button.showOff() = println("I'm a button!")

fun test8() {
    val view: View = Button()
    view.showOff()
}
1
2
3
4
5
6
7
8
9
10
11

输出结果

I'm a view!
1

3.5 扩展属性

//1 声明一个扩展属性
val String.lastChar1: Char
    get() = get(length - 1)

//2 声明一个可变的扩展属性
var StringBuilder.lastChar2: Char
    get() = get(length - 1)
    set(value: Char) {
        this.setCharAt(length - 1, value)
    }

fun test9() {
    println("kotlin.lastChar1 = " + "kotlin".lastChar1)

    val sb = StringBuilder("Kotlin?")
    sb.lastChar2 = '!'

    println(sb)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出结果

kotlin.lastChar1 = n
Kotlin!
1
2

4 可变参数,中缀调用和库的支持

4.1 扩展java集合的api

fun test10() {
    val strings: List<String> = listOf("first", "second", "fourteenth")
    println("strings.last() = " + strings.last())

    var numbers: Collection<Int> = setOf(1, 14, 2)
    println("numbers.max() = " + numbers.max())
}
1
2
3
4
5
6
7

输出结果

strings.last() = fourteenth
numbers.max() = 14
1
2

4.2 可变参数

fun test11() {
    // list of支持可变参数，使用vararg修复符
    val list = listOf(2, 3, 5, 7, 11)
}
1
2
3
4

4.3 键值对的处理:中缀调用和解构声明

fun test12() {
    //1 这行代码中的 to 不是内置的结构，而是一种特殊的函数调用，被称为中缀调用
    val map = mapOf(1 to "one", 7 to "seven", 53 to "fifty-three", 2.to("two"))

    //2 中缀调用 没有添加额外的分隔符， 函数名称是直接放在目标对象名称和参数之前

    //3  2.to("two") 等价于 2 to "two"

    //4 要允许使用中缀符号调用函数， 需要使用infix修饰符来标记它
//    infix fun Any.to(other:Any) = Pair<this, Other>

    //5 可以直接用Pair来初始化两个变量 这个功能称为解构声明
    val (numver, name) = 1 to "one"

    //6 解构声明也适用于循环
    val collection: Collection<String> = arrayListOf("one", "two", "three")
    for ((index, element) in collection.withIndex()) {
        println("$index: $element")
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

输出结果

0: one
1: two
2: three
1
2
3

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

5.1 分割字符串

fun test13() {
    var splitStr1 = "12.345-6.A".split("\\.|-".toRegex())
    println("splitStr1 = " + splitStr1)

    var splitStr2 = "12.345-6.A".split(".", "-")
    println("splitStr2 = " + splitStr2)
}
1
2
3
4
5
6
7

splitStr1 = [12, 345, 6, A]
splitStr2 = [12, 345, 6, A]
1
2

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

//1 使用String的扩展函数来解析文件路径
fun parsePath1(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")
}

//2 使用正则表达式解析文件路径
fun parsePath2(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")
    }
}

fun test14() {
    parsePath1("/Users/yole/kotlin-book/chapter.adoc")
    parsePath2("/Users/yole/kotlin-book/chapter.adoc")
}
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

输出结果

Dir: /Users/yole/kotlin-book, name: chapter, ext adoc
Dir:/Users/yole/kotlin-book, name:chapter, ext:adoc
1
2

6 局部函数和扩展

//1 带重复代码的函数
class User(val id:Int, val name:String, val address:String)
fun saveUser1(user:User){
    if(user.name.isEmpty()){
        throw IllegalArgumentException("Can't save user ${user.id}:empty Name")
    }

    if(user.address.isEmpty()){
        throw IllegalArgumentException("Can't save user${user.id}:empty Address")
    }
}
1
2
3
4
5
6
7
8
9
10
11

Exception in thread "main" java.lang.IllegalArgumentException: Can't save user 1:empty Name
at com.yl.lib.kt.chapter_3.Chapter3TestKt.saveUser1(Chapter3Test.kt:264)
1
2

//2 提取局部函数来避免重复
fun saveUser2(user:User){
    fun validate(user:User, value:String, fieldName:String){
        if(value.isEmpty()){
            throw IllegalArgumentException("Can't save user ${user.id} empty $fieldName")
        }
    }

    validate(user, user.name, "Name")
    validate(user, user.address, "Address")
}
1
2
3
4
5
6
7
8
9
10
11

Exception in thread "main" java.lang.IllegalArgumentException: Can't save user 1 empty Name
at com.yl.lib.kt.chapter_3.Chapter3TestKt$saveUser2$1.invoke(Chapter3Test.kt:279)
1
2