Koltin常用函数和关键字

JAVA_LDZ

已于 2024-01-20 16:22:53 修改

阅读量567

点赞数 8

文章标签： kotlin

于 2023-12-06 14:47:57 首次发布

本文链接：https://blog.csdn.net/JAVA_LDZ/article/details/134829926

版权

Koltin常用函数和关键字

1. inner（内部类）

在 Kotlin 中，inner 通常用于标记内部类，表示它是一个持有外部类引用的内部类。

2.with

with 函数用于在指定的接收者对象上执行指定的操作块。它允许在不重复引用接收者对象的情况下执行多个操作。
不使用with

val numbers = listOf(1, 2, 3)
val result = run {
    println(numbers.first())
    numbers.last()
}

使用with

val result = with(listOf(1, 2, 3)) {
    println(first())  // 等同于 this.first()
    this.last()
}

3.apply

apply 函数用于在对象上执行操作块，并返回该对象。通常用于对对象进行初始化操作。

val resultApply = mutableListOf<Int>().apply {
    // 在 mutableListOf 上执行配置操作
    addAll(list)
}

4.run

用于在 lambda 表达式中执行一系列操作，并返回 lambda 表达式的结果。它也可以用于在一个对象上执行多个操作

val resultRun = mutableListOf<Int>().run {
    // 在 mutableListOf 上执行多个操作，并返回 lambda 表达式的结果
    addAll(list)
    size
}

5.also

类似于 apply，但返回的是接收者对象而不是 lambda 表达式的结果。它通常用于在执行操作的同时保留原始对象。

val resultAlso = mutableListOf<Int>().also {
    // 在 mutableListOf 上执行操作，返回原始对象
    it.addAll(list)
}

对比 run，also,apply，with

fun demonstrateFunctions(list: List<Int>): List<Int> {
    val resultWith = with(list) {
        println(first())  // 等同于 this.first()
        this.last()
    }

    val resultApply = mutableListOf<Int>().apply {
        addAll(list)
    }

    val resultRun = mutableListOf<Int>().run {
        addAll(list)
        this.size // 返回 lambda 表达式的结果
    }

    val resultAlso = mutableListOf<Int>().also {
        it.addAll(list)
    }

    println("Result with: $resultWith")
    println("Result apply: $resultApply")
    println("Result run: $resultRun")
    println("Result also: $resultAlso")

    return resultApply
}

fun main() {
    val inputList = listOf(1, 2, 3, 4, 5)
    val finalResult = demonstrateFunctions(inputList)
    println("Final result: $finalResult")
}

6. 集合的扩展函数

// 创建一个示例数据集合
val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

1.映射操作

map: 将集合中的每个元素映射到新元素。
flatMap: 将集合中的每个元素映射到一个集合，并将所有结果合并成一个集合。

val squaredNumbers = numbers.map { it * it }

2.检查操作：

any: 检查集合中是否有任一元素符合条件。
all: 检查集合中是否所有元素都符合条件。
none: 检查集合中是否没有元素符合条件
any 是集合的一个扩展函数，用于检查集合中是否至少有一个元素满足指定的条件。

val anyGreaterThanTen = numbers.any { it > 10 }
val allGreaterThanZero = numbers.all { it > 0 }
val noneNegative = numbers.none { it < 0 }

3.过滤操作：

filter: 根据条件过滤集合。
filterNot: 根据条件排除元素。
filterNotNull: 过滤掉集合中的 null 元素

val evenNumbers = numbers.filter { it % 2 == 0 }
val notNullNumbers = numbers.filterNotNull()

4.排序操作

sorted: 对集合元素进行排序。
sortBy, sortByDescending: 根据某个属性排序。
sortedWith: 使用自定义比较器排序。

val sortedNumbers = numbers.sorted()
val descendingSortedNumbers = numbers.sortedDescending()

5.聚合操作：

reduce, reduceOrNull: 对集合元素进行累加。
fold: 同 reduce，但可以指定初始累加值。
sum, average, max, min: 计算集合中的数值元素的和、平均值、最大值和最

val sum = numbers.sum()
val average = numbers.average()
val max = numbers.max()
val min = numbers.min()

6.遍历操作

forEach: 遍历集合中的每个元素。
forEachIndexed: 带索引的遍历

numbers.forEach { println(it) }
numbers.forEachIndexed { index, value -> println("Index: $index, Value: $value") }

7.分组和分区操作：

groupBy: 根据条件将集合元素分组。
partition: 将集合分割成两个部分。

val groupedByEvenOdd = numbers.groupBy { it % 2 == 0 }
val (even, odd) = numbers.partition { it % 2 == 0 }

8.其他操作：

distinct: 移除重复元素。
zip: 将两个集合合并成一个 Pair 的集合

val distinctNumbers = numbers.distinct()
val zippedResult = numbers.zip(numbers.map { it * 2 })

7.const

用于声明编译器常量，主要用于顶层属性和伴生对象属性

//顶层属性
const val PI = 3.14159
//伴生对象的属性
class MyClass {
    companion object {
        const val SOME_CONSTANT = 42
    }
}

8.companion object

是一个对象声明，用于在类的内部创建一个单例对象，这个对象声明是类的一部分，但它的成员可以直接通过类名访问，而不需要类的实例

class MyClass {
    // 一般的类成员

    companion object {
        // companion object 的成员
        fun someFunction() {
            println("This is a function in the companion object.")
        }

        val someProperty: Int = 42
    }
}