Kotlin list:listOf()用法及代码示例

在 Kotlin 中，listOf() 是一个用于创建不可变元素列表的函数。 listOf() 函数采用可变数量的参数并返回包含这些参数的新列表。这是一个例子：

val numbers = listOf(1, 2, 3, 4, 5)

在此示例中，我们使用listOf()函数创建一个名为numbers的新列表。该列表包含五个元素：整数 1 到 5。由于该列表是不可变的，因此一旦创建，我们就无法修改其内容。

我们可以使用索引访问列表的元素，如下所示：

val firstNumber = numbers[0] // returns 1
val lastNumber = numbers[numbers.size - 1] // returns 5

在此示例中，我们使用索引来访问数字列表的第一个和最后一个元素。请注意，Kotlin 中的索引是从 0 开始的，因此第一个元素的索引为 0，最后一个元素的索引为 numbers.size - 1。

我们还可以使用 for 循环迭代列表，如下所示：

for (number in numbers) {
    println(number)
}

在此示例中，我们使用 for 循环来迭代数字列表并将每个元素打印到控制台。

总的来说，listOf() 函数是在 Kotlin 中创建不可变元素列表的一种简单便捷的方法。对于需要存储一组在程序运行期间不会更改的固定数据的情况特别有用。

以下是在 Kotlin 中使用 listOf() 函数的一些优点和缺点：

优点：

1. 不可变性：listOf() 函数创建一个不可变列表，这意味着列表的内容一旦创建就无法修改。这使得您可以更轻松地推断代码的行为，并有助于防止因列表意外更改而导致的错误。
2. 类型安全：由于 Kotlin 是静态类型语言，因此 listOf() 函数通过确保列表的所有元素都具有相同类型来提供类型安全。这有助于防止由于将错误类型的数据传递给函数或方法而导致的错误。
3. 方便：listOf() 函数是在 Kotlin 中创建元素列表的一种简单便捷的方法。它需要可变数量的参数，这使得创建元素列表变得很容易，而无需编写大量样板代码。

缺点：

1. 不变性：虽然在某些情况下不变性可能是一个优点，但在程序运行时需要修改列表内容的情况下，它也可能是一个缺点。如果需要修改列表，则需要使用可变列表而不是不可变列表。
2. 性能开销：与可变列表或数组相比，不可变列表可能会产生一些性能开销，特别是当您需要对列表执行大量操作时。这是因为对不可变列表的每个操作都需要创建一个新的列表对象，这在内存和处理时间方面可能会很昂贵。
3. 函数有限：listOf() 函数创建一个函数有限的基本不可变列表。如果您需要更高级的函数，例如能够在列表中添加或删除元素，则需要使用可变列表。
   总的来说，listOf() 函数是在 Kotlin 中创建不可变元素列表的有用工具，但它并不适合所有情况。它是
4. 优点包括不变性、类型安全和方便，而缺点包括函数有限和潜在的性能开销。当决定是否在代码中使用listOf()时，重要的是要考虑程序的具体需求并相应地选择适当的数据结构。

列表是通用的有序元素集合。科特林有两种类型的列表，不可变列表(无法修改)和可变列表(可以修改)。
只读列表是使用 listOf() 创建的，其元素无法修改，可变列表是使用 mutableListOf() 方法创建的，我们可以更改或修改列表的元素。
列表的 Kotlin 程序包含整数 -

fun main(args: Array<String>) {
    val a = listOf('1', '2', '3')
    println(a.size)
    println(a.indexOf('2'))
    println(a[2])
}

输出：

3
1
3

列表包含字符串的 Kotlin 程序 -

fun main(args: Array<String>) {
    //creating list of strings
    val a = listOf("Ram", "Shyam", "Raja", "Rani")
    println("The size of the list is: "+a.size)
    println("The index of the element Raja is: "+a.indexOf("Raja"))
    println("The element at index "+a[2])
    for(i in a.indices){
        println(a[i])
    }
}

输出：

The size of the list is: 4
The index of the element Raja is: 2
The element at index Raja
Ram
Shyam
Raja
Rani

Kotlin 中列表元素的索引 -

列表的每个元素都有一个索引。第一个元素的索引为零 (0)，最后一个元素的索引为
len - 1，其中 ‘len’ 是列表的长度。

fun main(args: Array<String>)
{
    val numbers = listOf(1, 5, 7, 32, 0, 21, 1, 6, 10)
    val num1 = numbers.get(0)
    println(num1)
    val num2 = numbers[7]
    println(num2)
    val index1 = numbers.indexOf(1)
    println("The first index of number is $index1")
    val index2 = numbers.lastIndexOf(1)
    println("The last index of number is $index2")
    val index3 = numbers.lastIndex
    println("The last index of the list is $index3")
}

输出：

1
6
The first index of number is 0
The last index of number is 6
The last index of the list is 8

第一个和最后一个元素 -

我们可以检索列表的第一个和最后一个元素，而无需使用get()方法。
考虑前面的示例，如果我们在第 1 行之后包含以下代码： 17 号

fun main(args: Array<String>)
{
    val numbers = listOf(1, 5, 7, 32, 0, 21, 1, 6, 10)
    println(numbers.first())
    println(numbers.last())
}

输出：

1
10

列表迭代方法 -

这是一个逐个访问列表元素的过程。
在 Kotlin 中有多种方法可以做到这一点。

fun main(args: Array<String>)
{
    val names = listOf("Gopal", "Asad", "Shubham", "Aditya",
        "Devarsh", "Nikhil", "Gagan")
    // method 1
    for (name in names) {
        print("$name, ")
    }
    println()
     
    // method 2
    for (i in 0 until names.size) {
        print("${names[i]} ")
    }
    println()
    
    // method 3
    names.forEachIndexed({i, j -> println("names[$i] = $j")})
    // method 4
    val it: ListIterator<String> = names.listIterator()
    while (it.hasNext()) {
        val i = it.next()
        print("$i ")
    }
    println()
}

输出：

Gopal, Asad, Shubham, Aditya, Devarsh, Nikhil, Gagan, 
Gopal Asad Shubham Aditya Devarsh Nikhil Gagan 
names[0] = Gopal
names[1] = Asad
names[2] = Shubham
names[3] = Aditya
names[4] = Devarsh
names[5] = Nikhil
names[6] = Gagan
Gopal Asad Shubham Aditya Devarsh Nikhil Gagan 

解释：

for (name in names) {

        print("$name, ")
    }

for循环遍历列表。在每个循环中，变量‘name’指向列表中的下一个元素。

for (i in 0 until names.size) {

        print("${names[i]} ")
    }

此方法使用列表的大小。 until 关键字创建列表索引的范围。

names.forEachIndexed({i, j -> println("namess[$i] = $j")})

使用 forEachIndexed() 方法，我们循环遍历每次迭代中具有可用索引和值的列表。

val it: ListIterator = names.listIterator()

    while (it.hasNext()) {

        val i = it.next()
        print("$i ")
    }

这里我们使用ListIterator来迭代列表。

对列表中的元素进行排序 -

以下示例显示如何按升序或降序对列表进行排序。

fun main(args: Array<String>)
{
    val list = listOf(8, 4, 7, 1, 2, 3, 0, 5, 6 )
    val asc = list.sorted()
    println(asc)
    val desc = list.sortedDescending()
    println(desc)
}

输出：

[0, 1, 2, 3, 4, 5, 6, 7, 8]
[8, 7, 6, 5, 4, 3, 2, 1, 0]

解释：

val asc = list.sorted()

sorted() 方法按升序对列表进行排序。

val desc = list.sortedDescending()

sortedDescending() 方法按降序对列表进行排序。

Contains() 和 containsAll() 函数 -

该方法检查列表中是否存在某个元素。

fun main(args: Array<String>)
{
    val list = listOf(8, 4, 7, 1, 2, 3, 0, 5, 6 )
    val res = list.contains(0)
    if (res)
        println("The list contains 0")
    else
        println("The list does not contain 0")
    val result = list.containsAll(listOf(3, -1))
    if (result)
        println("The list contains 3 and -1")
    else
        println("The list does not contain 3 and -1")
}

输出：

The list contains 0
The list does not contain 3 and -1

解释：

val res = list.contains(0)

检查列表是否包含 0，并返回存储在 res 中的 true 或 false(她的 true)。

 val result = list.containsAll(listOf(3, -1))

检查列表是否包含 3 和 -1。