DP-21: Strategy パターン

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class StrategyPatternSample {

    // ソートアルゴリズムを表すインターフェース（Strategy）
    interface SortStrategy {
        // 配列をソートして返す（元の配列は変更しない）
        int[] sort(int[] data);
    }

    // バブルソートによる実装（計算量: O(n²)）
    static class BubbleSortStrategy implements SortStrategy {
        @Override
        public int[] sort(int[] data) {
            int[] result = Arrays.copyOf(data, data.length); // 元の配列をコピー
            int n = result.length;
            for (int i = 0; i < n - 1; i++) {
                for (int j = 0; j < n - i - 1; j++) {
                    if (result[j] > result[j + 1]) {
                        int temp = result[j];
                        result[j] = result[j + 1];
                        result[j + 1] = temp;
                    }
                }
            }
            System.out.println("  [バブルソート実行]");
            return result;
        }
    }

    // 選択ソートによる実装（計算量: O(n²)）
    static class SelectionSortStrategy implements SortStrategy {
        @Override
        public int[] sort(int[] data) {
            int[] result = Arrays.copyOf(data, data.length);
            int n = result.length;
            for (int i = 0; i < n - 1; i++) {
                int minIdx = i;
                for (int j = i + 1; j < n; j++) {
                    if (result[j] < result[minIdx]) minIdx = j;
                }
                int temp = result[minIdx];
                result[minIdx] = result[i];
                result[i] = temp;
            }
            System.out.println("  [選択ソート実行]");
            return result;
        }
    }

    // Strategy を使う Context クラス
    static class DataProcessor {
        private SortStrategy strategy; // 現在のソート戦略

        public DataProcessor(SortStrategy strategy) {
            this.strategy = strategy;
        }

        // 実行時に戦略を切り替えられるのが Strategy パターンの特徴
        public void setStrategy(SortStrategy strategy) {
            this.strategy = strategy;
        }

        public int[] process(int[] data) {
            return strategy.sort(data);
        }
    }

    // 社員情報クラス（Comparator による Strategy 活用例）
    static class Employee {
        private final String name;
        private final int age;

        public Employee(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() { return name; }
        public int getAge() { return age; }

        @Override
        public String toString() { return name + "(" + age + "歳)"; }
    }

    public static void main(String[] args) {
        System.out.println("=== Strategy パターン: ソートアルゴリズムの切り替え ===");
        System.out.println();

        int[] data = {5, 2, 8, 1, 9, 3};
        System.out.println("ソート前: " + Arrays.toString(data));
        System.out.println();

        // バブルソート戦略で処理開始
        DataProcessor processor = new DataProcessor(new BubbleSortStrategy());
        int[] result1 = processor.process(data);
        System.out.println("バブルソート結果: " + Arrays.toString(result1));

        System.out.println();

        // 実行時に戦略を選択ソートに切り替え
        System.out.println("--- 戦略を選択ソートに切り替え ---");
        processor.setStrategy(new SelectionSortStrategy());
        int[] result2 = processor.process(data);
        System.out.println("選択ソート結果: " + Arrays.toString(result2));

        System.out.println();
        System.out.println("=== Comparator は Strategy パターンそのもの ===");
        System.out.println();

        List<Employee> employees = new ArrayList<Employee>();
        employees.add(new Employee("田中", 35));
        employees.add(new Employee("佐藤", 28));
        employees.add(new Employee("鈴木", 42));
        employees.add(new Employee("山田", 25));

        System.out.println("元のリスト: " + employees);

        // 名前順でソート（戦略1: 匿名クラスで Comparator を定義）
        List<Employee> byName = new ArrayList<Employee>(employees);
        byName.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee a, Employee b) {
                return a.getName().compareTo(b.getName());
            }
        });
        System.out.println("名前順: " + byName);

        // 年齢順でソート（戦略2: ラムダ式で Comparator を定義）
        List<Employee> byAge = new ArrayList<Employee>(employees);
        byAge.sort((a, b) -> Integer.compare(a.getAge(), b.getAge()));
        System.out.println("年齢順: " + byAge);

        // 年齢降順でソート（戦略3: ラムダ式）
        List<Employee> byAgeDesc = new ArrayList<Employee>(employees);
        byAgeDesc.sort((a, b) -> Integer.compare(b.getAge(), a.getAge()));
        System.out.println("年齢降順: " + byAgeDesc);
    }
}