CodeGym /課程 /Kotlin SELF /Star-projection *: List<*>

Star-projection *: List<*>

Kotlin SELF
等級 36, 課堂 3
開放

1. 認識 List<*>

想像一個真實情境(也在真實專案裡很常見):你在寫一個紀錄(logging)或除錯輸出函式。它完全不在乎清單裡裝的是什麼——Expense、String 或 Int 都一樣。它只需要遍歷元素並把它們印出來。或者例如顯示大小、前幾個元素,後面就安靜一點,避免洗版主控台。

如果你嘗試用 List<Any?> 寫一個「通用」函式,你很快會撞到一個現實:沒錯,List 是協變(covariant)的,但一旦你想支援 可變 集合(MutableList)或帶有更複雜型別參數的容器,就會開始出現不舒服的限制。因此 Kotlin 提供了獨立語法:List<*>,可讀作:

「這是一個裝著某種型別元素的清單,但到底是哪一種——不知道。」

而這個「不知道」不是哲學問題,而是編譯器的具體規則:你可以對這種清單做什麼、不能做什麼。

2. 可以對 List<*> 做什麼

如果我們拿到的是 List<*>,就可以做所有「讀取型」操作:size、isEmpty()、用 for 迭代、用索引取值。但要付出代價:元素型別會變成最保守、最安全的——Any?。

迷你範例:把所有元素都印出來

fun printAll(xs: List<*>) {
    for (x in xs) {
        println(x) // x: Any?
    }
}

fun main() {
    printAll(listOf(1, 2, 3))
    // 1
    // 2
    // 3

    printAll(listOf("a", "b"))
    // a
    // b
}

為什麼是 Any? 而不是 Any?因為 Kotlin 允許清單的元素可以是 null(例如 List<String?>)。當型別未知時,編譯器必須把這種可能性也納入考量。

現在有個很重要的實務結論:你從 List<*> 取出元素之後,接下來你就只能把它當作 Any? 來使用。想呼叫字串方法——先做型別檢查。

fun printStringLengths(xs: List<*>) {
    for (x in xs) {
        if (x is String) {
            println("${x} -> len=${x.length}") // smart-cast to String
        }
    }
}

fun main() {
    printStringLengths(listOf("Kotlin", "is", "fun"))
    // Kotlin -> len=6
    // is -> len=2
    // fun -> len=3
}

這裡 Kotlin 的體驗很友善:在 if(x is String)之後,它會做 smart cast,於是 x.length 就變得合法。

3. 為什麼不能往 MutableList<*> 加元素

對於 List<*> 而言,它看起來幾乎就是「通用的唯讀清單」。新手常常會在這裡做出下一個看似合理的推論:

「好,如果 List<*> 是未知元素的清單,那 MutableList<*> 就是未知元素的可變清單。那我應該可以往裡面加點東西……至少加個 null 吧……」

這時 Kotlin 會直接進入「嚴格保全模式」:禁止新增。

fun tryToAdd(xs: MutableList<*>) {
    // xs.add(1)    // Compilation error
    // xs.add("hi") // Compilation error
    // xs.add(null) // Also a compilation error
    println(xs.size)
}

為什麼這麼嚴格?因為實際的清單可能是 MutableList<String>。如果編譯器允許你加 Int,你就破壞了「字串清單」的契約;如果允許你加 null,你就破壞了 MutableList<String>(其中 null 是被禁止的)。

在形式化模型層面,Kotlin 這樣描述 star-projection:當型別參數未知時,讀取行為會變成「像 out ...」,而寫入行為會變成「像 in Nothing」(也就是「沒有任何東西可以安全寫入」)。這就寫在 star-projection 的規則裡:對於不變(invariant)的型別參數 Foo<T>,星號會表現為:安全地以其上界進行讀取,並透過 Nothing 對寫入做出禁止。

直覺上可以這樣記:MutableList<*> 就像一個盒子,上面寫著「內容物未知」。你如果開始往裡面塞東西,就可能遇到「原本其實是放湯匙的盒子」,結果你硬塞了一把螺絲起子。盒子或許沒壞,但你的型別契約會壞。

對比:* 並不等於「Any」

非常常見的誤解是:「星號就是 Any。」不是。有時候在「讀取時的行為」看起來相似,但語意完全不同。

我們用一個小表格把差異釐清(用直覺語言說明,不深入型別理論):

型別 對呼叫端承諾了什麼 可以讀到什麼 可以新增什麼
List<*>
「這是清單,但元素型別未知」
Any?
(不適用,
List
為唯讀)
List<Any?>
「這是清單,而且元素確定是 Any?」
Any?
(不適用)
MutableList<*>
「這是可變清單,但元素型別未知」
Any?
什麼都不行(被編譯器禁止)
MutableList<Any?>
「這是可變清單,保存的是 Any?」
Any?
可以新增 Any?(包含 null)

也就是說,MutableList<Any?> 是「什麼都能裝的容器」。而 MutableList<*> 是「不知道用來裝什麼的容器」,因此寫入才會被禁止。

用一個短例子驗證:為什麼 MutableList<*> 很適合作為輸入參數(你不打算寫入時):

fun printFirst(xs: MutableList<*>) {
    val first = xs[0]
    println("first=$first") // first: Any?
}

fun main() {
    val names: MutableList<String> = mutableListOf("Ann", "Bob")
    val nums: MutableList<Int> = mutableListOf(10, 20)

    printFirst(names) // first=Ann
    printFirst(nums)  // first=10
}

這裡 MutableList<*> 很有用:函式可以接受任何 MutableList<T>,但它的契約是「我只讀取」。編譯器也會保證你不會不小心往裡面加錯東西。

如果不禁止 add,會壞在哪裡

我們想像一下,如果 Kotlin 允許這樣寫:

fun breakWorld(xs: MutableList<*>) {
    xs.add(123) // assume this is allowed (in reality: no)
}

然後這樣呼叫:

val names: MutableList<String> = mutableListOf("Ann", "Bob")
breakWorld(names)
println(names[2].length) // what happens here?

如果允許 add(123),那 names 事實上就不再是「字串清單」。接下來你要嘛在執行期某處(可能很遠)爆掉(例如 ClassCastException),要嘛更糟:悄悄變成邏輯錯誤。

因此 Kotlin 寧可選擇「不讓它編譯」也不要「讓使用者在執行期踩雷」。而 MutableList<*> 的語意正是:「型別未知,我們沒有權利寫入」。

4. 實作:在 Expense Tracker 做清單除錯輸出

為了不讓內容停留在理論,我們把 List<*> 的想法放進我們的主控台 Expense Tracker(就是那個儲存支出並顯示報表的專案)。我們常常想快速看一下「集合裡目前到底放了什麼」,又不想為每種型別寫十個不同函式。

我們做一個小工具「印出清單」(一般函式,不用 extension):

data class Expense(val title: String, val amount: Double)

fun printList(label: String, xs: List<*>) {
    println("== $label (size=${xs.size}) ==")
    for (x in xs) println(x)
}

fun main() {
    val expenses = listOf(
        Expense("Coffee", 3.5),
        Expense("Book", 12.0)
    )
    val tags = listOf("food", "education")

    printList("Expenses", expenses)
    // == Expenses (size=2) ==
    // Expense(title=Coffee, amount=3.5)
    // Expense(title=Book, amount=12.0)

    printList("Tags", tags)
    // == Tags (size=2) ==
    // food
    // education
}

注意一個關鍵效果:printList 不可能「知道」元素型別,但這是正常且合理的。它不負責商業邏輯,它只是輸出用工具。在這種位置上,List<*> 非常剛好。

預告:只列印前 N 個元素

再加一點實用性:只印出前 N 個元素,避免超大清單把主控台「打爆」。

fun printPreview(label: String, xs: List<*>, limit: Int) {
    val n = if (xs.size < limit) xs.size else limit
    println("== $label (showing $n of ${xs.size}) ==")
    for (i in 0 until n) println(xs[i])
}

fun main() {
    val nums = listOf(1, 2, 3, 4, 5)
    printPreview("Numbers", nums, limit = 3)
    // == Numbers (showing 3 of 5) ==
    // 1
    // 2
    // 3
}

你會發現它讀起來很自然:我們不知道元素型別——而且也不需要知道,因為「除錯輸出」這個任務只需要列印,不需要任何額外操作。

5. 使用 is List<*> 做檢查並解析元素

在真實程式裡,有時候你拿到的是 Any(例如來自非常泛用的 API、JSON tree、Map<String, Any?>,或外部函式庫),你想判斷:這是清單嗎?

Kotlin 允許這種檢查:x is List<*>。這點很重要:檢查「這是未知元素的清單」是合法的;Kotlin 也直接在範例裡指出,此時元素型別會是 Any?。

做一個迷你函式:

fun describeValue(x: Any?) {
    if (x is List<*>) {
        println("This is a list, size=${x.size}") // ok
    } else {
        println("This is not a list")
    }
}

fun main() {
    describeValue(listOf(1, 2, 3)) // This is a list, size=3
    describeValue("hello")         // This is not a list
}

接下來常見的下一步是:「如果它是清單,那我試著取出其中的字串。」這裡要記得,元素是 Any?,你需要用型別檢查過濾。

fun printOnlyStrings(x: Any?) {
    if (x !is List<*>) return

    for (item in x) {
        if (item is String) {
            println(item.uppercase())
        }
    }
}

fun main() {
    printOnlyStrings(listOf("a", 1, "b", null))
    // A
    // B
}

這看起來比「魔法式轉型」囉嗦一些,但它可預測、也不會把你的程式變成地雷陣。

6. out/in 投影與 *

很有用的一個心智模型是分清楚兩種情境:「我知道元素大概是什麼,但我想限制操作」vs「我完全不知道元素是什麼」。

在 MutableList<out Number> 中,你知道這是「某種數字的清單」,因此你可以安全地把讀取當作 Number,但不能新增(因為「到底是哪種數字」未知)。在 MutableList<in Int> 中,你知道可以安全新增 Int,但讀取時你只能以最泛用的型別(通常是 Any?)來看待。

而 MutableList<*> 則是「我什麼都不知道」:除了 Any? 之外沒有更具體的上界、也沒有任何可用於寫入的下界。因此它對寫入最嚴格。

可以把它想成一個「資訊量滑桿」:

flowchart LR
    A["MutableList⟨Any?⟩
(know everything: can read Any? and write Any?)"] --> B["MutableList⟨out Number⟩
(know the upper bound: read Number, do not write)"] --> C["MutableList⟨*⟩
(know almost nothing: read Any?, do not write)"]

沒錯,這是簡化(就像所有好的教學解釋一樣),但它非常好用:你對型別知道得越少,Kotlin 允許你做的事就越少。

7. 使用 star-projection * 的常見錯誤

錯誤 1:以為 List<*> 就是「Any 的清單」,然後立刻呼叫元素的方法。
當你寫 val x: Any? = xs[0],接著嘗試 x.length,編譯器當然無法理解你為什麼認定它是字串。正確做法是先做型別檢查(if (x is String)),然後再操作字串屬性。

錯誤 2:嘗試往 MutableList<*> 加元素,並驚訝於連 null 都不行。
這是新手最容易覺得「很委屈」的點,因為直覺上 null 很通用。但 MutableList<*> 的寫入邏輯相當於「in Nothing」:沒有任何型別安全的值可以寫入(null 也不符合)。如果你真的需要新增元素,就代表函式契約必須使用具體的「輸入」型別,例如 MutableList<in Int> 或 MutableList<Any?>,而不是 *。

錯誤 3:混淆 MutableList<*> 與 MutableList<Any?>,然後「保險起見」就選星號。
星號不是「更通用」,而是「更嚴格」。它非常適合「讀取/遍歷/列印」的場景,但在你想往裡面放東西時就會很不方便。如果你的函式語意是要填充清單,那你就不在 * 的世界,而是在 in 的世界。

錯誤 4:用不安全的型別轉型(as MutableList<String>)取代星號,只為了「先讓它跑起來」。
有時候會很想「硬壓過編譯器」:寫個 as 就往下做。但在 generics 裡這通常會變成:程式能編譯,然後在某個意想不到的地方於執行期爆掉。List<*> 與 MutableList<*> 的價值在於:你可以誠實地說「我不知道型別」——然後編譯器會阻止你做危險操作。

錯誤 5:期待 x is List<*> 的檢查會自動帶來對元素型別的資訊。
這個檢查只回答「是不是清單」。通過之後,元素依然是 Any?,這很正常。如果你想知道裡面是字串、數字,或你的 Expense,就必須檢查元素本身(is String、is Int、is Expense),或改用一個「事先已知型別」的函式契約。

1
任務
Kotlin SELF, 等級 36, 課堂 3
上鎖
除錯列印
除錯列印
1
任務
Kotlin SELF, 等級 36, 課堂 3
上鎖
簡短預覽
簡短預覽
1
任務
Kotlin SELF, 等級 36, 課堂 3
上鎖
評論長度
評論長度
1
任務
Kotlin SELF, 等級 36, 課堂 3
上鎖
快速說明
快速說明
留言
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION