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。