Kotlinでデータクラスをシーケンス処理に活用する方法を解説

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

// シーケンスの生成
val sequence = sequenceOf(1, 2, 3, 4, 5)

// シーケンスをコレクションから生成
val listSequence = listOf(1, 2, 3, 4, 5).asSequence()

// 無限シーケンスの生成
val infiniteSequence = generateSequence(1) { it + 1 }

val result = listOf(1, 2, 3, 4, 5)
    .asSequence() // シーケンスに変換
    .filter { it % 2 == 0 } // 偶数をフィルタリング
    .map { it * 2 } // 各要素を2倍に変換
    .toList() // シーケンスをリストに変換

println(result) // [4, 8]

// リストの場合
val list = listOf(1, 2, 3).map { it * 2 }.filter { it > 2 }
println(list) // すべての操作が即時実行される

// シーケンスの場合
val sequence = listOf(1, 2, 3).asSequence().map { it * 2 }.filter { it > 2 }
println(sequence.toList()) // 操作が遅延評価され、結果のみ生成

// データクラスの定義
data class Employee(val id: Int, val name: String, val salary: Double)

// ダミーデータのリスト
val employees = listOf(
    Employee(1, "Alice", 5000.0),
    Employee(2, "Bob", 3000.0),
    Employee(3, "Charlie", 7000.0)
)

// シーケンス処理の適用
val highEarners = employees.asSequence()
    .filter { it.salary > 4000.0 } // 給料が4000以上の従業員を抽出
    .map { it.name } // 名前だけを抽出
    .toList() // リストに変換

println(highEarners) // [Alice, Charlie]

// 顧客情報を表すデータクラス
data class Customer(val id: Int, val name: String, val age: Int, val city: String)

// サンプルデータ
val customers = listOf(
    Customer(1, "Alice", 30, "New York"),
    Customer(2, "Bob", 22, "Los Angeles"),
    Customer(3, "Charlie", 35, "Chicago"),
    Customer(4, "Diana", 28, "New York"),
    Customer(5, "Eve", 40, "Seattle")
)

// New York在住の30歳以上の顧客を抽出
val result = customers.asSequence()
    .filter { it.city == "New York" && it.age >= 30 } // 条件に基づくフィルタリング
    .map { it.name } // 名前のみを抽出
    .toList() // 結果をリストに変換

println(result) // [Alice]

// 顧客データを都市ごとにグループ化して名前を抽出
val groupedByCity = customers.asSequence()
    .groupBy { it.city } // 都市ごとにグループ化
    .mapValues { entry -> entry.value.map { it.name } } // 各グループの名前を抽出

println(groupedByCity)
// {New York=[Alice, Diana], Los Angeles=[Bob], Chicago=[Charlie], Seattle=[Eve]}

// 名前を大文字に変換
val namesUppercase = customers.asSequence()
    .map { it.name.uppercase() } // 名前を大文字に変換
    .toList()

println(namesUppercase) // [ALICE, BOB, CHARLIE, DIANA, EVE]

// 顧客データからシンプルな概要データを生成
data class CustomerSummary(val id: Int, val name: String)

val summaries = customers.asSequence()
    .map { CustomerSummary(it.id, it.name) } // 新しいデータクラスに変換
    .toList()

println(summaries)
// [CustomerSummary(id=1, name=Alice), CustomerSummary(id=2, name=Bob), ...]

// 30歳以上の顧客を抽出
val adults = customers.asSequence()
    .filter { it.age >= 30 } // 年齢が30以上の顧客
    .toList()

println(adults)
// [Customer(id=1, name=Alice, age=30, city=New York), ...]

// New York在住かつ30歳以上の顧客を抽出
val nyAdults = customers.asSequence()
    .filter { it.city == "New York" && it.age >= 30 } // 複数条件
    .toList()

println(nyAdults)
// [Customer(id=1, name=Alice, age=30, city=New York)]

// New York在住の顧客の名前を大文字で抽出
val nyNamesUppercase = customers.asSequence()
    .filter { it.city == "New York" } // New York在住の顧客を絞り込み
    .map { it.name.uppercase() } // 名前を大文字に変換
    .toList()

println(nyNamesUppercase) // [ALICE, DIANA]

// 年齢層ごとに顧客を分類
val ageGroups = customers.asSequence()
    .groupBy { when (it.age) {
        in 0..18 -> "Youth"
        in 19..35 -> "Young Adult"
        else -> "Adult"
    }}

println(ageGroups)
// {Young Adult=[Customer(id=1, ...), Customer(id=4, ...)], Adult=[Customer(id=5, ...)], ...}

// リストを使用した即時評価
val immediateResult = customers
    .filter { it.age > 25 } // すべてのデータをメモリ上で処理
    .map { it.name }
println(immediateResult) // リストがすぐに生成される

// シーケンスを使用した遅延評価
val lazyResult = customers.asSequence()
    .filter { it.age > 25 } // 必要なデータのみ逐次処理
    .map { it.name }
println(lazyResult.toList()) // データが必要になるまで処理されない

// 効率の悪い例: mapを先に適用
val inefficientResult = customers.asSequence()
    .map { it.name.uppercase() } // すべてのデータに対して処理
    .filter { it.startsWith("A") }

// 効率の良い例: filterを先に適用
val efficientResult = customers.asSequence()
    .filter { it.name.startsWith("A") } // 必要なデータのみ残す
    .map { it.uppercase() }

// 小規模データではリストが効率的
val smallDataResult = customers.filter { it.age > 25 }.map { it.name }

// 大規模データではシーケンスが効率的
val largeDataResult = customers.asSequence().filter { it.age > 25 }.map { it.name }.toList()

val startTime = System.nanoTime()
val result = customers.asSequence()
    .filter { it.age > 25 }
    .map { it.name }
    .toList()
val endTime = System.nanoTime()

println("Execution Time: ${endTime - startTime} ns")

val parallelResult = customers.parallelStream()
    .filter { it.age > 25 }
    .map { it.name }
    .toList()

println(parallelResult)

val nullableCustomers = listOf(
    Customer(1, "Alice", 30, "New York"),
    null, // nullable要素
    Customer(2, "Bob", 22, "Los Angeles")
)

val names = nullableCustomers.asSequence()
    .filterNotNull() // null要素を排除
    .map { it.name }
    .toList()

println(names) // [Alice, Bob]

val infiniteSequence = generateSequence(1) { it + 1 }
    .take(10) // 10個のデータに制限
    .toList()

println(infiniteSequence) // [1, 2, 3, ..., 10]

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

val users = listOf(
    User(1, "Alice"),
    User(2, "Bob")
)

val ids = users.asSequence()
    .map { it.id.toString() } // 型変換を慎重に実施
    .toList()

println(ids) // [1, 2]

val result = customers.asSequence()
    .filter {
        println("Filtering: ${it.name}")
        it.age > 25
    }
    .map {
        println("Mapping: ${it.name}")
        it.name
    }
    .toList()

val filteredList = customers.asSequence()
    .filter { it.age > 25 }
    .toList() // 中間結果をリストで確認

println(filteredList)

import org.junit.Test
import kotlin.test.assertEquals

class SequenceTest {
    @Test
    fun testFiltering() {
        val result = customers.asSequence()
            .filter { it.age > 25 }
            .map { it.name }
            .toList()
        assertEquals(listOf("Alice", "Charlie", "Diana", "Eve"), result)
    }
}

data class LogEntry(val timestamp: String, val level: String, val message: String)

val logs = sequenceOf(
    LogEntry("2024-12-15 10:00:00", "INFO", "Application started"),
    LogEntry("2024-12-15 10:01:00", "ERROR", "Database connection failed"),
    LogEntry("2024-12-15 10:02:00", "INFO", "User logged in"),
    LogEntry("2024-12-15 10:03:00", "ERROR", "Failed to load configuration file")
)

val errorLogs = logs
    .filter { it.level == "ERROR" } // エラーレベルのログを抽出
    .map { "${it.timestamp}: ${it.message}" } // 簡略化
    .toList()

println(errorLogs)
// [2024-12-15 10:01:00: Database connection failed, 2024-12-15 10:03:00: Failed to load configuration file]

data class Customer(val id: Int, val name: String, val age: Int, val purchases: Double)

val customers = listOf(
    Customer(1, "Alice", 30, 1200.0),
    Customer(2, "Bob", 22, 300.0),
    Customer(3, "Charlie", 35, 700.0),
    Customer(4, "Diana", 28, 1500.0),
    Customer(5, "Eve", 40, 200.0)
)

val customerCategories = customers.asSequence()
    .groupBy { when {
        it.purchases > 1000 -> "High Spenders"
        it.purchases > 500 -> "Medium Spenders"
        else -> "Low Spenders"
    } }

customerCategories.forEach { (category, customerList) ->
    println("$category: ${customerList.map { it.name }}")
}
// 出力例
// High Spenders: [Alice, Diana]
// Medium Spenders: [Charlie]
// Low Spenders: [Bob, Eve]

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

val apiResponse = listOf(
    Product(1, "Laptop", 1500.0),
    Product(2, "Mouse", 25.0),
    Product(3, "Keyboard", 75.0),
    Product(4, "Monitor", 300.0),
    Product(5, "USB Cable", 10.0)
)

val discountedProducts = apiResponse.asSequence()
    .filter { it.price > 100 } // 高価格商品をフィルタ
    .map { it.copy(price = it.price * 0.9) } // 割引を適用
    .toList()

println(discountedProducts)
// [Product(id=1, name=Laptop, price=1350.0), Product(id=4, name=Monitor, price=270.0)]

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

val products = listOf(
    Product(1, "Laptop", "Electronics", 1500.0),
    Product(2, "Notebook", "Stationery", 5.0),
    Product(3, "Headphones", "Electronics", 100.0),
    Product(4, "Pen", "Stationery", 1.5),
    Product(5, "Smartphone", "Electronics", 800.0)
)

[LAPTOP, SMARTPHONE]

Electronics: 2400.0
Stationery: 6.5

[Product(id=1, name=Product_100, category=Electronics, price=100.0), ...]