@k2works/claude-code-booster 6.2.0 → 6.3.1

package/lib/assets/docs/article/getting-start-tdd/java/09-solid-principles-and-module-design.md

@@ -1,319 +0,0 @@
----
-type: Article
-title: "第 9 章: SOLID 原則とモジュール設計"
-description: "前章までで、FizzBuzz のコードはデザインパターンを適用して大きく改善されました。"
-tags: [article, getting-start-tdd, java]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 9 章: SOLID 原則とモジュール設計
-
-## 9.1 はじめに
-
-前章までで、FizzBuzz のコードはデザインパターンを適用して大きく改善されました。しかし、すべてのクラスが `tdd.fizzbuzz` という 1 つのパッケージに詰め込まれています。
-
-この章では、**SOLID 原則** を確認しながら、クラスを適切なパッケージに分割する **モジュール設計** を行います。
-
-## 9.2 SOLID 原則の確認
-
-FizzBuzz のコードが SOLID 原則にどの程度準拠しているか確認しましょう。
-
-### 単一責任原則（SRP: Single Responsibility Principle）
-
-> クラスを変更する理由は 1 つだけであるべき。
-
-| クラス | 責務 | 変更理由 | SRP 準拠 |
-|--------|------|---------|---------|
-| `FizzBuzzType01` | タイプ 1 の変換ルール | タイプ 1 のルール変更時 | OK |
-| `FizzBuzzType02` | タイプ 2 の変換ルール | タイプ 2 のルール変更時 | OK |
-| `FizzBuzzType03` | タイプ 3 の変換ルール | タイプ 3 のルール変更時 | OK |
-| `FizzBuzzValue` | 値の保持と等価性 | 値の表現が変わるとき | OK |
-| `FizzBuzzList` | コレクション操作 | コレクション操作が変わるとき | OK |
-| `FizzBuzzValueCommand` | 単一値変換の実行 | 実行方法が変わるとき | OK |
-| `FizzBuzzListCommand` | リスト生成の実行 | 実行方法が変わるとき | OK |
-
-ポリモーフィズムとデザインパターンの適用により、各クラスが単一の責務を持つようになっています。
-
-### 開放閉鎖原則（OCP: Open-Closed Principle）
-
-> 拡張に対して開いていて、修正に対して閉じているべき。
-
-新しいタイプ（例: タイプ 4）を追加する場合を考えてみましょう。
-
-```java
-// タイプ 4 を追加するのに必要な変更
-// 1. 新しいクラスを追加（既存コードの修正なし）
-public class FizzBuzzType04 extends FizzBuzzType {
-    @Override
-    public FizzBuzzValue generate(int number) {
-        // タイプ 4 のルール
-        return new FizzBuzzValue(number, String.valueOf(number));
-    }
-}
-
-// 2. ファクトリメソッドに 1 行追加（最小限の修正）
-case 4: return new FizzBuzzType04();
-```
-
-`FizzBuzzType` 階層は拡張に対して開いています。新しいタイプを追加しても、既存のタイプクラスや `FizzBuzzCommand` を修正する必要はありません。
-
-### 依存性逆転原則（DIP: Dependency Inversion Principle）
-
-> 上位モジュールは下位モジュールに依存すべきではない。どちらも抽象に依存すべき。
-
-```
-FizzBuzz → FizzBuzzType（抽象）← FizzBuzzType01, 02, 03
-FizzBuzzCommand（抽象）← FizzBuzzValueCommand, FizzBuzzListCommand
-```
-
-`FizzBuzz` クラスは具体的な `FizzBuzzType01` ではなく、抽象的な `FizzBuzzType` に依存しています。
-
-## 9.3 パッケージ設計
-
-### 現在の問題
-
-すべてのクラスが `tdd.fizzbuzz` に入っています。
-
-```
-tdd.fizzbuzz/
-├── FizzBuzz.java
-├── FizzBuzzType.java
-├── FizzBuzzType01.java
-├── FizzBuzzType02.java
-├── FizzBuzzType03.java
-├── FizzBuzzValue.java
-├── FizzBuzzList.java
-├── FizzBuzzCommand.java
-├── FizzBuzzValueCommand.java
-├── FizzBuzzListCommand.java
-└── Main.java
-```
-
-クラスが増えるにつれて、どのクラスがどの責務を持つかが分かりにくくなります。
-
-### パッケージ分割
-
-責務に基づいてパッケージを分割します。
-
-```
-tdd/
-├── App.java                         # エントリポイント
-└── fizzbuzz/
-    ├── domain/
-    │   ├── type/
-    │   │   ├── FizzBuzzType.java     # 抽象タイプ + Factory
-    │   │   ├── FizzBuzzType01.java   # タイプ 1
-    │   │   ├── FizzBuzzType02.java   # タイプ 2
-    │   │   └── FizzBuzzType03.java   # タイプ 3
-    │   └── model/
-    │       ├── FizzBuzzValue.java    # 値オブジェクト
-    │       └── FizzBuzzList.java     # コレクション
-    └── application/
-        ├── FizzBuzzCommand.java      # コマンドインターフェース
-        ├── FizzBuzzValueCommand.java # 単一値コマンド
-        └── FizzBuzzListCommand.java  # リストコマンド
-```
-
-### パッケージの責務
-
-| パッケージ | 責務 | 含まれるクラス |
-|-----------|------|--------------|
-| `tdd.fizzbuzz.domain.type` | 変換ルール（ビジネスロジック） | `FizzBuzzType` 階層 |
-| `tdd.fizzbuzz.domain.model` | ドメインモデル（値・コレクション） | `FizzBuzzValue`, `FizzBuzzList` |
-| `tdd.fizzbuzz.application` | アプリケーション層（操作の実行） | `FizzBuzzCommand` 階層 |
-
-### 依存関係
-
-```plantuml
-@startuml
-title パッケージ依存関係
-
-package "tdd" {
-  class App
-}
-
-package "tdd.fizzbuzz.application" {
-  interface FizzBuzzCommand
-  class FizzBuzzValueCommand
-  class FizzBuzzListCommand
-}
-
-package "tdd.fizzbuzz.domain.type" {
-  abstract class FizzBuzzType
-  class FizzBuzzType01
-  class FizzBuzzType02
-  class FizzBuzzType03
-}
-
-package "tdd.fizzbuzz.domain.model" {
-  class FizzBuzzValue
-  class FizzBuzzList
-}
-
-App --> FizzBuzzCommand
-App --> FizzBuzzType
-
-FizzBuzzValueCommand --> FizzBuzzType
-FizzBuzzListCommand --> FizzBuzzType
-FizzBuzzListCommand --> FizzBuzzList
-
-FizzBuzzType ..> FizzBuzzValue : 生成
-FizzBuzzList o-- FizzBuzzValue
-
-@enduml
-```
-
-`application` パッケージは `domain` に依存しますが、`domain` は `application` に依存しません。これにより、ビジネスロジックがアプリケーション層から独立して変更・テストできます。
-
-## 9.4 エントリポイントの更新
-
-パッケージ分割後の `App.java` です。
-
-```java
-package tdd;
-
-import tdd.fizzbuzz.application.FizzBuzzListCommand;
-import tdd.fizzbuzz.application.FizzBuzzValueCommand;
-import tdd.fizzbuzz.domain.model.FizzBuzzList;
-import tdd.fizzbuzz.domain.model.FizzBuzzValue;
-import tdd.fizzbuzz.domain.type.FizzBuzzType;
-
-public class App {
-    private static final int MAX_NUMBER = 100;
-
-    public static void main(String[] args) {
-        FizzBuzzType type = FizzBuzzType.create(1);
-
-        // 単一値の取得
-        FizzBuzzValueCommand valueCommand
-            = new FizzBuzzValueCommand(type);
-        FizzBuzzValue value = valueCommand.execute(15);
-        System.out.println(value);
-
-        // リストの生成
-        FizzBuzzListCommand listCommand
-            = new FizzBuzzListCommand(type);
-        FizzBuzzList list = listCommand.executeList(MAX_NUMBER);
-        for (FizzBuzzValue item : list.getValues()) {
-            System.out.println(item.getValue());
-        }
-    }
-}
-```
-
-## 9.5 テストの更新
-
-テストもパッケージ構造に合わせて再配置します。
-
-```
-src/test/java/tdd/fizzbuzz/
-├── domain/
-│   ├── type/
-│   │   └── FizzBuzzTypeTest.java    # タイプ別テスト
-│   └── model/
-│       ├── FizzBuzzValueTest.java   # 値オブジェクトテスト
-│       └── FizzBuzzListTest.java    # コレクションテスト
-└── application/
-    └── FizzBuzzCommandTest.java     # コマンドテスト
-```
-
-### FizzBuzzTypeTest（タイプ別テスト）
-
-```java
-package tdd.fizzbuzz.domain.type;
-
-import org.junit.jupiter.api.Nested;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-class FizzBuzzTypeTest {
-
-    @Nested
-    class タイプ1の場合 {
-        private final FizzBuzzType type = FizzBuzzType.create(1);
-
-        @Test
-        void 三と五の倍数でFizzBuzzを返す() {
-            assertEquals("FizzBuzz", type.generate(15).getValue());
-        }
-
-        @Test
-        void 三の倍数でFizzを返す() {
-            assertEquals("Fizz", type.generate(3).getValue());
-        }
-
-        @Test
-        void 五の倍数でBuzzを返す() {
-            assertEquals("Buzz", type.generate(5).getValue());
-        }
-
-        @Test
-        void その他は数値を返す() {
-            assertEquals("1", type.generate(1).getValue());
-        }
-    }
-
-    @Nested
-    class タイプ2の場合 {
-        private final FizzBuzzType type = FizzBuzzType.create(2);
-
-        @Test
-        void 常に数値を返す() {
-            assertEquals("3", type.generate(3).getValue());
-            assertEquals("5", type.generate(5).getValue());
-            assertEquals("15", type.generate(15).getValue());
-        }
-    }
-
-    @Nested
-    class タイプ3の場合 {
-        private final FizzBuzzType type = FizzBuzzType.create(3);
-
-        @Test
-        void 十五の倍数のみFizzBuzzを返す() {
-            assertEquals("FizzBuzz", type.generate(15).getValue());
-            assertEquals("3", type.generate(3).getValue());
-            assertEquals("5", type.generate(5).getValue());
-        }
-    }
-
-    @Nested
-    class 不正なタイプの場合 {
-        @Test
-        void 例外をスローする() {
-            assertThrows(IllegalArgumentException.class,
-                () -> FizzBuzzType.create(4));
-        }
-    }
-}
-```
-
-## 9.6 まとめ
-
-この章では SOLID 原則を確認しながらモジュール設計を行いました。
-
-| 概念 | 適用 |
-|------|------|
-| 単一責任原則（SRP） | 各クラスが 1 つの責務を持つ |
-| 開放閉鎖原則（OCP） | 新タイプ追加で既存コード変更不要 |
-| 依存性逆転原則（DIP） | 抽象への依存で結合度を低減 |
-| パッケージ分割 | `domain`（ビジネスロジック）と `application`（操作）の分離 |
-
-### 第 3 部の振り返り
-
-第 3 部（第 7〜9 章）を通じて、手続き的な FizzBuzz をオブジェクト指向設計に変換しました。
-
-| 章 | テーマ | 学んだこと |
-|----|--------|-----------
-| 7 | カプセル化とポリモーフィズム | `private` / `final`、Strategy パターン、抽象クラス |
-| 8 | デザインパターンの適用 | Value Object、First-Class Collection、Command、Factory Method |
-| 9 | SOLID 原則とモジュール設計 | SRP / OCP / DIP、パッケージ分割、ドメインモデル |
-
-```
-Before: 1 つのクラスに全ロジック（手続き型）
-After:  責務ごとにパッケージ分割された OOP 設計
-```
-
-次の第 4 部では、Java の関数型プログラミング機能（Stream API、Optional、Lambda）を使って、さらにコードを発展させます。

package/lib/assets/docs/article/getting-start-tdd/java/10-higher-order-functions-and-composition.md

@@ -1,197 +0,0 @@
----
-type: Article
-title: "第 10 章: 高階関数と関数合成"
-description: "第 3 部では、手続き型の FizzBuzz をオブジェクト指向設計に変換しました。"
-tags: [article, getting-start-tdd, java]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 10 章: 高階関数と関数合成
-
-## 10.1 はじめに
-
-第 3 部では、手続き型の FizzBuzz をオブジェクト指向設計に変換しました。この第 4 部では、Java の **関数型プログラミング** 機能を活用して、さらにコードを発展させます。
-
-Java 8 以降で導入された主要な関数型機能:
-
-| 機能 | 説明 |
-|------|------|
-| Lambda 式 | 匿名関数を簡潔に記述 |
-| メソッド参照 | 既存メソッドを関数として渡す |
-| `Function` インターフェース | 関数を値として扱う |
-| Stream API | コレクションの宣言的処理 |
-
-## 10.2 Lambda 式とメソッド参照
-
-### Lambda 式
-
-Lambda 式を使うと、関数を値として変数に代入したり、引数として渡したりできます。
-
-```java
-// 従来の匿名クラス
-Comparator<FizzBuzzValue> comparator = new Comparator<FizzBuzzValue>() {
-    @Override
-    public int compare(FizzBuzzValue a, FizzBuzzValue b) {
-        return Integer.compare(a.getNumber(), b.getNumber());
-    }
-};
-
-// Lambda 式
-Comparator<FizzBuzzValue> comparator =
-    (a, b) -> Integer.compare(a.getNumber(), b.getNumber());
-```
-
-### メソッド参照
-
-メソッド参照は Lambda 式をさらに簡潔に書く記法です。
-
-```java
-// Lambda 式
-values.stream().map(v -> v.getValue());
-
-// メソッド参照
-values.stream().map(FizzBuzzValue::getValue);
-```
-
-| 種類 | 構文 | 例 |
-|------|------|-----|
-| 静的メソッド | `クラス::メソッド` | `Integer::parseInt` |
-| インスタンスメソッド | `オブジェクト::メソッド` | `type::generate` |
-| 任意オブジェクトのメソッド | `クラス::メソッド` | `FizzBuzzValue::getValue` |
-| コンストラクタ | `クラス::new` | `ArrayList::new` |
-
-## 10.3 Function インターフェース
-
-`java.util.function` パッケージには、関数を型として表現するインターフェースが用意されています。
-
-| インターフェース | シグネチャ | 用途 |
-|----------------|-----------|------|
-| `Function<T, R>` | `R apply(T t)` | 変換 |
-| `Predicate<T>` | `boolean test(T t)` | 条件判定 |
-| `Consumer<T>` | `void accept(T t)` | 副作用のある操作 |
-| `Supplier<T>` | `T get()` | 値の生成 |
-| `UnaryOperator<T>` | `T apply(T t)` | 同じ型への変換 |
-
-### FizzBuzz での活用
-
-`FizzBuzzType` の `generate` メソッドは `int → FizzBuzzValue` の関数です。これを `IntFunction` として表現できます。
-
-```java
-import java.util.function.IntFunction;
-
-// FizzBuzzType.generate は IntFunction<FizzBuzzValue> と同じシグネチャ
-IntFunction<FizzBuzzValue> generator = type::generate;
-FizzBuzzValue result = generator.apply(15);
-```
-
-## 10.4 Stream API の基本
-
-### for ループから Stream へ
-
-`FizzBuzzListCommand` の `executeList` メソッドを Stream API でリファクタリングします。
-
-```java
-// Before: for ループ
-public FizzBuzzList executeList(int count) {
-    List<FizzBuzzValue> values = new ArrayList<>();
-    for (int i = 1; i <= count; i++) {
-        values.add(type.generate(i));
-    }
-    return new FizzBuzzList(values);
-}
-
-// After: Stream API
-public FizzBuzzList executeList(int count) {
-    List<FizzBuzzValue> values = IntStream.rangeClosed(1, count)
-        .mapToObj(type::generate)
-        .collect(Collectors.toList());
-    return new FizzBuzzList(values);
-}
-```
-
-### Stream の 3 ステップ
-
-1. **生成**: `IntStream.rangeClosed(1, count)` — 1 から count までの数列
-2. **中間操作**: `.mapToObj(type::generate)` — 各数値を FizzBuzzValue に変換
-3. **終端操作**: `.collect(Collectors.toList())` — リストに集約
-
-## 10.5 関数合成
-
-### compose と andThen
-
-`Function` インターフェースは関数を合成するメソッドを持っています。
-
-```java
-Function<Integer, FizzBuzzValue> generate = type::generate;
-Function<FizzBuzzValue, String> getValue = FizzBuzzValue::getValue;
-
-// andThen: generate した後に getValue を実行
-Function<Integer, String> generateAndGetValue =
-    generate.andThen(getValue);
-
-String result = generateAndGetValue.apply(15); // "FizzBuzz"
-```
-
-### Predicate の合成
-
-```java
-Predicate<FizzBuzzValue> isFizz =
-    v -> v.getValue().equals("Fizz");
-Predicate<FizzBuzzValue> isBuzz =
-    v -> v.getValue().equals("Buzz");
-
-// or: Fizz または Buzz
-Predicate<FizzBuzzValue> isFizzOrBuzz = isFizz.or(isBuzz);
-
-// and + negate: Fizz でも Buzz でもない
-Predicate<FizzBuzzValue> isNumber =
-    isFizz.negate().and(isBuzz.negate());
-```
-
-## 10.6 Stream API を使ったフィルタリング
-
-Stream API と Predicate を組み合わせて、FizzBuzzList にフィルタリング機能を追加します。
-
-```java
-// FizzBuzzList にメソッドを追加
-public FizzBuzzList filter(Predicate<FizzBuzzValue> predicate) {
-    List<FizzBuzzValue> filtered = values.stream()
-        .filter(predicate)
-        .collect(Collectors.toList());
-    return new FizzBuzzList(filtered);
-}
-```
-
-使用例:
-
-```java
-FizzBuzzList list = listCommand.executeList(100);
-
-// Fizz だけを抽出
-FizzBuzzList fizzOnly = list.filter(
-    v -> v.getValue().equals("Fizz")
-);
-
-// 数値だけを抽出（Fizz でも Buzz でも FizzBuzz でもない）
-FizzBuzzList numbersOnly = list.filter(
-    v -> !v.getValue().equals("Fizz")
-        && !v.getValue().equals("Buzz")
-        && !v.getValue().equals("FizzBuzz")
-);
-```
-
-## 10.7 まとめ
-
-この章では Java の関数型プログラミングの基礎を学びました。
-
-| 概念 | 適用 |
-|------|------|
-| Lambda 式 | 匿名関数の簡潔な記述 |
-| メソッド参照 | `type::generate`、`FizzBuzzValue::getValue` |
-| Function インターフェース | 関数を値として扱う |
-| Stream API | for ループの宣言的な置き換え |
-| 関数合成 | `andThen`、`compose` による関数の連結 |
-| Predicate 合成 | `and`、`or`、`negate` による条件の組み合わせ |
-
-次の第 11 章では、Stream API をさらに活用してパイプライン処理を構築し、不変データの操作パターンを深掘りします。

package/lib/assets/docs/article/getting-start-tdd/java/11-immutable-data-and-pipeline.md

@@ -1,176 +0,0 @@
----
-type: Article
-title: "第 11 章: 不変データとパイプライン処理"
-description: "前章では Lambda 式、メソッド参照、Stream API の基本を学びました。"
-tags: [article, getting-start-tdd, java]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 11 章: 不変データとパイプライン処理
-
-## 11.1 はじめに
-
-前章では Lambda 式、メソッド参照、Stream API の基本を学びました。この章では **不変データ** の設計パターンを深掘りし、**パイプライン処理** でデータを宣言的に変換する手法を学びます。
-
-## 11.2 不変データの原則
-
-### なぜ不変性が重要か
-
-> 変更可能なデータはしばしば予期せぬ結果や、厄介なバグを引き起こします。そのため、関数型プログラミングは、データは不変であるべきで、更新時は常に元データ構造のコピーを返すようにし、元データには手を触れないという思想に基づいています。
->
-> — Martin Fowler「リファクタリング（第 2 版）」
-
-### FizzBuzz における不変設計の確認
-
-第 8 章で作成した `FizzBuzzValue` と `FizzBuzzList` は既に不変設計です。
-
-| クラス | 不変性の実装 |
-|--------|------------|
-| `FizzBuzzValue` | `final` フィールド、setter なし |
-| `FizzBuzzList` | 防御的コピー、`add()` が新しいインスタンスを返す |
-
-```java
-// FizzBuzzList.add() は元のリストを変更しない
-FizzBuzzList original = listCommand.executeList(10);
-FizzBuzzList extended = original.add(newValues);
-
-// original は変更されていない
-assert original.size() == 10;
-```
-
-## 11.3 Stream パイプラインの構築
-
-### パイプラインとは
-
-Stream API のパイプラインは、データに対する一連の変換を宣言的に記述する仕組みです。
-
-```
-データソース → 中間操作 → 中間操作 → ... → 終端操作
-```
-
-### FizzBuzzList にパイプライン操作を追加
-
-```java
-// map: 各要素を変換
-public <R> List<R> map(Function<FizzBuzzValue, R> mapper) {
-    return values.stream()
-        .map(mapper)
-        .collect(Collectors.toList());
-}
-
-// toStringValues: 値の文字列リストを取得
-public List<String> toStringValues() {
-    return values.stream()
-        .map(FizzBuzzValue::getValue)
-        .collect(Collectors.toList());
-}
-```
-
-### Collectors の活用
-
-```java
-// グルーピング: 値の種類ごとに分類
-public Map<String, List<FizzBuzzValue>> groupByValue() {
-    return values.stream()
-        .collect(Collectors.groupingBy(FizzBuzzValue::getValue));
-}
-
-// カウント: 値の種類ごとの出現回数
-public Map<String, Long> countByValue() {
-    return values.stream()
-        .collect(Collectors.groupingBy(
-            FizzBuzzValue::getValue,
-            Collectors.counting()
-        ));
-}
-
-// 結合: カンマ区切りの文字列に変換
-public String joining(String delimiter) {
-    return values.stream()
-        .map(FizzBuzzValue::getValue)
-        .collect(Collectors.joining(delimiter));
-}
-```
-
-## 11.4 IntStream によるリスト生成
-
-### executeList のリファクタリング
-
-`FizzBuzzListCommand.executeList` を `IntStream` でリファクタリングします。
-
-```java
-// Before: for ループ
-public FizzBuzzList executeList(int count) {
-    List<FizzBuzzValue> values = new ArrayList<>();
-    for (int i = 1; i <= count; i++) {
-        values.add(type.generate(i));
-    }
-    return new FizzBuzzList(values);
-}
-
-// After: IntStream パイプライン
-public FizzBuzzList executeList(int count) {
-    List<FizzBuzzValue> values = IntStream.rangeClosed(1, count)
-        .mapToObj(type::generate)
-        .collect(Collectors.toList());
-    return new FizzBuzzList(values);
-}
-```
-
-### Stream 操作の組み合わせ
-
-```java
-// 1〜100 の FizzBuzz で "Fizz" の出現回数を数える
-long fizzCount = IntStream.rangeClosed(1, 100)
-    .mapToObj(type::generate)
-    .map(FizzBuzzValue::getValue)
-    .filter("Fizz"::equals)
-    .count();
-```
-
-## 11.5 reduce による集約
-
-### 基本的な reduce
-
-```java
-// 数値の合計を計算（FizzBuzz の数値のみ）
-int sum = IntStream.rangeClosed(1, 100)
-    .mapToObj(type::generate)
-    .filter(v -> v.getValue().matches("\\d+"))
-    .mapToInt(FizzBuzzValue::getNumber)
-    .sum();
-```
-
-### FizzBuzzList での reduce 活用
-
-```java
-// FizzBuzzList に統計情報を追加
-public FizzBuzzListStats getStats() {
-    long fizzCount = values.stream()
-        .filter(v -> "Fizz".equals(v.getValue())).count();
-    long buzzCount = values.stream()
-        .filter(v -> "Buzz".equals(v.getValue())).count();
-    long fizzBuzzCount = values.stream()
-        .filter(v -> "FizzBuzz".equals(v.getValue())).count();
-    long numberCount = values.stream()
-        .filter(v -> v.getValue().matches("\\d+")).count();
-
-    return new FizzBuzzListStats(
-        fizzCount, buzzCount, fizzBuzzCount, numberCount);
-}
-```
-
-## 11.6 まとめ
-
-この章では不変データとパイプライン処理を学びました。
-
-| 概念 | 適用 |
-|------|------|
-| 不変データ | `FizzBuzzValue`、`FizzBuzzList` の不変設計を確認 |
-| パイプライン | Stream の中間操作・終端操作の連鎖 |
-| IntStream | `rangeClosed` による数列生成 |
-| Collectors | `groupingBy`、`counting`、`joining` による集約 |
-| reduce / sum | 統計情報の算出 |
-
-次の第 12 章では、`Optional` によるエラーハンドリングと型安全性を学びます。