Java 與 Kotlin 中的集合

集合是數量可變（可能為零）的項目群組，這些項目對於所要解決的問題具有重要意義，並且是常用的操作對象。本指南解釋並比較了 Java 與 Kotlin 中的集合概念和操作。它將幫助您從 Java 遷移到 Kotlin，並以純正的 Kotlin 方式編寫程式碼。

本指南的第一部分包含了 Java 與 Kotlin 中相同集合操作的快速詞彙表。它分為在 Java 和 Kotlin 中相同的操作和僅存在於 Kotlin 的標準函式庫中的操作。本指南的第二部分從可變性開始，透過具體案例解釋了一些差異。

有關集合的介紹，請參閱集合概述或觀看 Kotlin 開發者推廣者 Sebastian Aigner 的這段影片。

以下所有範例僅使用 Java 和 Kotlin 標準函式庫的 API。

Java 與 Kotlin 中相同的操作

在 Kotlin 中，許多集合操作與 Java 中的對應操作看起來完全相同。

對 Lists、Sets、Queues 和 Deques 的操作

描述	常用操作	更多 Kotlin 替代方案
添加元素	`add()`, `addAll()`	使用 `plusAssign` (`+=`) 運算子：`collection += element`，`collection += anotherCollection`。
檢查集合是否包含一個或多個元素	`contains()`, `containsAll()`	使用 `in` 關鍵字以運算子形式呼叫 `contains()`：`element in collection`。
檢查集合是否為空	`isEmpty()`	使用 `isNotEmpty()` 檢查集合是否不為空。
在特定條件下移除	`removeIf()`
只保留選定的元素	`retainAll()`
從集合中移除所有元素	`clear()`
從集合中取得 stream	`stream()`	Kotlin 有自己的方式來處理 stream：序列以及像 `map()` 和 `filter()` 這樣的方法。
從集合中取得 iterator	`iterator()`

對 Maps 的操作

描述	常用操作	更多 Kotlin 替代方案
添加元素	`put()`, `putAll()`, `putIfAbsent()`	在 Kotlin 中，賦值操作 `map[key] = value` 的行為與 `put(key, value)` 相同。此外，您可以使用 `plusAssign` (`+=`) 運算子：`map += Pair(key, value)` 或 `map += anotherMap`。
替換一個或多個元素	`put()`, `replace()`, `replaceAll()`	使用索引運算子 `map[key] = value` 而非 `put()` 和 `replace()`。
取得元素	`get()`	使用索引運算子來取得元素：`map[index]`。
檢查映射是否包含一個或多個元素	`containsKey()`, `containsValue()`	使用 `in` 關鍵字以運算子形式呼叫 `contains()`：`element in map`。
檢查映射是否為空	`isEmpty()`	使用 `isNotEmpty()` 檢查映射是否不為空。
移除元素	`remove(key)`, `remove(key, value)`	使用 `minusAssign` (`-=`) 運算子：`map -= key`。
從映射中移除所有元素	`clear()`
從映射中取得 stream	對 entries、keys 或 values 的 `stream()`

僅適用於 Lists 的操作

描述	常用操作	更多 Kotlin 替代方案
取得元素的索引	`indexOf()`
取得元素的最後索引	`lastIndexOf()`
取得元素	`get()`	使用索引運算子來取得元素：`list[index]`。
取得子列表	`subList()`
替換一個或多個元素	`set()`, `replaceAll()`	使用索引運算子而非 `set()`：`list[index] = value`。

稍有不同的操作

對任何集合類型的操作

描述	Java	Kotlin
取得集合的大小	`size()`	`count()`, `size`
平面存取巢狀集合元素	`collectionOfCollections.forEach(flatCollection::addAll)` 或 `collectionOfCollections.stream().flatMap().collect()`	`flatten()` 或 `flatMap()`
將給定的函數應用於每個元素	`stream().map().collect()`	`map()`
依序對集合元素應用所提供的操作並回傳累計結果	`stream().reduce()`	`reduce()`, `fold()`
依分類器分組元素並計數	`stream().collect(Collectors.groupingBy(classifier, counting()))`	`eachCount()`
依條件篩選	`stream().filter().collect()`	`filter()`
檢查集合元素是否滿足條件	`stream().noneMatch()`, `stream().anyMatch()`, `stream().allMatch()`	`none()`, `any()`, `all()`
排序元素	`stream().sorted().collect()`	`sorted()`
取前 N 個元素	`stream().limit(N).collect()`	`take(N)`
依判斷式取元素	`stream().takeWhile().collect()`	`takeWhile()`
跳過前 N 個元素	`stream().skip(N).collect()`	`drop(N)`
依判斷式跳過元素	`stream().dropWhile().collect()`	`dropWhile()`
從集合元素及與其關聯的特定值建立映射	`stream().collect(toMap(keyMapper, valueMapper))`	`associate()`

若要對映射執行上述所有操作，您首先需要取得映射的 entrySet。

對 Lists 的操作

描述	Java	Kotlin
將列表按自然順序排序	`sort(null)`	`sort()`
將列表按降序排序	`sort(comparator)`	`sortDescending()`
從列表中移除元素	`remove(index)`, `remove(element)`	`removeAt(index)`, `remove(element)` 或 `collection -= element`
以特定值填充列表的所有元素	`Collections.fill()`	`fill()`
從列表中取得唯一元素	`stream().distinct().toList()`	`distinct()`

Java 標準函式庫中不存在的操作

zip(), unzip() – 轉換集合。
aggregate() – 依條件分組。
takeLast(), takeLastWhile(), dropLast(), dropLastWhile() – 依判斷式取用或捨棄元素。
slice(), chunked(), windowed() – 檢索集合部分。
加 (+) 和減 (-) 運算子 – 添加或移除元素。

如果您想深入了解 zip()、chunked()、windowed() 和其他一些操作，請觀看 Sebastian Aigner 關於 Kotlin 進階集合操作的這段影片：

可變性

在 Java 中，存在可變集合：

java

// Java
// This list is mutable!
public List<Customer> getCustomers() { ... }

部分可變的：

java

// Java
List<String> numbers = Arrays.asList("one", "two", "three", "four");
numbers.add("five"); // Fails in runtime with `UnsupportedOperationException`

以及不可變的：

java

// Java
List<String> numbers = new LinkedList<>();
// This list is immutable!
List<String> immutableCollection = Collections.unmodifiableList(numbers);
immutableCollection.add("five"); // Fails in runtime with `UnsupportedOperationException`

如果您在 IntelliJ IDEA 中編寫最後兩段程式碼，IDE 會警告您正在嘗試修改一個不可變的物件。此程式碼將會編譯並在執行期因 UnsupportedOperationException 失敗。您無法透過查看其類型來判斷集合是否可變。

與 Java 不同，在 Kotlin 中，您可以根據需求明確宣告可變或唯讀集合。如果您嘗試修改唯讀集合，程式碼將無法編譯：

kotlin

// Kotlin
val numbers = mutableListOf("one", "two", "three", "four")
numbers.add("five")            // This is OK
val immutableNumbers = listOf("one", "two")
//immutableNumbers.add("five") // Compilation error - Unresolved reference: add

在 Kotlin 編碼慣例頁面閱讀更多關於不可變性的資訊。

協變性

在 Java 中，您無法將具有後代類型的集合傳遞給接受祖先類型集合的函數。例如，如果 Rectangle 擴展 Shape，您不能將 Rectangle 元素的集合傳遞給接受 Shape 元素集合的函數。為了使程式碼可編譯，請使用 ? extends Shape 類型，這樣函數就可以接受 Shape 的任何繼承者的集合：

java

// Java
class Shape {}

class Rectangle extends Shape {}

public void doSthWithShapes(List<? extends Shape> shapes) {
/* If using just List<Shape>, the code won't compile when calling
this function with the List<Rectangle> as the argument as below */
}

public void main() {
    var rectangles = List.of(new Rectangle(), new Rectangle());
    doSthWithShapes(rectangles);
}

在 Kotlin 中，唯讀集合類型是協變的。這意味著如果 Rectangle 類別繼承自 Shape 類別，您可以在任何需要 List<Shape> 類型的地方使用 List<Rectangle> 類型。換句話說，集合類型與元素類型具有相同的子類型關係。映射在值類型上是協變的，但在鍵類型上不是。可變集合不是協變的——這會導致執行期失敗。

kotlin

// Kotlin
open class Shape(val name: String)

class Rectangle(private val rectangleName: String) : Shape(rectangleName)

fun doSthWithShapes(shapes: List<Shape>) {
    println("The shapes are: ${shapes.joinToString { it.name }}")
}

fun main() {
    val rectangles = listOf(Rectangle("rhombus"), Rectangle("parallelepiped"))
    doSthWithShapes(rectangles)
}

在此處閱讀更多關於集合類型的資訊。

範圍和進度

在 Kotlin 中，您可以使用範圍創建區間。例如，Version(1, 11)..Version(1, 30) 包含從 1.11 到 1.30 的所有版本。您可以使用 in 運算子檢查您的版本是否在範圍內：Version(0, 9) in versionRange。

在 Java 中，您需要手動檢查 Version 是否符合兩個邊界：

java

// Java
class Version implements Comparable<Version> {

    int major;
    int minor;

    Version(int major, int minor) {
        this.major = major;
        this.minor = minor;
    }

    @Override
    public int compareTo(Version o) {
        if (this.major != o.major) {
            return this.major - o.major;
        }
        return this.minor - o.minor;
    }
}

public void compareVersions() {
    var minVersion = new Version(1, 11);
    var maxVersion = new Version(1, 31);

   System.out.println(
           versionIsInRange(new Version(0, 9), minVersion, maxVersion));
   System.out.println(
           versionIsInRange(new Version(1, 20), minVersion, maxVersion));
}

public Boolean versionIsInRange(Version versionToCheck, Version minVersion, 
                                Version maxVersion) {
    return versionToCheck.compareTo(minVersion) >= 0 
            && versionToCheck.compareTo(maxVersion) <= 0;
}

在 Kotlin 中，您將範圍作為一個整體物件來操作。您不需要創建兩個變數並比較 Version 與它們：

kotlin

// Kotlin
class Version(val major: Int, val minor: Int): Comparable<Version> {
    override fun compareTo(other: Version): Int {
        if (this.major != other.major) {
            return this.major - other.major
        }
        return this.minor - other.minor
    }
}

fun main() {
    val versionRange = Version(1, 11)..Version(1, 30)

    println(Version(0, 9) in versionRange)
    println(Version(1, 20) in versionRange)
}

一旦您需要排除其中一個邊界，例如檢查版本是否大於或等於 (>=) 最小版本且小於 (<) 最大版本時，這些包含範圍將無濟於事。

多準則比較

在 Java 中，若要依多個準則比較物件，您可以使用 Comparator 介面中的 comparing() 和 thenComparingX() 函數。例如，依姓名和年齡比較人物：

java

class Person implements Comparable<Person> {
    String name;
    int age;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return this.name + " " + age;
    }
}

public void comparePersons() {
    var persons = List.of(new Person("Jack", 35), new Person("David", 30), 
            new Person("Jack", 25));
    System.out.println(persons.stream().sorted(Comparator
            .comparing(Person::getName)
            .thenComparingInt(Person::getAge)).collect(toList()));
}

在 Kotlin 中，您只需列舉您想要比較的欄位：

kotlin

data class Person(
    val name: String,
    val age: Int
)

fun main() {
    val persons = listOf(Person("Jack", 35), Person("David", 30), 
        Person("Jack", 25))
    println(persons.sortedWith(compareBy(Person::name, Person::age)))
}

序列

在 Java 中，您可以這樣產生數字序列：

java

// Java
int sum = IntStream.iterate(1, e -> e + 3)
    .limit(10).sum();
System.out.println(sum); // Prints 145

在 Kotlin 中，請使用序列。序列的多步驟處理在可能的情況下會延遲執行——實際計算只在請求整個處理鏈的結果時發生。

kotlin

fun main() {
    // Kotlin
    val sum = generateSequence(1) {
        it + 3
    }.take(10).sum()
    println(sum) // Prints 145
}

序列可以減少執行某些過濾操作所需的步驟數量。請參閱序列處理範例，其中顯示了 Iterable 和 Sequence 之間的差異。

從列表中移除元素

在 Java 中，remove() 函數接受要移除元素的索引。

當移除整數元素時，請使用 Integer.valueOf() 函數作為 remove() 函數的參數：

java

// Java
public void remove() {
    var numbers = new ArrayList<>();
    numbers.add(1);
    numbers.add(2);
    numbers.add(3);
    numbers.add(1);
    numbers.remove(1); // This removes by index
    System.out.println(numbers); // [1, 3, 1]
    numbers.remove(Integer.valueOf(1));
    System.out.println(numbers); // [3, 1]
}

在 Kotlin 中，有兩種元素移除方式：依索引使用 removeAt() 和依值使用 remove()。

kotlin

fun main() {
    // Kotlin
    val numbers = mutableListOf(1, 2, 3, 1)
    numbers.removeAt(0)
    println(numbers) // [2, 3, 1]
    numbers.remove(1)
    println(numbers) // [2, 3]
}

遍歷映射

在 Java 中，您可以透過 forEach 遍歷映射：

java

// Java
numbers.forEach((k,v) -> System.out.println("Key = " + k + ", Value = " + v));

在 Kotlin 中，使用 for 迴圈或 forEach（類似於 Java 的 forEach）來遍歷映射：

kotlin

// Kotlin
for ((k, v) in numbers) {
    println("Key = $k, Value = $v")
}
// Or
numbers.forEach { (k, v) -> println("Key = $k, Value = $v") }

取得可能為空集合的第一個和最後一個項目

在 Java 中，您可以透過檢查集合大小並使用索引來安全地取得第一個和最後一個項目：

java

// Java
var list = new ArrayList<>();
//...
if (list.size() > 0) {
    System.out.println(list.get(0));
    System.out.println(list.get(list.size() - 1));
}

您也可以將 getFirst() 和 getLast() 函數用於 Deque 及其繼承者：

java

// Java
var deque = new ArrayDeque<>();
//...
if (deque.size() > 0) {
    System.out.println(deque.getFirst());
    System.out.println(deque.getLast());
}

在 Kotlin 中，有特殊的函數 firstOrNull() 和 lastOrNull()。使用Elvis 運算子，您可以根據函數的結果立即執行進一步的操作。例如，firstOrNull()：

kotlin

// Kotlin
val emails = listOf<String>() // Might be empty
val theOldestEmail = emails.firstOrNull() ?: ""
val theFreshestEmail = emails.lastOrNull() ?: ""

從列表中建立集合

在 Java 中，若要從 List 建立 Set，您可以使用 Set.copyOf 函數：

java

// Java
public void listToSet() {
    var sourceList = List.of(1, 2, 3, 1);
    var copySet = Set.copyOf(sourceList);
    System.out.println(copySet);
}

在 Kotlin 中，請使用 toSet() 函數：

kotlin

fun main() {
    // Kotlin
    val sourceList = listOf(1, 2, 3, 1)
    val copySet = sourceList.toSet()
    println(copySet)
}

分組元素

在 Java 中，您可以使用 Collectors 函數 groupingBy() 來分組元素：

java

// Java
public void analyzeLogs() {
    var requests = List.of(
        new Request("https://kotlinlang.org/docs/home.html", 200),
        new Request("https://kotlinlang.org/docs/home.html", 400),
        new Request("https://kotlinlang.org/docs/comparison-to-java.html", 200)
    );
    var urlsAndRequests = requests.stream().collect(
            Collectors.groupingBy(Request::getUrl));
    System.out.println(urlsAndRequests);
}

在 Kotlin 中，請使用 groupBy() 函數：

kotlin

data class Request(
    val url: String,
    val responseCode: Int
)

fun main() {
    // Kotlin
    val requests = listOf(
        Request("https://kotlinlang.org/docs/home.html", 200),
        Request("https://kotlinlang.org/docs/home.html", 400),
        Request("https://kotlinlang.org/docs/comparison-to-java.html", 200)
    )
    println(requests.groupBy(Request::url))
}

過濾元素

在 Java 中，若要從集合中過濾元素，您需要使用 Stream API。 Stream API 具有 中間 (intermediate) 和 終端 (terminal) 操作。filter() 是一個中間操作，它返回一個 stream。若要接收集合作為輸出，您需要使用終端操作，例如 collect()。例如，只保留那些鍵以 1 結尾且值大於 10 的配對：

java

// Java
public void filterEndsWith() {
    var numbers = Map.of("key1", 1, "key2", 2, "key3", 3, "key11", 11);
    var filteredNumbers = numbers.entrySet().stream()
        .filter(entry -> entry.getKey().endsWith("1") && entry.getValue() > 10)
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    System.out.println(filteredNumbers);
}

在 Kotlin 中，過濾功能已內建於集合中，並且 filter() 返回被過濾的相同集合類型。所以，您只需編寫 filter() 及其判斷式：

kotlin

fun main() {
    // Kotlin
    val numbers = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key11" to 11)
    val filteredNumbers = numbers.filter { (key, value) -> key.endsWith("1") && value > 10 }
    println(filteredNumbers)
}

在此處了解更多關於過濾映射的資訊。

依類型篩選元素

在 Java 中，若要依類型篩選元素並對其執行操作，您需要使用 instanceof 運算子檢查其類型，然後進行類型轉換：

java

// Java
public void objectIsInstance() {
    var numbers = new ArrayList<>();
    numbers.add(null);
    numbers.add(1);
    numbers.add("two");
    numbers.add(3.0);
    numbers.add("four");
    System.out.println("All String elements in upper case:");
    numbers.stream().filter(it -> it instanceof String)
        .forEach( it -> System.out.println(((String) it).toUpperCase()));
}

在 Kotlin 中，您只需在集合上呼叫 filterIsInstance<NEEDED_TYPE>()，類型轉換則由智慧型轉型完成：

kotlin

// Kotlin
fun main() {
    // Kotlin
    val numbers = listOf(null, 1, "two", 3.0, "four")
    println("All String elements in upper case:")
    numbers.filterIsInstance<String>().forEach {
        println(it.uppercase())
    }
}

測試判斷式

某些任務要求您檢查所有、沒有或任何元素是否滿足條件。在 Java 中，您可以透過 Stream API 函數 allMatch()、noneMatch() 和 anyMatch() 來執行所有這些檢查：

java

// Java
public void testPredicates() {
    var numbers = List.of("one", "two", "three", "four");
    System.out.println(numbers.stream().noneMatch(it -> it.endsWith("e"))); // false
    System.out.println(numbers.stream().anyMatch(it -> it.endsWith("e"))); // true
    System.out.println(numbers.stream().allMatch(it -> it.endsWith("e"))); // false
}

在 Kotlin 中，擴充函數 none()、any() 和 all() 可用於每個 Iterable 物件：

kotlin

fun main() {
// Kotlin
    val numbers = listOf("one", "two", "three", "four")
    println(numbers.none { it.endsWith("e") })
    println(numbers.any { it.endsWith("e") })
    println(numbers.all { it.endsWith("e") })
}

了解更多關於測試判斷式的資訊。

集合轉換操作

配對元素

在 Java 中，您可以透過同時迭代兩個集合中相同位置的元素來建立配對：

java

// Java
public void zip() {
    var colors = List.of("red", "brown");
    var animals = List.of("fox", "bear", "wolf");

    for (int i = 0; i < Math.min(colors.size(), animals.size()); i++) {
        String animal = animals.get(i);
        System.out.println("The " + animal.substring(0, 1).toUpperCase()
               + animal.substring(1) + " is " + colors.get(i));
   }
}

如果您想做比單純將元素配對列印到輸出更複雜的事情，可以使用 Records。在上面的範例中，record 會是 record AnimalDescription(String animal, String color) {}。

在 Kotlin 中，使用 zip() 函數執行相同的操作：

kotlin

fun main() {
    // Kotlin
    val colors = listOf("red", "brown")
    val animals = listOf("fox", "bear", "wolf")

    println(colors.zip(animals) { color, animal -> 
        "The ${animal.replaceFirstChar { it.uppercase() }} is $color" })
}

zip() 返回 Pair 物件的 List。

如果集合大小不同，zip() 的結果將以較小的大小為準。較大集合的最後幾個元素不會包含在結果中。

關聯元素

在 Java 中，您可以使用 Stream API 將元素與特性關聯起來：

java

// Java
public void associate() {
    var numbers = List.of("one", "two", "three", "four");
    var wordAndLength = numbers.stream()
        .collect(toMap(number -> number, String::length));
    System.out.println(wordAndLength);
}

在 Kotlin 中，請使用 associate() 函數：

kotlin

fun main() {
    // Kotlin
    val numbers = listOf("one", "two", "three", "four")
    println(numbers.associateWith { it.length })
}

接下來？

造訪 Kotlin Koans – 完成練習以學習 Kotlin 語法。每個練習都建立為一個失敗的單元測試，您的任務是使其通過。
瀏覽其他 Kotlin 慣用寫法。
了解如何使用 Java 到 Kotlin 轉換器將現有的 Java 程式碼轉換為 Kotlin。
探索 Kotlin 中的集合。

如果您有喜歡的慣用寫法，歡迎透過發送 pull request 來分享。

基本類型

建構器

Spring

使用 Spring Boot 建立一個包含資料庫的 RESTful Web 服務

Java 遷移至 Kotlin 指南

C 互通

Objective-C 互通

記憶體管理器

參考與提示

用於 JS 平台的 Kotlin

概覽

執行 Dokka

輸出格式

最小化心智複雜度

Java 與 Kotlin 中的集合

Java 與 Kotlin 中相同的操作

對 Lists、Sets、Queues 和 Deques 的操作

對 Maps 的操作

僅適用於 Lists 的操作

稍有不同的操作

對任何集合類型的操作

對 Lists 的操作

Java 標準函式庫中不存在的操作

可變性

協變性

範圍和進度

多準則比較

序列

從列表中移除元素

遍歷映射

取得可能為空集合的第一個和最後一個項目

從列表中建立集合

分組元素

過濾元素

依類型篩選元素

測試判斷式

集合轉換操作

配對元素

關聯元素

接下來？

使用 Spring Boot 建立一個包含資料庫的 RESTful Web 服務

Java 與 Kotlin 中的集合 ​

Java 與 Kotlin 中相同的操作 ​

對 Lists、Sets、Queues 和 Deques 的操作 ​

對 Maps 的操作 ​

僅適用於 Lists 的操作 ​

稍有不同的操作 ​

對任何集合類型的操作 ​

對 Lists 的操作 ​

Java 標準函式庫中不存在的操作 ​

可變性 ​

協變性 ​

範圍和進度 ​

多準則比較 ​

序列 ​

從列表中移除元素 ​

遍歷映射 ​

取得可能為空集合的第一個和最後一個項目 ​

從列表中建立集合 ​

分組元素 ​

過濾元素 ​

依類型篩選元素 ​

測試判斷式 ​

集合轉換操作 ​

配對元素 ​

關聯元素 ​

接下來？ ​

Java 與 Kotlin 中的集合

Java 與 Kotlin 中相同的操作

對 Lists、Sets、Queues 和 Deques 的操作

對 Maps 的操作

僅適用於 Lists 的操作

稍有不同的操作

對任何集合類型的操作

對 Lists 的操作

Java 標準函式庫中不存在的操作

可變性

協變性

範圍和進度

多準則比較

序列

從列表中移除元素

遍歷映射

取得可能為空集合的第一個和最後一個項目

從列表中建立集合

分組元素

過濾元素

依類型篩選元素

測試判斷式

集合轉換操作

配對元素

關聯元素

接下來？