Skip to content

Java と Kotlin におけるコレクション ​

コレクション(Collections) とは、解決すべき課題にとって意味を持ち、共通の操作が行われる可変個(0 個の場合もあります)のアイテムの集まりです。 このガイドでは、Java と Kotlin におけるコレクションの概念と操作を説明し、比較します。 Java から Kotlin への移行を支援し、本物の Kotlin らしい方法でコードを書けるようにすることを目的としています。

このガイドの最初のパートには、Java と Kotlin で同じコレクションに対する操作のクイック用語集(対応表)が含まれています。 これは、Java と Kotlin で同じ操作 と Kotlin にのみ存在する操作 に分かれています。 可変性(Mutability) から始まるガイドの第 2 パートでは、具体的なケースを見ながらいくつかの違いを説明します。

コレクションの概要については、コレクションの概要 を参照するか、Kotlin デベロッパーアドボケイトの Sebastian Aigner によるこちらの ビデオ をご覧ください。

以下の例はすべて、Java および Kotlin の標準ライブラリ API のみを使用しています。

Java と Kotlin で同じ操作 ​

Kotlin には、Java の対応するものとまったく同じように見えるコレクション操作が多数あります。

List、Set、Queue、Deque に対する操作 ​

説明一般的な操作より Kotlin らしい代替手段
要素を追加するadd(), addAll()plusAssign (+=) 演算子 を使用: collection += element, collection += anotherCollection。
コレクションに要素が含まれているか確認するcontains(), containsAll()in キーワード を使用して演算子の形式で contains() を呼び出す: element in collection。
コレクションが空かどうかを確認するisEmpty()コレクションが空でないことを確認するには isNotEmpty() を使用。
特定の条件で削除するremoveIf()
選択した要素のみを残すretainAll()
コレクションからすべての要素を削除するclear()
コレクションからストリームを取得するstream()Kotlin にはストリームを処理する独自の方法があります: シーケンス(sequences) や map()、filter() などのメソッド。
コレクションからイテレータを取得するiterator()

Map に対する操作 ​

説明一般的な操作より Kotlin らしい代替手段
要素を追加するput(), putAll(), putIfAbsent()Kotlin では、代入 map[key] = value は put(key, value) と同じように動作します。また、plusAssign (+=) 演算子 を使用することもできます: map += Pair(key, value) または map += anotherMap。
要素を置き換えるput(), replace(), replaceAll()put() や replace() の代わりにインデックス演算子 map[key] = value を使用。
要素を取得するget()要素を取得するためにインデックス演算子を使用: map[index]。
Map に要素が含まれているか確認するcontainsKey(), containsValue()in キーワード を使用して演算子の形式で contains() を呼び出す: element in map。
Map が空かどうかを確認するisEmpty()Map が空でないことを確認するには isNotEmpty() を使用。
要素を削除するremove(key), remove(key, value)minusAssign (-=) 演算子 を使用: map -= key。
Map からすべての要素を削除するclear()
Map からストリームを取得するエントリ、キー、または値に対する stream()

List にのみ存在する操作 ​

説明一般的な操作より Kotlin らしい代替手段
要素のインデックスを取得するindexOf()
要素の最後のインデックスを取得するlastIndexOf()
要素を取得するget()要素を取得するためにインデックス演算子を使用: list[index]。
サブリストを取得するsubList()
要素を置き換えるset(), replaceAll()set() の代わりにインデックス演算子を使用: list[index] = value。

少し異なる操作 ​

任意のコレクション型に対する操作 ​

説明JavaKotlin
コレクションのサイズを取得するsize()count(), size
ネストされたコレクション要素へフラットにアクセスするcollectionOfCollections.forEach(flatCollection::addAll) または collectionOfCollections.stream().flatMap().collect()flatten() または flatMap()
指定された関数をすべての要素に適用するstream().map().collect()map()
コレクション要素に指定された操作を順次適用し、蓄積された結果を返すstream().reduce()reduce(), fold()
分類基準(classifier)によって要素をグループ化し、カウントする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)
述語(predicate)に基づいて要素を取得するstream().takeWhile().collect()takeWhile()
最初の N 個の要素をスキップするstream().skip(N).collect()drop(N)
述語(predicate)に基づいて要素をスキップするstream().dropWhile().collect()dropWhile()
コレクション要素とそれに関連付けられた特定の値から Map を構築するstream().collect(toMap(keyMapper, valueMapper))associate()

上記のすべての操作を Map に対して実行するには、まず Map の entrySet を取得する必要があります。

List に対する操作 ​

説明JavaKotlin
リストを自然順序でソートする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()、chunked()、windowed()、およびその他の操作について詳しく知りたい場合は、Sebastian Aigner による Kotlin の高度なコレクション操作に関するこちらのビデオをご覧ください:

可変性 (Mutability) ​

Java には、可変(mutable)なコレクションがあります:

java
// Java
// このリストは可変です!
public List<Customer> getCustomers() { ... }

部分的に可変なものもあります:

java
// Java
List<String> numbers = Arrays.asList("one", "two", "three", "four");
numbers.add("five"); // 実行時に `UnsupportedOperationException` で失敗します

そして不変(immutable)なものもあります:

java
// Java
List<String> numbers = new LinkedList<>();
// このリストは不変です!
List<String> immutableCollection = Collections.unmodifiableList(numbers);
immutableCollection.add("five"); // 実行時に `UnsupportedOperationException` で失敗します

IntelliJ IDEA で最後の 2 つのコードを書くと、不変なオブジェクトを変更しようとしているという警告が IDE から表示されます。 このコードはコンパイルは通りますが、実行時に UnsupportedOperationException で失敗します。型を見るだけでは、コレクションが可変かどうかを判断することはできません。

Java とは異なり、Kotlin ではニーズに応じて可変コレクションまたは読み取り専用(read-only)コレクションを明示的に宣言します。 読み取り専用コレクションを変更しようとすると、コードはコンパイルされません:

kotlin
// Kotlin
val numbers = mutableListOf("one", "two", "three", "four")
numbers.add("five")            // これは OK
val immutableNumbers = listOf("one", "two")
//immutableNumbers.add("five") // コンパイルエラー - Unresolved reference: add

不変性についての詳細は、Kotlin コーディング規約 ページをご覧ください。

共変性 (Covariance) ​

Java では、子孫(派生)型のコレクションを、祖先(基底)型のコレクションを受け取る関数に渡すことはできません。 たとえば、Rectangle が Shape を拡張している場合、Rectangle 要素のコレクションを Shape 要素のコレクションを受け取る関数に渡すことはできません。 コードをコンパイルできるようにするには、関数が Shape の任意の後継クラスのコレクションを受け取れるように、? extends Shape 型を使用します:

java
// Java
class Shape {}

class Rectangle extends Shape {}

public void doSthWithShapes(List<? extends Shape> shapes) {
/* 単に List<Shape> を使用した場合、以下のように List<Rectangle> を
引数としてこの関数を呼び出すとコードはコンパイルされません */
}

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

Kotlin では、読み取り専用コレクション型は共変(covariant)です。つまり、Rectangle クラスが Shape クラスを継承している場合、List<Shape> 型が必要とされる場所ならどこでも List<Rectangle> 型を使用できます。 言い換えると、コレクション型は要素型と同じサブタイプ関係を持ちます。Map は値の型に対しては共変ですが、キーの型に対しては共変ではありません。 可変コレクションは共変ではありません。共変にしてしまうと実行時エラーにつながるためです。

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)
}

コレクション型 の詳細についてはこちらをご覧ください。

範囲と数列 (Ranges and progressions) ​

Kotlin では、範囲(ranges) を使用して区間を作成できます。たとえば、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 では、範囲を 1 つのオブジェクトとして操作します。2 つの変数を作成して 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)
}

バージョンが最小バージョン以上(>=)かつ最大バージョン未満(<)であるかを確認するなど、境界のいずれかを除外する必要がある場合、これらの両端を含む(inclusive な)範囲は利用できません。

複数の基準による比較 ​

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)))
}

シーケンス (Sequences) ​

Java では、次のようにして数列を生成できます:

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

Kotlin では、シーケンス を使用します。シーケンスの複数ステップの処理は、可能な限り遅延(lazy)実行されます。 実際の計算は、処理チェーン全体の結果が要求されたときにのみ行われます。

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

シーケンスを使用すると、一部のフィルタリング操作の実行に必要なステップ数を減らすことができます。 Iterable と Sequence の違いを示す シーケンスの処理例 をご覧ください。

リストからの要素の削除 ​

Java では、remove() 関数は削除する要素のインデックスを受け取ります。

整数の要素を削除する場合は、remove() 関数の引数として Integer.valueOf() 関数を使用します:

java
// Java
public void remove() {
    var numbers = new ArrayList<>();
    numbers.add(1);
    numbers.add(2);
    numbers.add(3);
    numbers.add(1);
    numbers.remove(1); // これはインデックスによって削除します
    System.out.println(numbers); // [1, 3, 1]
    numbers.remove(Integer.valueOf(1));
    System.out.println(numbers); // [3, 1]
}

Kotlin では、removeAt() によるインデックス指定の削除と、 remove() による値指定の削除の 2 種類があります。

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]
}

Map の走査 (Traverse a map) ​

Java では、forEach を使用して Map を走査できます:

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

Kotlin では、Java の forEach と同様の forEach や for ループを使用して Map を走査します:

kotlin
// Kotlin
for ((k, v) in numbers) {
    println("Key = $k, Value = $v")
}
// または
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));
}

JDK 21 以降では、すべての SequencedCollection 実装で利用可能な getFirst() および getLast() メソッドを使用することもできます。これには、すべての List 実装や LinkedHashSet などの他のコレクションが含まれます。 たとえば、ArrayList の場合は次のようになります:

java
// Java
var list = new ArrayList<>();
//...
if (!list.isEmpty()) {
    System.out.println(list.getFirst());
    System.out.println(list.getLast());
}

Kotlin には、特別な関数 firstOrNull() と lastOrNull() があります。 Elvis 演算子 を使用すると、関数の結果に応じて即座に以降のアクションを実行できます。たとえば、firstOrNull() の場合:

kotlin
// Kotlin
val emails = listOf<String>() // 空の可能性あり
val theOldestEmail = emails.firstOrNull() ?: ""
val theFreshestEmail = emails.lastOrNull() ?: ""

List から Set を作成する ​

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 には「中間操作」と「終端操作」があります。filter() は中間操作であり、ストリームを返します。 出力としてコレクションを受け取るには、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)
}

Map のフィルタリング の詳細についてはこちらをご覧ください。

型による要素のフィルタリング ​

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())
    }
}

条件のテスト (Test predicates) ​

タスクによっては、すべての要素、いずれの要素も満たさない、またはいずれかの要素が条件を満たしているかを確認する必要があります。 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 では、すべての Iterable オブジェクトで 拡張関数 の none()、any()、および all() が使用可能です:

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") })
}

条件のテスト の詳細をご覧ください。

コレクションの変換操作 ​

要素の結合 (Zip elements) ​

Java では、2 つのコレクションを同時に反復処理することで、同じ位置にある要素からペアを作成できます:

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 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() の結果は小さい方のサイズになります。大きい方のコレクションの末尾の要素は結果に含まれません。

要素の関連付け (Associate elements) ​

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() (または associateWith())関数を使用します:

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

次のステップ ​

お気に入りのイディオムがあれば、プルリクエストを送ってぜひ共有してください。