【2026年7月最新】JavaのcompareToメソッド完全ガイド｜文字列・数値・日付の比較とClaude Code活用術

この記事の内容

1. 01compareToメソッドとは｜返り値の意味と使い方の基本
2. 02Stringの文字列を比較する（compareTo・compareToIgnoreCase）
3. 03日付・数値・ラッパークラスの比較
4. 04NullPointerException対策｜StringUtilsを使った安全な比較
5. 05Comparatorで独自のソート順を定義する
6. 06【独自】Claude CodeでJavaの比較・ソートコードを自動生成する
7. FAQよくある質問

📚 用語解説

compareToメソッド：Javaのオブジェクト同士の大小関係を整数値で返すメソッド。Comparableインターフェースで定義されており、String・Integer・Date・BigDecimalなど多くのクラスで実装されています。「a.compareTo(b)」は「aとbを比較して、aが小さければ負の値、等しければ0、大きければ正の値を返す」という仕様です。

// 基本構文
変数1.compareTo(変数2)

// 返り値の意味
// 変数1 < 変数2 → 負の値（通常は -1）
// 変数1 == 変数2 → 0
// 変数1 > 変数2 → 正の値（通常は 1）

import java.util.Integer;

public class Main {
    public static void main(String[] args) {
        Integer a = 1;
        Integer b = 2;

        // a(1) < b(2) → 「1 - 2 = 負」のイメージ → -1
        System.out.println(a.compareTo(b));  // -1

        // b(2) > a(1) → 「2 - 1 = 正」のイメージ → 1
        System.out.println(b.compareTo(a));  // 1

        // 同じ → 「1 - 1 = 0」→ 0
        System.out.println(a.compareTo(a));  // 0
    }
}

compareToはComparableインターフェースのメソッドで、クラス自身に実装します（Integer・String等は標準実装済み）。一方、Comparatorは別クラスに比較ロジックを実装するインターフェースで、compare()メソッドを定義します。「クラス自体に自然な順序がある（Comparable）」か「外から比較方法を注入する（Comparator）」かの違いです。

public class Main {
    public static void main(String[] args) {
        String str1 = "apple";
        String str2 = "banana";
        String str3 = "apple";

        // "apple" vs "banana"
        // 'a'(97) < 'b'(98) → 負の値
        System.out.println(str1.compareTo(str2));  // -1

        // "banana" vs "apple" → 正の値
        System.out.println(str2.compareTo(str1));  // 1

        // 同じ文字列 → 0
        System.out.println(str1.compareTo(str3));  // 0

        // 単純なif文での使用例
        if (str1.compareTo(str2) < 0) {
            System.out.println(str1 + "は" + str2 + "より辞書順で前");
        }
    }
}

📚 用語解説

compareToIgnoreCaseメソッド：compareToの大文字小文字を無視（ignore case）するバリエーション。「Hello」と「hello」を比較すると通常のcompareToでは不一致ですが、compareToIgnoreCaseでは一致（0）を返します。メールアドレスや商品名の比較でよく使います。

public class Main {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "hello";
        String str3 = "HELLO";

        // 大文字小文字を区別する（通常のcompareTo）
        System.out.println(str1.compareTo(str2));           // -32（異なる）
        System.out.println(str1.compareTo(str3));           // 32（異なる）

        // 大文字小文字を無視する（compareToIgnoreCase）
        System.out.println(str1.compareToIgnoreCase(str2)); // 0（等しい）
        System.out.println(str1.compareToIgnoreCase(str3)); // 0（等しい）

        // 実務例：メールアドレスの大文字小文字を無視した比較
        String email1 = "User@Example.COM";
        String email2 = "user@example.com";
        if (email1.compareToIgnoreCase(email2) == 0) {
            System.out.println("同じメールアドレス");  // これが出力される
        }
    }
}

単純に「同じかどうか」だけ確認したい場合はequals()を使いましょう。compareToは「等しいかどうか + どちらが大きいか」が分かる必要がある場合（ソートや範囲チェック）に使います。また文字列の等値比較には「==」ではなくequals()を使うのが鉄則です（「==」は参照を比較するため、同じ内容の文字列でも異なるオブジェクトだとfalseになります）。

import java.util.Date;

public class Main {
    public static void main(String[] args) {
        // 2024年1月1日 と 2024年12月31日を比較
        Date date1 = new Date(2024 - 1900, 0, 1);   // 2024/01/01
        Date date2 = new Date(2024 - 1900, 11, 31);  // 2024/12/31

        System.out.println(date1.compareTo(date2));  // -1（date1が過去）
        System.out.println(date2.compareTo(date1));  // 1（date2が未来）
        System.out.println(date1.compareTo(date1));  // 0（同じ日付）

        // 実務例：期限切れチェック
        Date today = new Date();
        Date deadline = new Date(2026 - 1900, 11, 31); // 2026/12/31

        if (today.compareTo(deadline) > 0) {
            System.out.println("期限切れ");
        } else {
            System.out.println("期限内");
        }
    }
}

📚 用語解説

BigDecimalクラス：浮動小数点数の精度問題を避けるためのJavaクラス。doubleやfloatは「0.1 + 0.2 = 0.30000000000000004」のような計算誤差が出ますが、BigDecimalでは正確な10進数演算ができます。金額・税率・会計計算など精度が重要な処理で使います。

import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) {
        BigDecimal price1 = new BigDecimal("1000.00");
        BigDecimal price2 = new BigDecimal("1000.10");
        BigDecimal price3 = new BigDecimal("1000.00");

        System.out.println(price1.compareTo(price2));  // -1
        System.out.println(price2.compareTo(price1));  // 1
        System.out.println(price1.compareTo(price3));  // 0

        // BigDecimalの注意点：equalsとcompareToの違い
        BigDecimal a = new BigDecimal("1.0");
        BigDecimal b = new BigDecimal("1.00");

        // equals()は小数点以下の桁数も考慮する
        System.out.println(a.equals(b));       // false（桁数が違う）
        // compareTo()は数値として比較する
        System.out.println(a.compareTo(b));    // 0（同じ値）

        // 実務例：商品価格の範囲チェック
        BigDecimal minPrice = new BigDecimal("100");
        BigDecimal maxPrice = new BigDecimal("10000");
        BigDecimal targetPrice = new BigDecimal("5000");

        if (targetPrice.compareTo(minPrice) >= 0 &&
            targetPrice.compareTo(maxPrice) <= 0) {
            System.out.println("有効な価格範囲内");
        }
    }
}

BigDecimalの等値比較には必ずcompareTo() == 0を使いましょう。new BigDecimal("1.0")とnew BigDecimal("1.00")はequals()ではfalse（小数点以下の桁数が違う）ですが、compareTo()では0（数値として等しい）になります。金額計算のバグの原因になりやすいので注意が必要です。

📚 用語解説

ラッパークラス：Javaのプリミティブ型（int, double等）をオブジェクトとして扱えるようにしたクラス群。Integer（int）・Double（double）・Long（long）・Float（float）・Boolean（boolean）・Character（char）があります。compareToはオブジェクトのメソッドなので、プリミティブ型ではなくラッパークラスを使う必要があります。

public class Main {
    public static void main(String[] args) {
        // Integerラッパークラスの比較
        Integer num1 = 100;  // オートボクシングで Integer に変換
        Integer num2 = 200;

        System.out.println(num1.compareTo(num2));  // -1
        System.out.println(num2.compareTo(num1));  // 1
        System.out.println(num1.compareTo(100));   // 0

        // Doubleでも同様
        Double d1 = 3.14;
        Double d2 = 2.71;
        System.out.println(d1.compareTo(d2));  // 1（d1の方が大きい）

        // 静的メソッドも使える（Java 7以降推奨）
        System.out.println(Integer.compare(100, 200));  // -1
        System.out.println(Double.compare(3.14, 2.71)); // 1
    }
}

Integer.compare(a, b)という静的メソッドを使うと、a.compareTo(b)と同じ結果をプリミティブ型intのまま使えます。オートボクシング（intからIntegerへの変換）のオーバーヘッドがないため、パフォーマンスが重要な処理ではInteger.compare()の方が推奨されます。

📚 用語解説

NullPointerException（NPE）：Javaで最も頻繁に発生する例外の1つ。nullの参照に対してメソッドを呼び出したり、フィールドにアクセスしようとすると発生します。「str1.compareTo(str2)」でstr1がnullだとNPEが発生します。実務では外部API・ユーザー入力・DBからのデータにnullが混在することが多いため、必ず対策が必要です。

// NPEが発生するケース（危険）
String str1 = null;
String str2 = "hello";
str1.compareTo(str2);  // NullPointerException！

// シンプルなnullチェック（基本）
if (str1 != null && str1.compareTo(str2) < 0) {
    // null以外の場合だけ比較
}

// Apache Commons LangのStringUtilsを使う
// pom.xmlまたはbuild.gradleに依存関係を追加してから使用

import org.apache.commons.lang3.StringUtils;

public class Main {
    public static void main(String[] args) {
        String str1 = null;
        String str2 = "hello";
        String str3 = null;

        // StringUtils.compare()はnullが来てもNPEが発生しない
        // null は 非nullより「小さい」と判断される
        System.out.println(StringUtils.compare(str1, str2));   // -1
        System.out.println(StringUtils.compare(str2, str1));   // 1
        System.out.println(StringUtils.compare(str1, str3));   // 0（null == null）

        // nullを「大きい」方向に変えることもできる
        System.out.println(StringUtils.compare(str1, str2, false)); // 1（nullが大きい扱い）
    }
}

import java.util.Comparator;
import java.util.Objects;

// Comparator.nullsFirst / Comparator.nullsLast でもnull安全
String str1 = null;
String str2 = "hello";

// nullを先頭に（nullが最小扱い）
Comparator nullFirst = Comparator.nullsFirst(Comparator.naturalOrder());
System.out.println(nullFirst.compare(str1, str2));  // 負の値（nullが前）

// nullを末尾に（nullが最大扱い）
Comparator nullLast = Comparator.nullsLast(Comparator.naturalOrder());
System.out.println(nullLast.compare(str1, str2));   // 正の値（nullが後）

📚 用語解説

Comparatorインターフェース：Javaでソート順を外部から注入するためのインターフェース。compare(a, b)メソッドで2つのオブジェクトを比較する。Collections.sort()やList.sort()の第2引数として渡す。Java 8以降はラムダ式で簡潔に書けます。Comparableと異なり、クラス自体を変更せずにソート基準を変更できます。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List names = Arrays.asList("佐藤", "田中", "山田", "阿部");

        // 自然順（デフォルト）でソート
        Collections.sort(names);
        System.out.println(names);  // [佐藤, 山田, 田中, 阿部]（Unicode順）

        // 逆順でソート（Comparator.reverseOrder()）
        names.sort(Comparator.reverseOrder());
        System.out.println(names);

        // 文字列長でソート（短い順）
        names.sort(Comparator.comparingInt(String::length));
        System.out.println(names);

        // 複数条件でソート：文字列長 → 辞書順
        names.sort(Comparator.comparingInt(String::length)
                              .thenComparing(Comparator.naturalOrder()));
        System.out.println(names);
    }
}

import java.util.*;

class Employee {
    String name;
    int age;
    double salary;

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

public class Main {
    public static void main(String[] args) {
        List employees = Arrays.asList(
            new Employee("山田", 35, 500000),
            new Employee("佐藤", 28, 400000),
            new Employee("田中", 35, 600000),
            new Employee("鈴木", 28, 450000)
        );

        // 年齢でソート
        employees.sort(Comparator.comparingInt(e -> e.age));

        // 給与の降順でソート
        employees.sort(Comparator.comparingDouble((Employee e) -> e.salary).reversed());

        // 複数条件：年齢昇順 → 給与降順
        employees.sort(
            Comparator.comparingInt((Employee e) -> e.age)
                      .thenComparing(Comparator.comparingDouble((Employee e) -> e.salary).reversed())
        );

        employees.forEach(e ->
            System.out.println(e.name + " : " + e.age + "歳, " + e.salary + "円")
        );
    }
}

import java.util.*;
import java.util.stream.*;

public class Main {
    public static void main(String[] args) {
        Map scores = new HashMap<>();
        scores.put("山田", 85);
        scores.put("佐藤", 92);
        scores.put("田中", 78);
        scores.put("鈴木", 88);

        // Valueの降順でソート（Stream APIを使用）
        Map sorted = scores.entrySet().stream()
            .sorted(Map.Entry.comparingByValue().reversed())
            .collect(Collectors.toLinkedHashMap(
                Map.Entry::getKey,
                Map.Entry::getValue,
                (e1, e2) -> e1,
                LinkedHashMap::new
            ));

        sorted.forEach((name, score) ->
            System.out.println(name + ": " + score)
        );
        // 佐藤: 92, 鈴木: 88, 山田: 85, 田中: 78
    }
}

【Claude Codeへの指示例：コピーして使えます】

「Javaで以下の仕様のソート処理を書いてください。

データクラス：
・Employeeクラス（name: String, department: String, age: int, salary: double）

ソート要件：
1. departmentを昇順で並べる（大文字小文字無視）
2. 同じdepartmentの場合はsalaryを降順で並べる
3. それでも同じ場合はageを昇順で並べる
4. nameやdepartmentがnullの場合はnullFirstで処理する

Listに対してソートを適用し、
結果をSystem.out.printlnで出力するコードを書いてください。
JavaのStreamとComparatorを使って1メソッドで完結させてください。」

import java.util.*;
import java.util.stream.*;

class Employee {
    String name;
    String department;
    int age;
    double salary;

    Employee(String name, String department, int age, double salary) {
        this.name = name;
        this.department = department;
        this.age = age;
        this.salary = salary;
    }
}

public class Main {
    public static void main(String[] args) {
        List employees = Arrays.asList(
            new Employee("山田", "営業部", 35, 500000),
            new Employee("佐藤", "開発部", 28, 600000),
            new Employee("田中", "営業部", 32, 550000),
            new Employee(null, "開発部", 30, 480000)
        );

        // Claude Codeが生成したソート処理
        Comparator comparator =
            Comparator.comparing(
                (Employee e) -> e.department,
                Comparator.nullsFirst(String.CASE_INSENSITIVE_ORDER)
            )
            .thenComparing(
                (Employee e) -> e.salary,
                Comparator.reverseOrder()
            )
            .thenComparingInt((Employee e) -> e.age);

        employees.stream()
            .sorted(comparator)
            .forEach(e -> System.out.printf("%-10s %-8s %3d歳 %,7.0f円%n",
                e.name, e.department, e.age, e.salary));
    }
}

【テストコード生成の指示例】

「先ほど生成したEmployeeのComparatorに対して、
JUnit 5のテストコードを書いてください。

テスト要件：
1. 同一departmentで salary降順になることを確認
2. departmentが異なる場合に昇順になることを確認
3. departmentがnullの場合に先頭に来ることを確認
4. 複数の等価条件でageによる昇順になることを確認

各テストケースにわかりやすい@DisplayNameをつけてください。」

NEXT STEP

この記事の内容を、あなたのビジネスで
実践してみませんか？