MENU
  1. ホーム
  2. Kotlin
  3. Kotlinでジェネリクスとラムダ式を組み合わせた汎用関数の作成例

Kotlinでジェネリクスとラムダ式を組み合わせた汎用関数の作成例

Kotlin

Kotlinのプログラミングにおいて、ジェネリクスとラムダ式はコードの柔軟性と再利用性を高める強力な機能です。ジェネリクスは型の汎用性を実現し、ラムダ式はシンプルで読みやすい関数定義を可能にします。これらを組み合わせることで、型安全かつ効率的な汎用関数を簡単に作成することができます。

本記事では、Kotlinのジェネリクスとラムダ式の基本概念を整理し、これらを組み合わせて汎用関数を実際に作成する手順を具体的に解説します。さらに、複雑なロジックへの応用例や最適化のポイント、実際に使えるユーティリティ関数まで紹介することで、Kotlinの実用的なスキルを習得できる内容となっています。

目次

ジェネリクスの基本概念

ジェネリクスとは、型に依存しない柔軟なコードを作成するための機能です。Kotlinでは、クラスや関数でジェネリクスを使用することで、異なるデータ型を安全に扱うことができます。

ジェネリクスの構文

Kotlinのジェネリクスは、型引数として角括弧 <> を使用します。例えば、以下はジェネリッククラスの基本構文です：

class Box<T>(val item: T)

fun main() {
    val intBox = Box(10)       // Int型
    val stringBox = Box("Hello") // String型
    println(intBox.item)       // 出力: 10
    println(stringBox.item)    // 出力: Hello
}
  • T は型引数のプレースホルダであり、どの型でも受け入れ可能です。

ジェネリクス関数の定義

関数でもジェネリクスを利用できます。型引数を指定することで、異なる型のデータを受け入れる関数を作成できます。

fun <T> printItem(item: T) {
    println(item)
}

fun main() {
    printItem(10)          // Int型のデータ
    printItem("Hello")     // String型のデータ
    printItem(3.14)        // Double型のデータ
}

この例では、<T>が型引数を表し、関数 printItem はどのデータ型でも受け入れることができます。

型制約 (Type Constraints)

ジェネリクスに制約を加えることで、特定の型のサブクラスのみ受け入れるように設定できます。whereキーワードを使用するのが一般的です。

fun <T : Number> sum(a: T, b: T): Double {
    return a.toDouble() + b.toDouble()
}

fun main() {
    println(sum(10, 20))       // 出力: 30.0
    println(sum(5.5, 3.3))     // 出力: 8.8
}
  • T : Number は型制約で、Numberクラスのサブクラスのみ受け入れることを意味します。

型の安全性

Kotlinのジェネリクスは型推論が強力であり、コンパイル時に型がチェックされるため、実行時エラーを防ぐことができます。これにより、型安全なコードが実現できます。

ジェネリクスを理解することで、柔軟かつ型安全なクラスや関数を作成することができ、コードの再利用性と効率性が向上します。

ラムダ式の基本構文

Kotlinにおけるラムダ式は、簡潔に関数を表現するための強力な機能です。ラムダ式を使うことで、冗長なコードを削減し、直感的かつ読みやすい記述が可能になります。

ラムダ式の基本構文

Kotlinのラムダ式は以下の形式で記述します：

{ 引数 -> 処理内容 }

例えば、以下のコードは整数を引数に取り、その2倍の値を返すラムダ式です：

val doubleValue = { x: Int -> x * 2 }
println(doubleValue(5)) // 出力: 10
  • x: Int：引数の型と名前を指定します。
  • x * 2：引数を利用して処理を行い、その結果を返します。

関数型引数への適用

ラムダ式は、関数型の引数を持つ関数に適用されます。例えば、map関数やfilter関数でラムダ式を活用することが一般的です：

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val doubledNumbers = numbers.map { it * 2 } // 各要素を2倍にする
    println(doubledNumbers) // 出力: [2, 4, 6, 8, 10]
}
  • it：ラムダ式の引数が1つの場合、itという暗黙的な名前が使用されます。

複数の引数を持つラムダ式

ラムダ式で複数の引数を扱う場合、明示的に引数名を指定します：

val sum = { a: Int, b: Int -> a + b }
println(sum(3, 5)) // 出力: 8

関数型の型定義

ラムダ式を関数の引数として渡す場合、関数型を定義して利用します：

fun operateOnNumbers(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

fun main() {
    val result = operateOnNumbers(4, 2) { x, y -> x * y } // 引数にラムダ式を渡す
    println(result) // 出力: 8
}
  • operation: (Int, Int) -> Int：operationは2つのIntを受け取り、Intを返す関数型を指定しています。

ラムダ式と高階関数

ラムダ式は高階関数（関数を引数に取る関数）と共に使われることが多いです。これにより、関数を柔軟にカスタマイズできます。

fun performOperation(x: Int, y: Int, operation: (Int, Int) -> Int) {
    val result = operation(x, y)
    println("Result: $result")
}

fun main() {
    performOperation(10, 5, { a, b -> a - b }) // 引数にラムダ式
    performOperation(10, 5) { a, b -> a + b }  // 最後の引数の場合、{}で省略可能
}

ラムダ式の省略記法

Kotlinでは、以下のようにラムダ式を省略して記述することが可能です：

  • 引数が1つの場合：itを使用
  • 関数型引数が最後の場合：波括弧 {} でラムダを記述
val numbers = listOf(1, 2, 3)
val squared = numbers.map { it * it }
println(squared) // 出力: [1, 4, 9]

まとめ

Kotlinのラムダ式は簡潔で読みやすく、関数型プログラミングの基盤を支える重要な要素です。関数型引数や高階関数と組み合わせることで、柔軟かつ効率的なコードを実現できます。

ジェネリクスとラムダ式の組み合わせ方


Kotlinでは、ジェネリクスとラムダ式を組み合わせることで、型に依存しない汎用的かつ柔軟な関数を作成することができます。これにより、コードの再利用性と効率が大幅に向上します。

ジェネリクスとラムダ式を組み合わせる基本形


ジェネリクスとラムダ式を同時に利用する場合、関数の型引数とラムダ式の引数・戻り値が連携する形になります。

以下の例を見てみましょう：

fun <T> processItem(item: T, operation: (T) -> Unit) {
    operation(item)
}

fun main() {
    // String型の処理
    processItem("Hello") { println("Item: $it") }  
    // Int型の処理
    processItem(123) { println("Item doubled: ${it * 2}") }
}
  • <T>：ジェネリクスの型引数を定義。
  • operation: (T) -> Unit：引数としてラムダ式を取り、T型のデータを処理する関数型を指定。
  • operation内でitを利用してデータを操作できます。

このように、ジェネリクスで受け取るデータの型に依存せず、柔軟に操作を定義できます。

ジェネリクスとラムダ式を使ったフィルタ関数


次に、ジェネリクスとラムダ式を活用して条件に合う要素をフィルタリングする関数を作成します：

fun <T> filterItems(items: List<T>, predicate: (T) -> Boolean): List<T> {
    val result = mutableListOf<T>()
    for (item in items) {
        if (predicate(item)) {
            result.add(item)
        }
    }
    return result
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)
    val evenNumbers = filterItems(numbers) { it % 2 == 0 }
    println(evenNumbers) // 出力: [2, 4, 6]

    val words = listOf("Kotlin", "Java", "C++", "Python")
    val filteredWords = filterItems(words) { it.length > 4 }
    println(filteredWords) // 出力: [Kotlin, Python]
}
  • predicate: (T) -> Boolean：ラムダ式で条件を指定する関数型。
  • T：リストの要素型がジェネリクスで定義され、任意の型に対応可能です。
  • 結果として、型に依存しない汎用的なフィルタ関数が実現されています。

複数のジェネリクスとラムダ式


ジェネリクスは複数の型引数をサポートしています。例えば、2つの異なる型引数を持つ関数を定義することができます。

fun <T, R> transformItem(item: T, transformer: (T) -> R): R {
    return transformer(item)
}

fun main() {
    val length = transformItem("Kotlin") { it.length }
    println("Length of Kotlin: $length") // 出力: 6

    val square = transformItem(5) { it * it }
    println("Square of 5: $square") // 出力: 25
}
  • <T, R>：複数の型引数を定義。
  • transformer: (T) -> R：T型の入力を受け取り、R型の結果を返すラムダ式。
  • StringやIntなど、異なる型で柔軟に利用できます。

ジェネリクスとラムダ式の利点

  • コードの再利用性：型を固定せず、異なるデータ型に対応する関数を一つ定義できます。
  • 柔軟な処理：ラムダ式によって任意の処理を関数に渡すことができます。
  • 型安全性：Kotlinの型システムにより、コンパイル時にエラーが検出されます。

まとめ


ジェネリクスとラムダ式を組み合わせることで、Kotlinの関数は柔軟で型安全な設計が可能になります。これにより、同じ関数を異なる型や目的で使い回すことができ、効率的なプログラミングが実現できます。

汎用関数の具体的なサンプルコード


ここでは、Kotlinのジェネリクスとラムダ式を組み合わせた具体的な汎用関数のサンプルコードを紹介します。これにより、型に依存せず柔軟な処理を行う関数を作成する方法が理解できます。

1. 任意のリスト要素に操作を適用する関数


この関数は、ジェネリクスを使用して任意の型のリストに対し、ラムダ式で指定した操作を適用するものです。

fun <T> applyOperation(items: List<T>, operation: (T) -> Unit) {
    for (item in items) {
        operation(item)
    }
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    println("各要素を出力:")
    applyOperation(numbers) { println(it) } // 各要素を表示

    val words = listOf("Kotlin", "Java", "C++")
    println("単語の長さを表示:")
    applyOperation(words) { println("${it}: ${it.length}") }
}
  • applyOperation：リストの各要素に対し、ラムダ式で指定した操作を適用します。
  • <T>：任意の型を受け入れられるジェネリクス型。
  • operation: (T) -> Unit：ラムダ式で操作を指定します。

実行結果：

各要素を出力:
1
2
3
4
5
単語の長さを表示:
Kotlin: 6
Java: 4
C++: 3

2. 条件に一致する要素を抽出する汎用関数


この関数は、ジェネリクスとラムダ式を使って、任意の条件に一致する要素のみをリストから抽出します。

fun <T> filterItems(items: List<T>, predicate: (T) -> Boolean): List<T> {
    val result = mutableListOf<T>()
    for (item in items) {
        if (predicate(item)) {
            result.add(item)
        }
    }
    return result
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)
    val evenNumbers = filterItems(numbers) { it % 2 == 0 }
    println("偶数のみ: $evenNumbers") // 出力: [2, 4, 6]

    val words = listOf("Kotlin", "Java", "Python", "C++")
    val longWords = filterItems(words) { it.length > 4 }
    println("5文字以上の単語: $longWords") // 出力: [Kotlin, Python]
}
  • filterItems：条件に合致する要素をリストから抽出します。
  • predicate: (T) -> Boolean：条件をラムダ式で指定します。

実行結果：

偶数のみ: [2, 4, 6]
5文字以上の単語: [Kotlin, Python]

3. リスト要素を変換する汎用関数


この関数は、ジェネリクスを用いてリストの要素を別の型に変換するものです。

fun <T, R> transformItems(items: List<T>, transformer: (T) -> R): List<R> {
    val result = mutableListOf<R>()
    for (item in items) {
        result.add(transformer(item))
    }
    return result
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val squaredNumbers = transformItems(numbers) { it * it }
    println("2乗の値: $squaredNumbers") // 出力: [1, 4, 9, 16, 25]

    val words = listOf("kotlin", "java", "c++")
    val upperWords = transformItems(words) { it.uppercase() }
    println("大文字に変換: $upperWords") // 出力: [KOTLIN, JAVA, C++]
}
  • transformItems：リストの要素を変換し、別の型のリストを作成します。
  • <T, R>：Tが入力型、Rが出力型を表します。
  • transformer: (T) -> R：変換処理をラムダ式で指定します。

実行結果：

2乗の値: [1, 4, 9, 16, 25]
大文字に変換: [KOTLIN, JAVA, C++]

まとめ


これらのサンプルコードでは、ジェネリクスとラムダ式を組み合わせることで、データ型に依存せず、柔軟な汎用関数を作成する方法を解説しました。これにより、コードの再利用性や保守性が大幅に向上します。実際のプロジェクトでは、これらの汎用関数を基盤に、さらに複雑な処理を実装できます。

複雑な関数への応用例


Kotlinでは、ジェネリクスとラムダ式を組み合わせることで、複雑なロジックをシンプルかつ柔軟に実装することができます。ここでは、実際の開発現場で役立つ応用例を紹介します。

1. 条件を組み合わせたフィルタリング関数


複数の条件をラムダ式で柔軟に組み合わせることで、特定のルールに一致する要素をフィルタリングできます。

fun <T> filterWithConditions(items: List<T>, vararg conditions: (T) -> Boolean): List<T> {
    return items.filter { item ->
        conditions.all { condition -> condition(item) }
    }
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    val result = filterWithConditions(
        numbers,
        { it > 3 },       // 4以上の要素
        { it % 2 == 0 }   // 偶数の要素
    )
    println("条件を満たす要素: $result") // 出力: [4, 6, 8, 10]
}
  • filterWithConditions：複数の条件をvarargで受け取り、all関数で全ての条件を満たす要素を抽出します。
  • 柔軟な適用：条件を追加・変更するだけで異なるフィルタリングが可能になります。

2. カスタム変換関数と結果の集計


データを変換し、その結果を集計する関数です。例えば、数値リストの特定の操作を行った後に合計値を求める場合です。

fun <T, R : Number> transformAndSum(items: List<T>, transformer: (T) -> R): Double {
    return items.map { transformer(it) }.sumOf { it.toDouble() }
}

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

    val squaredSum = transformAndSum(numbers) { it * it }
    println("2乗の合計: $squaredSum") // 出力: 55.0

    val doubledSum = transformAndSum(numbers) { it * 2 }
    println("2倍の合計: $doubledSum") // 出力: 30.0
}
  • transformAndSum：transformerで要素を変換し、合計値を計算します。
  • 汎用性：入力データ型 T と出力データ型 R を分けることで、さまざまな処理に対応可能です。

3. リストのグルーピングと操作


複数の条件でリストをグループ分けし、それぞれに対する処理を行う関数です。

fun <T, K> groupAndProcess(
    items: List<T>,
    keySelector: (T) -> K,
    processor: (K, List<T>) -> Unit
) {
    val grouped = items.groupBy(keySelector)
    for ((key, group) in grouped) {
        processor(key, group)
    }
}

fun main() {
    val words = listOf("apple", "banana", "cherry", "apricot", "blueberry")

    groupAndProcess(words, { it.first() }) { key, group ->
        println("Key: $key -> Group: $group")
    }
}
  • groupBy：要素を指定したキーでグルーピングします。
  • processor：グループごとの処理をラムダ式で指定します。

実行結果：

Key: a -> Group: [apple, apricot]
Key: b -> Group: [banana, blueberry]
Key: c -> Group: [cherry]

4. 高度な条件で要素を置換する関数


リストの中の要素を条件に基づいて変更する関数です。

fun <T> replaceItems(
    items: List<T>, 
    condition: (T) -> Boolean, 
    replacement: (T) -> T
): List<T> {
    return items.map { if (condition(it)) replacement(it) else it }
}

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

    val replaced = replaceItems(numbers, { it % 2 == 0 }, { it * 10 })
    println("偶数を10倍に置換: $replaced") // 出力: [1, 20, 3, 40, 5]
}
  • replaceItems：条件を満たす要素のみ、ラムダ式で指定した変換処理を適用します。

まとめ


ジェネリクスとラムダ式を組み合わせることで、複雑な処理や高度なロジックをシンプルかつ柔軟に実装できます。これらの応用例は、フィルタリング、データ変換、集計、グルーピングなど、日常的な開発タスクを効率的に行うための基盤になります。

コードの解説と最適化ポイント


Kotlinにおけるジェネリクスとラムダ式を組み合わせたコードは強力ですが、複雑になることもあります。ここでは、これまでのコードを解説し、最適化のポイントを詳しく説明します。

1. コードの構造と役割の解説

ジェネリクスの役割


ジェネリクス（<T>や<T, R>）は、関数やクラスを柔軟にし、型に依存しない設計を実現します。具体的には次の役割があります：

  • 型の安全性：実行時ではなく、コンパイル時に型エラーを検出します。
  • 再利用性：異なるデータ型で同じ処理を適用可能にします。

ラムダ式の役割


ラムダ式は関数型プログラミングを可能にし、柔軟な処理を簡潔に記述できます。

  • 高階関数との組み合わせ：関数の引数にラムダ式を渡して処理内容をカスタマイズします。
  • コードの簡略化：ボイラープレートコードを削減し、可読性を高めます。

2. 最適化ポイントと改善例

ポイント1: **引数の型推論を活用する**


Kotlinの型推論を利用することで、コードをさらに簡潔に記述できます。
例えば以下のコード：

fun <T> processItem(item: T, operation: (T) -> Unit) {
    operation(item)
}

processItem("Kotlin") { it -> println(it) }

itは引数が1つの場合のデフォルト名なので、よりシンプルに書けます：

processItem("Kotlin") { println(it) }

ポイント2: **`inline`を活用して高階関数のパフォーマンスを改善**


Kotlinでは、関数を引数に取る高階関数を使用すると、ラムダ式がオブジェクトとして生成されるため、オーバーヘッドが発生します。inline修飾子を使用することで、このオーバーヘッドを削減できます。

before（inlineを使わない場合）：

fun <T> processItem(item: T, operation: (T) -> Unit) {
    operation(item)
}

after（inlineを使用）：

inline fun <T> processItem(item: T, operation: (T) -> Unit) {
    operation(item)
}
  • 効果：inlineにより関数呼び出しがインライン化され、オブジェクト生成が回避されます。
  • 注意点：inlineは大規模な関数ではコードサイズが増加する可能性があるため、バランスを考慮しましょう。

ポイント3: **`when`とラムダ式の組み合わせ**


複数の条件をシンプルに処理する際には、whenとラムダ式を組み合わせると可読性が向上します。

例：データの型ごとに異なる処理を行う関数：

fun <T> performAction(item: T) {
    when (item) {
        is String -> println("String: ${item.uppercase()}")
        is Int -> println("Square: ${item * item}")
        else -> println("Unknown type: $item")
    }
}

fun main() {
    performAction("Kotlin") // 出力: String: KOTLIN
    performAction(5)        // 出力: Square: 25
}

ポイント4: **複雑な条件をラムダ式に分割する**


条件が複雑になりすぎる場合は、ラムダ式を分割して可読性を保ちます。

改善前：

val result = items.filter { it > 3 && it % 2 == 0 }

改善後：

val isGreaterThanThree = { x: Int -> x > 3 }
val isEven = { x: Int -> x % 2 == 0 }

val result = items.filter { isGreaterThanThree(it) && isEven(it) }

ラムダ式を分割することで、条件の意味が明確になり、再利用もしやすくなります。

3. リファクタリングの実例

先ほど紹介した「要素を置換する関数」を最適化します：

before:

fun <T> replaceItems(
    items: List<T>, 
    condition: (T) -> Boolean, 
    replacement: (T) -> T
): List<T> {
    return items.map { if (condition(it)) replacement(it) else it }
}

after:

inline fun <T> replaceItems(
    items: List<T>,
    noinline condition: (T) -> Boolean,
    noinline replacement: (T) -> T
): List<T> = items.map { if (condition(it)) replacement(it) else it }
  • inline：関数全体をインライン化してパフォーマンス向上。
  • noinline：一部のラムダ式をインライン化しないことで柔軟性を確保します。

まとめ


Kotlinにおけるジェネリクスとラムダ式を活用した関数は柔軟で強力ですが、最適化することでさらに効率的かつ可読性の高いコードを実現できます。型推論、inline関数、条件分割などの手法を取り入れることで、パフォーマンスの向上とメンテナンス性の向上が可能です。

ジェネリクスとラムダ式を使ったユーティリティ関数


Kotlinでジェネリクスとラムダ式を組み合わせると、日常の開発タスクに役立つユーティリティ関数を作成できます。これにより、コードの再利用性や効率が大幅に向上します。ここでは、実用的な関数の具体例を紹介します。

1. Null安全な処理を行う関数


リストの要素や単一の値に対し、Null安全にラムダ式で処理を行うユーティリティ関数です。

fun <T> safeLet(value: T?, action: (T) -> Unit) {
    value?.let { action(it) }
}

fun main() {
    val name: String? = "Kotlin"
    val nullName: String? = null

    safeLet(name) { println("Hello, $it!") }     // 出力: Hello, Kotlin!
    safeLet(nullName) { println("This won't be printed") }
}
  • safeLet：Nullチェックを含め、ラムダ式で処理を適用します。
  • value?.let：値がNullでない場合のみラムダを実行します。

2. データの変換と結合を行う関数


リスト要素を別の型に変換し、結合して結果を返すユーティリティ関数です。

fun <T, R> mapAndJoin(items: List<T>, transformer: (T) -> R, separator: String = ", "): String {
    return items.joinToString(separator) { transformer(it).toString() }
}

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

    val squaredString = mapAndJoin(numbers, { it * it }, " | ")
    println("2乗の結合結果: $squaredString") // 出力: 1 | 4 | 9 | 16 | 25
}
  • mapAndJoin：データを変換し、文字列として結合します。
  • transformer: (T) -> R：要素を変換するラムダ式。
  • separator：結合時の区切り文字をカスタマイズできます。

3. リストの要素をグルーピングして集計する関数


リストの要素を指定したキーでグループ分けし、集計を行う関数です。

fun <T, K> groupAndCount(items: List<T>, keySelector: (T) -> K): Map<K, Int> {
    return items.groupingBy(keySelector).eachCount()
}

fun main() {
    val words = listOf("apple", "banana", "apricot", "blueberry", "cherry")

    val groupedCount = groupAndCount(words) { it.first() }
    println("先頭文字ごとの要素数: $groupedCount")
}
  • groupingBy：要素をキーごとにグループ化します。
  • eachCount：グループごとの要素数を集計します。

実行結果：

先頭文字ごとの要素数: {a=2, b=2, c=1}

4. 再帰処理を簡単に行う高階関数


ラムダ式を使って、再帰処理を汎用化する関数を作成します。

fun <T> recursiveOperation(item: T, operation: (T) -> T?, action: (T) -> Unit) {
    var current: T? = item
    while (current != null) {
        action(current)
        current = operation(current)
    }
}

fun main() {
    var count = 5
    println("カウントダウン:")
    recursiveOperation(count, { if (it > 0) it - 1 else null }) { println(it) }
}
  • recursiveOperation：再帰処理を柔軟に適用します。
  • operation：次の状態を計算するラムダ式。
  • action：現在の状態を処理するラムダ式。

実行結果：

カウントダウン:
5
4
3
2
1
0

5. エラー処理を簡略化するユーティリティ関数


例外が発生する可能性がある処理を安全に実行し、エラー時の処理をラムダ式で指定します。

fun <T> tryOrNull(action: () -> T): T? {
    return try {
        action()
    } catch (e: Exception) {
        null
    }
}

fun main() {
    val result = tryOrNull { "123".toInt() }
    println("成功時: $result") // 出力: 123

    val errorResult = tryOrNull { "abc".toInt() }
    println("エラー時: $errorResult") // 出力: null
}
  • tryOrNull：例外が発生した場合にnullを返します。
  • エラー時の安全性：例外処理をシンプルに記述できます。

まとめ


ジェネリクスとラムダ式を活用したユーティリティ関数は、日々の開発を効率化し、コードの可読性と再利用性を高めます。
これらの関数をプロジェクトに組み込むことで、同じ処理を繰り返すことなく、柔軟かつ安全な実装が可能になります。

演習問題と解答例


Kotlinのジェネリクスとラムダ式を理解し、実践的に使いこなせるようになるための演習問題を紹介します。各問題には解答例を示し、具体的な実装方法を確認できるように解説します。

演習問題 1: 条件を満たす要素の合計


問題：
ジェネリクスを使って任意の型のリストから条件を満たす要素を抽出し、その合計を計算する関数を作成してください。数値型（IntやDoubleなど）に対応するようにしてください。

解答例：

fun <T : Number> sumIf(items: List<T>, predicate: (T) -> Boolean): Double {
    return items.filter(predicate).sumOf { it.toDouble() }
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)

    val evenSum = sumIf(numbers) { it.toInt() % 2 == 0 }
    println("偶数の合計: $evenSum") // 出力: 12.0

    val greaterThanThreeSum = sumIf(numbers) { it.toInt() > 3 }
    println("3より大きい数の合計: $greaterThanThreeSum") // 出力: 15.0
}

解説：

  • ジェネリクス T : Number を使用して数値型を制限。
  • predicate で条件を指定し、フィルタリング後に合計を計算します。

演習問題 2: 文字列リストの長さを変換


問題：
ジェネリクスとラムダ式を使って文字列リストの各要素の長さを取得し、新しいリストとして返す汎用関数を作成してください。

解答例：

fun <T, R> mapItems(items: List<T>, transformer: (T) -> R): List<R> {
    return items.map(transformer)
}

fun main() {
    val words = listOf("Kotlin", "Java", "C++", "Python")

    val lengths = mapItems(words) { it.length }
    println("各文字列の長さ: $lengths") // 出力: [6, 4, 3, 6]
}

解説：

  • mapItems はジェネリクス T と R を使い、入力リストを任意の型に変換します。
  • ラムダ式 transformer により、各文字列の長さを取得しています。

演習問題 3: 複数条件の要素置換


問題：
リストの要素を条件に基づいて別の値に置き換える汎用関数を作成してください。ジェネリクスを使用し、複数の条件に対応するようにしてください。

解答例：

fun <T> replaceItems(
    items: List<T>, 
    condition: (T) -> Boolean, 
    replacement: (T) -> T
): List<T> {
    return items.map { if (condition(it)) replacement(it) else it }
}

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

    val replaced = replaceItems(numbers, { it % 2 == 0 }, { it * 10 })
    println("偶数を10倍に置換: $replaced") // 出力: [1, 20, 3, 40, 5]
}

解説：

  • ジェネリクス T を使い、任意の型のデータに対応。
  • condition で置換条件を指定し、replacement で置換後の値を設定します。

演習問題 4: グルーピングと要素カウント


問題：
任意のリストを指定したキーでグループ化し、各グループの要素数をカウントする汎用関数を作成してください。

解答例：

fun <T, K> groupAndCount(items: List<T>, keySelector: (T) -> K): Map<K, Int> {
    return items.groupingBy(keySelector).eachCount()
}

fun main() {
    val words = listOf("apple", "banana", "apricot", "blueberry", "cherry")

    val groupedCount = groupAndCount(words) { it.first() }
    println("先頭文字ごとの要素数: $groupedCount")
}

解説：

  • groupingBy と eachCount を使って簡単にグルーピングとカウントが可能です。
  • ジェネリクス T はリストの要素型、K はグループ化のキー型です。

まとめ


これらの演習問題を通じて、Kotlinのジェネリクスとラムダ式を使った関数設計の理解を深めることができます。ジェネリクスを活用することで型に依存しない汎用的な処理が可能になり、ラムダ式を組み合わせることで柔軟で簡潔なコードを実現できます。

まとめ


本記事では、Kotlinにおけるジェネリクスとラムダ式を組み合わせた汎用関数の作成方法について解説しました。

  • ジェネリクスの基本：型に依存しない柔軟な関数やクラスを実現。
  • ラムダ式の活用：シンプルかつ直感的な処理を記述。
  • 組み合わせの応用：フィルタリング、変換、置換、グルーピングなど、日常の開発に役立つユーティリティ関数を実装。
  • 演習問題：実践的なコード例で理解を深める内容を提供。

ジェネリクスとラムダ式を適切に活用することで、型安全かつ効率的なコードが実現でき、プロジェクトの保守性と再利用性を向上させることが可能です。これらの知識を活かして、Kotlinの柔軟な関数設計を習得してください。

Kotlin
ジェネリクス ラムダ式 Kotlin 汎用関数

コメント

コメントする

目次