MENU
  1. ホーム
  2. Kotlin
  3. Kotlin拡張関数でデータクラスのプロパティを自在に操作する方法

Kotlin拡張関数でデータクラスのプロパティを自在に操作する方法

Kotlin

Kotlinはそのシンプルさと柔軟性から、Android開発やサーバーサイド開発で幅広く利用されています。その中でも「データクラス」は、データの保持や管理に特化したクラスとして非常に便利です。データクラスの利用は、冗長なコードを減らし、可読性や保守性を向上させます。

さらにKotlinでは「拡張関数」という強力な機能があり、既存のクラスに新しい関数を追加することができます。これにより、データクラスのプロパティ操作を効率的に行えるだけでなく、コードの再利用性が向上します。本記事では、拡張関数を活用してデータクラスのプロパティを自在に操作する方法を詳しく解説します。

Kotlinの基本から応用まで、拡張関数をマスターしてデータクラスをもっと効率的に活用しましょう。

目次
  1. Kotlinデータクラスとは
    1. データクラスの基本構文
    2. データクラスの具体例
    3. データクラスの利用シーン
  2. 拡張関数とは何か
    1. 拡張関数の基本構文
    2. 拡張関数の仕組み
    3. データクラスへの拡張関数適用例
    4. 拡張関数の利点
  3. データクラスで拡張関数を使うメリット
    1. コードの可読性向上
    2. ソースコードの変更が不要
    3. 関数の再利用性向上
    4. シンプルなコードで複雑な処理を実装
    5. まとめ
  4. 基本的な拡張関数の実装例
    1. データクラスの基本例
    2. フルネームを取得する拡張関数
    3. 年齢を1歳加算する拡張関数
    4. プロパティをフォーマットして出力する拡張関数
    5. 拡張関数をチェーンする
    6. まとめ
  5. 特定のプロパティを操作する拡張関数
    1. 特定のプロパティを変更する拡張関数
    2. プロパティを検証する拡張関数
    3. 数値プロパティをフォーマットする拡張関数
    4. 特定の条件でプロパティを変更する
    5. まとめ
  6. データクラスのリストを操作する拡張関数
    1. データクラスのリストを定義
    2. 特定条件のユーザーをフィルタリングする拡張関数
    3. リスト内のユーザー名を取得する拡張関数
    4. 年齢の平均値を計算する拡張関数
    5. 特定の年齢以上のユーザーに対して処理を適用する拡張関数
    6. リストのユーザーをソートする拡張関数
    7. まとめ
  7. 拡張関数の実用的な応用例
    1. 1. ログ出力のフォーマット関数
    2. 2. バリデーション関数
    3. 3. JSON形式への変換関数
    4. 4. 文字列のフィルタリング・整形
    5. 5. リストの集計処理
    6. まとめ
  8. 注意点とベストプラクティス
    1. 1. 拡張関数はオーバーライドできない
    2. 2. 拡張関数はクラスの非公開メンバにアクセスできない
    3. 3. 拡張関数のスコープに注意
    4. 4. 拡張関数の利用は適材適所で
    5. 5. 可読性を保つ
    6. 6. 名前空間の衝突を避ける
    7. まとめ
  9. まとめ

Kotlinデータクラスとは

Kotlinのデータクラス（Data Class）は、データを保持するために特化したクラスです。Javaでデータ保持用のクラスを作成する際には、フィールド、コンストラクタ、ゲッター、セッター、toString()、equals()、hashCode()メソッドを手動で実装する必要がありますが、Kotlinのデータクラスは、それらを自動的に生成してくれるため、シンプルかつ効率的です。

データクラスの基本構文

データクラスを宣言するには、dataキーワードを使います。

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

この1行で以下のメソッドが自動生成されます：

  • toString()：オブジェクトの文字列表現を返します。
  • equals()：オブジェクトの内容が等しいかどうかを比較します。
  • hashCode()：ハッシュコードを生成します。
  • copy()：オブジェクトを複製します。

データクラスの具体例

fun main() {
    val user1 = User("Alice", 25)
    val user2 = user1.copy(name = "Bob")

    println(user1)  // 出力: User(name=Alice, age=25)
    println(user2)  // 出力: User(name=Bob, age=25)
}

データクラスの利用シーン

データクラスは、以下のようなシーンで頻繁に使用されます：

  1. APIレスポンスのモデル：データの受け渡し用オブジェクトとして。
  2. 状態管理：アプリケーションの状態を表現するために。
  3. リスト処理：データの一覧やフィルタリング操作に。

データクラスを活用することで、コードをシンプルに保ちながら、データの取り扱いを効率的に行うことができます。

拡張関数とは何か

Kotlinの拡張関数は、既存のクラスに新しい関数を追加するための機能です。クラスのソースコードを直接変更せずに、関数を追加できるため、柔軟で効率的なコードを書けます。拡張関数は、標準ライブラリやサードパーティのクラス、さらには自分で作成したデータクラスにも適用できます。

拡張関数の基本構文

拡張関数を定義するには、次のような構文を使用します：

fun クラス名.関数名(引数): 戻り値 {
    // 関数の処理
}

例えば、Stringクラスに文字数をカウントして出力する関数を追加する場合：

fun String.countCharacters(): Int {
    return this.length
}

fun main() {
    val text = "Hello, Kotlin!"
    println(text.countCharacters())  // 出力: 14
}

拡張関数の仕組み

  • thisキーワード：拡張関数内では、thisが対象のクラスインスタンスを指します。
  • オーバーライド不可：拡張関数はクラスのメソッドをオーバーライドできません。既存のメソッドが優先されます。

データクラスへの拡張関数適用例

データクラスUserに年齢を判定する拡張関数を追加する例です：

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

fun User.isAdult(): Boolean {
    return this.age >= 18
}

fun main() {
    val user = User("Alice", 20)
    println(user.isAdult())  // 出力: true
}

拡張関数の利点

  1. コードの再利用：同じ処理を複数の場所で使い回せます。
  2. クリーンなコード：クラスのソースコードを変更せず、必要な処理を追加できます。
  3. メンテナンス性向上：拡張関数を使うことで、機能追加が容易になります。

拡張関数は、Kotlinの柔軟性を象徴する機能であり、データクラスや標準ライブラリのクラスをさらに便利に活用できる強力な手段です。

データクラスで拡張関数を使うメリット

Kotlinのデータクラスに拡張関数を適用することで、効率的かつ柔軟なコードを実現できます。データクラスは主にデータの保持と管理に使われますが、拡張関数を活用することで、データの操作や処理をシンプルに記述できます。

コードの可読性向上

拡張関数を使えば、データクラスに関連する操作を直感的に書くことができます。例えば、データクラスのプロパティを操作する関数をそのままメソッドチェーンのように呼び出せるため、コードの可読性が向上します。

data class Product(val name: String, val price: Double)

fun Product.discountedPrice(discount: Double): Double {
    return this.price * (1 - discount)
}

fun main() {
    val product = Product("Laptop", 1000.0)
    println(product.discountedPrice(0.1))  // 出力: 900.0
}

ソースコードの変更が不要

データクラス自体を変更せずに、新しい機能や操作を追加できるのが拡張関数の大きな利点です。既存のコードベースに影響を与えず、必要な機能だけを柔軟に追加できます。

関数の再利用性向上

拡張関数は再利用しやすく、一度定義すれば複数の場所で使えます。異なるデータクラスでも似たような処理が必要な場合、共通の拡張関数を作成して効率的に使い回せます。

シンプルなコードで複雑な処理を実装

複雑な処理やビジネスロジックを拡張関数としてデータクラスに関連付けることで、ロジックが分散せず、コード全体がシンプルになります。

data class User(val name: String, val email: String)

fun User.maskEmail(): String {
    return this.email.replaceBefore("@", "****")
}

fun main() {
    val user = User("Alice", "alice@example.com")
    println(user.maskEmail())  // 出力: ****@example.com
}

まとめ

データクラスに拡張関数を適用することで、以下のメリットが得られます：

  1. 可読性の向上：操作が直感的で分かりやすい。
  2. 柔軟性：ソースコードを変更せずに機能を追加。
  3. 再利用性：一度作成した拡張関数を複数の場所で使える。
  4. シンプルな実装：複雑な処理を簡潔に表現。

これにより、データクラスをより効率的に活用し、保守性の高いコードを書けるようになります。

基本的な拡張関数の実装例

Kotlinの拡張関数を使えば、データクラスに簡単な機能を追加できます。ここでは、基本的な拡張関数の実装例をいくつか紹介し、データクラスのプロパティ操作を効率化する方法を解説します。

データクラスの基本例

まず、シンプルなデータクラスPersonを定義します。

data class Person(val firstName: String, val lastName: String, val age: Int)

フルネームを取得する拡張関数

Personクラスにフルネームを取得する拡張関数を追加してみましょう。

fun Person.getFullName(): String {
    return "$firstName $lastName"
}

fun main() {
    val person = Person("John", "Doe", 30)
    println(person.getFullName())  // 出力: John Doe
}

年齢を1歳加算する拡張関数

次に、年齢を1歳加算する拡張関数を作成します。データクラスは不変（val）なので、新しいインスタンスを返します。

fun Person.incrementAge(): Person {
    return this.copy(age = this.age + 1)
}

fun main() {
    val person = Person("Alice", "Smith", 25)
    val olderPerson = person.incrementAge()
    println(olderPerson)  // 出力: Person(firstName=Alice, lastName=Smith, age=26)
}

プロパティをフォーマットして出力する拡張関数

プロパティの情報をフォーマットして出力する拡張関数を作成します。

fun Person.formatDetails(): String {
    return "Name: ${this.getFullName()}, Age: ${this.age}"
}

fun main() {
    val person = Person("Tom", "Brown", 40)
    println(person.formatDetails())  // 出力: Name: Tom Brown, Age: 40
}

拡張関数をチェーンする

複数の拡張関数を組み合わせて呼び出すことで、処理をチェーンできます。

fun main() {
    val person = Person("Jane", "Doe", 28)
    val updatedPerson = person.incrementAge()
    println(updatedPerson.formatDetails())  // 出力: Name: Jane Doe, Age: 29
}

まとめ

これらの基本的な拡張関数の例を活用することで、データクラスに対して柔軟に操作を追加できます。主なポイントは以下の通りです：

  1. コードのシンプル化：短いコードで機能を追加できる。
  2. 不変性の維持：copy関数を使い、新しいインスタンスを返すことで不変性を保つ。
  3. 再利用性：同じ処理を異なる場所で使い回せる。

これにより、Kotlinのデータクラスをさらに便利に活用することができます。

特定のプロパティを操作する拡張関数

Kotlinの拡張関数を使えば、データクラスの特定のプロパティに対する操作を簡単に定義できます。これにより、冗長なコードを書くことなく、プロパティごとの処理を柔軟に行えます。

特定のプロパティを変更する拡張関数

例えば、Userというデータクラスのemailプロパティをドメインごと変更する拡張関数を作成します。

data class User(val name: String, val email: String)

fun User.changeEmailDomain(newDomain: String): User {
    val newEmail = this.email.substringBefore("@") + "@$newDomain"
    return this.copy(email = newEmail)
}

fun main() {
    val user = User("Alice", "alice@example.com")
    val updatedUser = user.changeEmailDomain("newdomain.com")
    println(updatedUser)  // 出力: User(name=Alice, email=alice@newdomain.com)
}

この拡張関数は、元のユーザーのメールアドレスのドメイン部分だけを変更し、新しいインスタンスを返します。

プロパティを検証する拡張関数

次に、Personデータクラスのageプロパティが有効かどうかを検証する拡張関数を作成します。

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

fun Person.isValidAge(): Boolean {
    return this.age in 0..120
}

fun main() {
    val person = Person("Bob", 25)
    println(person.isValidAge())  // 出力: true

    val invalidPerson = Person("Charlie", 150)
    println(invalidPerson.isValidAge())  // 出力: false
}

この拡張関数は、年齢が0から120の範囲にあるかをチェックします。

数値プロパティをフォーマットする拡張関数

Productデータクラスで、価格のフォーマットを行う拡張関数を作成します。

data class Product(val name: String, val price: Double)

fun Product.formatPrice(): String {
    return "$%.2f".format(this.price)
}

fun main() {
    val product = Product("Laptop", 999.99)
    println(product.formatPrice())  // 出力: $999.99
}

この拡張関数は、価格を小数点以下2桁にフォーマットして返します。

特定の条件でプロパティを変更する

Employeeデータクラスのsalaryが一定金額以下の場合に昇給する拡張関数を作成します。

data class Employee(val name: String, val salary: Double)

fun Employee.raiseSalaryIfLow(threshold: Double, increment: Double): Employee {
    return if (this.salary < threshold) {
        this.copy(salary = this.salary + increment)
    } else {
        this
    }
}

fun main() {
    val employee = Employee("David", 2800.0)
    val updatedEmployee = employee.raiseSalaryIfLow(3000.0, 200.0)
    println(updatedEmployee)  // 出力: Employee(name=David, salary=3000.0)
}

まとめ

特定のプロパティを操作する拡張関数を活用すると、次の利点があります：

  1. 柔軟性：プロパティごとの処理を柔軟に追加できる。
  2. コードの再利用：共通の処理を拡張関数としてまとめられる。
  3. 不変性の維持：データクラスのcopyメソッドを利用することで、不変性を保ちながらプロパティを変更できる。

これにより、データクラスの特定のプロパティに対する操作をシンプルかつ効率的に記述できます。

データクラスのリストを操作する拡張関数

Kotlinでは、データクラスのリストに対して拡張関数を使うことで、効率的にリスト全体の処理やデータのフィルタリング・変換が可能です。ここでは、データクラスのリストを操作する基本的な拡張関数を紹介します。

データクラスのリストを定義

まず、Userというデータクラスとそのリストを用意します。

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

val users = listOf(
    User("Alice", 25),
    User("Bob", 30),
    User("Charlie", 18),
    User("David", 15)
)

特定条件のユーザーをフィルタリングする拡張関数

リスト内のユーザーから成人（18歳以上）だけを抽出する拡張関数を作成します。

fun List<User>.filterAdults(): List<User> {
    return this.filter { it.age >= 18 }
}

fun main() {
    val adults = users.filterAdults()
    println(adults)  // 出力: [User(name=Alice, age=25), User(name=Bob, age=30), User(name=Charlie, age=18)]
}

リスト内のユーザー名を取得する拡張関数

リスト内のすべてのユーザーの名前を取得する拡張関数です。

fun List<User>.getAllNames(): List<String> {
    return this.map { it.name }
}

fun main() {
    val names = users.getAllNames()
    println(names)  // 出力: [Alice, Bob, Charlie, David]
}

年齢の平均値を計算する拡張関数

ユーザーの年齢の平均を求める拡張関数を作成します。

fun List<User>.averageAge(): Double {
    return this.map { it.age }.average()
}

fun main() {
    val avgAge = users.averageAge()
    println("Average Age: $avgAge")  // 出力: Average Age: 22.0
}

特定の年齢以上のユーザーに対して処理を適用する拡張関数

特定の年齢以上のユーザーにラベルを付ける拡張関数です。

fun List<User>.labelSeniors(threshold: Int): List<String> {
    return this.map { user ->
        if (user.age >= threshold) "${user.name} (Senior)" else user.name
    }
}

fun main() {
    val labeledUsers = users.labelSeniors(25)
    println(labeledUsers)  // 出力: [Alice (Senior), Bob (Senior), Charlie, David]
}

リストのユーザーをソートする拡張関数

年齢順にソートする拡張関数を作成します。

fun List<User>.sortByAge(): List<User> {
    return this.sortedBy { it.age }
}

fun main() {
    val sortedUsers = users.sortByAge()
    println(sortedUsers)
    // 出力: [User(name=David, age=15), User(name=Charlie, age=18), User(name=Alice, age=25), User(name=Bob, age=30)]
}

まとめ

データクラスのリストに対して拡張関数を適用することで、以下の利点があります：

  1. コードの簡素化：複雑な処理をシンプルな関数で記述できる。
  2. 再利用性：リスト操作のロジックを拡張関数として定義することで、複数の場所で使い回せる。
  3. 柔軟性：リストに対するフィルタリング、マッピング、ソートなどの処理を直感的に行える。

これにより、データクラスのリストを効率的かつ柔軟に操作できます。

拡張関数の実用的な応用例

Kotlinの拡張関数は、実際の開発現場でデータクラスを効率的に操作する際に非常に役立ちます。ここでは、実用的なシナリオで活用できる拡張関数の具体例を紹介します。

1. ログ出力のフォーマット関数

データクラスの内容を整形してログとして出力する拡張関数を作成します。

data class Transaction(val id: String, val amount: Double, val status: String)

fun Transaction.toLogString(): String {
    return "Transaction [ID: $id, Amount: $${"%.2f".format(amount)}, Status: $status]"
}

fun main() {
    val transaction = Transaction("TX12345", 1500.75, "Completed")
    println(transaction.toLogString())  
    // 出力: Transaction [ID: TX12345, Amount: $1500.75, Status: Completed]
}

2. バリデーション関数

入力データが有効かどうか検証する拡張関数を作成します。

data class User(val name: String, val email: String)

fun User.isValidEmail(): Boolean {
    return email.contains("@") && email.contains(".")
}

fun main() {
    val user = User("Alice", "alice@example.com")
    println(user.isValidEmail())  // 出力: true

    val invalidUser = User("Bob", "bob[at]example")
    println(invalidUser.isValidEmail())  // 出力: false
}

3. JSON形式への変換関数

データクラスをJSON形式の文字列に変換する拡張関数です。ライブラリを使わずシンプルに実装します。

data class Product(val name: String, val price: Double, val inStock: Boolean)

fun Product.toJson(): String {
    return """{"name": "$name", "price": $price, "inStock": $inStock}"""
}

fun main() {
    val product = Product("Laptop", 1200.0, true)
    println(product.toJson())  
    // 出力: {"name": "Laptop", "price": 1200.0, "inStock": true}
}

4. 文字列のフィルタリング・整形

データクラス内のプロパティの値を整形する拡張関数を作成します。

data class Message(val sender: String, val content: String)

fun Message.censorContent(badWords: List<String>): Message {
    var censoredContent = content
    badWords.forEach { badWord ->
        censoredContent = censoredContent.replace(badWord, "*".repeat(badWord.length))
    }
    return this.copy(content = censoredContent)
}

fun main() {
    val message = Message("John", "This is a bad message with inappropriate words.")
    val censoredMessage = message.censorContent(listOf("bad", "inappropriate"))
    println(censoredMessage)  
    // 出力: Message(sender=John, content=This is a *** message with ************* words.)
}

5. リストの集計処理

データクラスのリストに対して集計や統計情報を取得する拡張関数です。

data class Sale(val product: String, val quantity: Int, val pricePerUnit: Double)

fun List<Sale>.totalRevenue(): Double {
    return this.sumOf { it.quantity * it.pricePerUnit }
}

fun main() {
    val sales = listOf(
        Sale("Book", 3, 15.0),
        Sale("Pen", 10, 1.5),
        Sale("Notebook", 5, 8.0)
    )
    println("Total Revenue: $${sales.totalRevenue()}")  
    // 出力: Total Revenue: $116.0
}

まとめ

これらの拡張関数の応用例により、以下の利点が得られます：

  1. コードの再利用：共通の処理を一度定義すれば、何度でも利用可能。
  2. 保守性向上：ロジックが拡張関数に集約されるため、コードの保守が容易。
  3. 効率的なデータ操作：データクラスに関連する操作を直感的に記述できる。

拡張関数を活用することで、Kotlin開発の生産性を大幅に向上させることができます。

注意点とベストプラクティス

Kotlinの拡張関数は非常に便利ですが、適切に使用しないとコードが予期しない動作をする可能性があります。ここでは、拡張関数を使う際の注意点とベストプラクティスを解説します。

1. 拡張関数はオーバーライドできない

拡張関数はクラスのメンバ関数ではないため、サブクラスでオーバーライドすることができません。メンバ関数が優先される点に注意が必要です。

open class Animal
fun Animal.speak() = println("Animal speaks")

class Dog : Animal()

fun main() {
    val dog: Animal = Dog()
    dog.speak()  // 出力: Animal speaks（Dogでオーバーライドされない）
}

ベストプラクティス：拡張関数とメンバ関数の名前が競合しないように設計する。

2. 拡張関数はクラスの非公開メンバにアクセスできない

拡張関数は、対象クラスの非公開（private）または保護（protected）メンバにはアクセスできません。

class User(private val password: String)

fun User.showPassword(): String {
    // return password  // コンパイルエラー：非公開メンバにアクセス不可
    return "Access Denied"
}

ベストプラクティス：拡張関数は公開メンバに対してのみ操作するように設計する。

3. 拡張関数のスコープに注意

拡張関数のスコープは定義した場所によって異なります。同じ名前の拡張関数が異なる場所にある場合、意図しない関数が呼ばれることがあります。

fun String.firstLetter() = this.first()

fun main() {
    println("Hello".firstLetter())  // 出力: H
}

別の場所に同名の拡張関数があると、どちらが呼ばれるかが曖昧になるため注意が必要です。

ベストプラクティス：拡張関数の命名は明確にし、パッケージやファイルのスコープに注意する。

4. 拡張関数の利用は適材適所で

拡張関数は便利ですが、すべての処理を拡張関数にするべきではありません。クラスの本質的な機能はメンバ関数として定義する方が適切です。

ベストプラクティス：

  • メンバ関数：クラスの内部状態を操作する基本機能。
  • 拡張関数：クラス外で追加したい補助的な機能。

5. 可読性を保つ

拡張関数を使いすぎると、コードが分散して読みづらくなる可能性があります。特にプロジェクトが大きくなると、どこに拡張関数が定義されているか分かりにくくなります。

ベストプラクティス：関連する拡張関数は同じファイルやパッケージにまとめる。

6. 名前空間の衝突を避ける

拡張関数は、名前の衝突が起こりやすいため、特にライブラリの公開APIを設計する場合は注意が必要です。

ベストプラクティス：一意性のある関数名を付けるか、適切なパッケージを利用する。

まとめ

Kotlinの拡張関数を安全に使用するためには、以下の点を意識しましょう：

  1. オーバーライド不可であることを理解する。
  2. 非公開メンバにはアクセスできない。
  3. スコープと命名に注意する。
  4. メンバ関数と拡張関数を適材適所で使い分ける。
  5. コードの可読性と保守性を考慮する。
  6. 名前空間の衝突を避ける。

これらのベストプラクティスを守ることで、拡張関数を効果的に活用し、保守しやすいコードを実現できます。

まとめ

本記事では、Kotlinにおける拡張関数を活用してデータクラスのプロパティを効率的に操作する方法について解説しました。データクラスの基本から始め、拡張関数の定義方法、特定のプロパティの操作、リストの操作、さらには実用的な応用例と注意点について詳しく紹介しました。

拡張関数を使うことで、次のようなメリットが得られます：

  1. コードのシンプル化：冗長なコードを減らし、直感的に記述できる。
  2. 柔軟性：データクラスを直接変更せずに機能を追加できる。
  3. 再利用性：共通処理を効率的に再利用できる。
  4. 可読性と保守性の向上：ロジックを整理し、管理しやすいコードが書ける。

ただし、拡張関数の使用には注意点もあり、適切なスコープや命名、オーバーライド不可といった特性を考慮する必要があります。これらを意識することで、Kotlinの強力な機能を最大限に活用し、効率的な開発が可能になります。

Kotlinの拡張関数をマスターして、データクラスをより便利に、そしてスマートに活用していきましょう。

Kotlin
データクラス Kotlin 拡張関数

コメント

コメントする

目次
  1. Kotlinデータクラスとは
    1. データクラスの基本構文
    2. データクラスの具体例
    3. データクラスの利用シーン
  2. 拡張関数とは何か
    1. 拡張関数の基本構文
    2. 拡張関数の仕組み
    3. データクラスへの拡張関数適用例
    4. 拡張関数の利点
  3. データクラスで拡張関数を使うメリット
    1. コードの可読性向上
    2. ソースコードの変更が不要
    3. 関数の再利用性向上
    4. シンプルなコードで複雑な処理を実装
    5. まとめ
  4. 基本的な拡張関数の実装例
    1. データクラスの基本例
    2. フルネームを取得する拡張関数
    3. 年齢を1歳加算する拡張関数
    4. プロパティをフォーマットして出力する拡張関数
    5. 拡張関数をチェーンする
    6. まとめ
  5. 特定のプロパティを操作する拡張関数
    1. 特定のプロパティを変更する拡張関数
    2. プロパティを検証する拡張関数
    3. 数値プロパティをフォーマットする拡張関数
    4. 特定の条件でプロパティを変更する
    5. まとめ
  6. データクラスのリストを操作する拡張関数
    1. データクラスのリストを定義
    2. 特定条件のユーザーをフィルタリングする拡張関数
    3. リスト内のユーザー名を取得する拡張関数
    4. 年齢の平均値を計算する拡張関数
    5. 特定の年齢以上のユーザーに対して処理を適用する拡張関数
    6. リストのユーザーをソートする拡張関数
    7. まとめ
  7. 拡張関数の実用的な応用例
    1. 1. ログ出力のフォーマット関数
    2. 2. バリデーション関数
    3. 3. JSON形式への変換関数
    4. 4. 文字列のフィルタリング・整形
    5. 5. リストの集計処理
    6. まとめ
  8. 注意点とベストプラクティス
    1. 1. 拡張関数はオーバーライドできない
    2. 2. 拡張関数はクラスの非公開メンバにアクセスできない
    3. 3. 拡張関数のスコープに注意
    4. 4. 拡張関数の利用は適材適所で
    5. 5. 可読性を保つ
    6. 6. 名前空間の衝突を避ける
    7. まとめ
  9. まとめ