JavaのRecord入門 - イミュータブルなデータクラスを簡潔に定義

1
2

// Recordの定義
record User(String name, int age) {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// 従来のクラス定義（Recordと同等の機能）
public final class User {
    private final String name;
    private final int age;
    
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String name() {
        return name;
    }
    
    public int age() {
        return age;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User user)) return false;
        return age == user.age && Objects.equals(name, user.name);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    
    @Override
    public String toString() {
        return "User[name=" + name + ", age=" + age + "]";
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public class RecordExample {
    public static void main(String[] args) {
        // インスタンス生成
        User user = new User("田中太郎", 30);
        
        // アクセサメソッドによる値の取得
        System.out.println("名前: " + user.name());  // 名前: 田中太郎
        System.out.println("年齢: " + user.age());   // 年齢: 30
        
        // toString()の出力
        System.out.println(user);  // User[name=田中太郎, age=30]
        
        // equals()による比較
        User user2 = new User("田中太郎", 30);
        System.out.println(user.equals(user2));  // true
        
        // hashCode()の一致
        System.out.println(user.hashCode() == user2.hashCode());  // true
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

record Point(int x, int y) {}

public class EqualsHashCodeDemo {
    public static void main(String[] args) {
        Point p1 = new Point(10, 20);
        Point p2 = new Point(10, 20);
        Point p3 = new Point(10, 30);
        
        // 同じ値を持つRecordは等しい
        System.out.println(p1.equals(p2));  // true
        System.out.println(p1.equals(p3));  // false
        
        // HashSetでの利用
        Set<Point> points = new HashSet<>();
        points.add(p1);
        points.add(p2);  // p1と等しいため追加されない
        System.out.println(points.size());  // 1
    }
}

1
2
3
4
5

record Product(String id, String name, int price) {}

Product product = new Product("P001", "ノートPC", 120000);
System.out.println(product);
// 出力: Product[id=P001, name=ノートPC, price=120000]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

record User(String name, int age) {
    // コンパクトコンストラクタ
    public User {
        // バリデーション
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("名前は必須です");
        }
        if (age < 0) {
            throw new IllegalArgumentException("年齢は0以上である必要があります");
        }
        // this.name = name; は自動で行われる
        // this.age = age; は自動で行われる
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// コンパクトコンストラクタ（推奨）
record Email(String value) {
    public Email {
        if (!value.contains("@")) {
            throw new IllegalArgumentException("無効なメールアドレス形式です");
        }
    }
}

// 正規コンストラクタ（明示的な代入が必要）
record Email(String value) {
    public Email(String value) {
        if (!value.contains("@")) {
            throw new IllegalArgumentException("無効なメールアドレス形式です");
        }
        this.value = value;  // 明示的な代入が必要
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

record Name(String value) {
    public Name {
        // nullチェックと正規化
        value = Objects.requireNonNull(value, "名前はnullにできません").trim();
        
        if (value.isEmpty()) {
            throw new IllegalArgumentException("名前は空にできません");
        }
    }
}

public class NormalizationDemo {
    public static void main(String[] args) {
        Name name = new Name("  田中太郎  ");
        System.out.println("[" + name.value() + "]");  // [田中太郎]
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

record DateRange(LocalDate start, LocalDate end) {
    public DateRange {
        Objects.requireNonNull(start, "開始日は必須です");
        Objects.requireNonNull(end, "終了日は必須です");
        
        if (start.isAfter(end)) {
            throw new IllegalArgumentException("開始日は終了日以前である必要があります");
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

record Rectangle(double width, double height) {
    // 追加のインスタンスメソッド
    public double area() {
        return width * height;
    }
    
    public double perimeter() {
        return 2 * (width + height);
    }
    
    public boolean isSquare() {
        return width == height;
    }
}

public class RectangleDemo {
    public static void main(String[] args) {
        Rectangle rect = new Rectangle(10.0, 5.0);
        System.out.println("面積: " + rect.area());      // 面積: 50.0
        System.out.println("周長: " + rect.perimeter()); // 周長: 30.0
        System.out.println("正方形: " + rect.isSquare()); // 正方形: false
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

record Money(BigDecimal amount, String currency) {
    // 静的フィールド
    private static final Set<String> VALID_CURRENCIES = 
        Set.of("JPY", "USD", "EUR");
    
    // コンパクトコンストラクタ
    public Money {
        Objects.requireNonNull(amount, "金額は必須です");
        Objects.requireNonNull(currency, "通貨は必須です");
        
        if (!VALID_CURRENCIES.contains(currency)) {
            throw new IllegalArgumentException("無効な通貨コード: " + currency);
        }
        if (amount.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("金額は0以上である必要があります");
        }
    }
    
    // ファクトリメソッド
    public static Money yen(long amount) {
        return new Money(BigDecimal.valueOf(amount), "JPY");
    }
    
    public static Money usd(double amount) {
        return new Money(BigDecimal.valueOf(amount), "USD");
    }
    
    // インスタンスメソッド
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("通貨が異なります");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

record SecureUser(String name, String password) {
    // パスワードをマスクして返す
    @Override
    public String password() {
        return "********";
    }
    
    // 実際のパスワードを取得するメソッド（セキュリティに注意）
    public boolean verifyPassword(String input) {
        return password.equals(input);
    }
    
    // toStringもオーバーライドしてパスワードを隠す
    @Override
    public String toString() {
        return "SecureUser[name=" + name + ", password=********]";
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

record Book(String title, String author, int publicationYear) {
    // 出版年を現在年にするコンストラクタ
    public Book(String title, String author) {
        this(title, author, java.time.Year.now().getValue());
    }
    
    // 著者を「著者不明」にするコンストラクタ
    public Book(String title) {
        this(title, "著者不明");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

interface Printable {
    String format();
}

record Invoice(String id, BigDecimal amount, LocalDate dueDate) 
    implements Printable, Comparable<Invoice> {
    
    @Override
    public String format() {
        return String.format("請求書 %s: ¥%s（期限: %s）", 
            id, amount.toPlainString(), dueDate);
    }
    
    @Override
    public int compareTo(Invoice other) {
        return this.dueDate.compareTo(other.dueDate);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// コンパイルエラー: インスタンスフィールドは宣言できない
record User(String name) {
    private int loginCount;  // エラー
    
    {
        loginCount = 0;  // インスタンス初期化子も不可
    }
}

// 静的フィールドは許可される
record Config(String key, String value) {
    private static final String PREFIX = "config_";  // OK
    
    static {
        // 静的初期化子もOK
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

record Team(String name, List<String> members) {}

public class MutabilityDemo {
    public static void main(String[] args) {
        List<String> memberList = new ArrayList<>();
        memberList.add("田中");
        memberList.add("佐藤");
        
        Team team = new Team("開発チーム", memberList);
        System.out.println(team);  // Team[name=開発チーム, members=[田中, 佐藤]]
        
        // 外部からリストを変更できてしまう
        memberList.add("鈴木");
        System.out.println(team);  // Team[name=開発チーム, members=[田中, 佐藤, 鈴木]]
    }
}

1
2
3
4
5
6

record Team(String name, List<String> members) {
    public Team {
        // 防御的コピーで不変性を保証
        members = List.copyOf(members);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public final class UserPojo {
    private final String name;
    private final int age;
    
    public UserPojo(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        UserPojo userPojo = (UserPojo) o;
        return age == userPojo.age && 
               Objects.equals(name, userPojo.name);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    
    @Override
    public String toString() {
        return "UserPojo{name='" + name + "', age=" + age + "}";
    }
}

1
2
3
4
5
6
7

import lombok.Value;

@Value
public class UserLombok {
    String name;
    int age;
}

1

record UserRecord(String name, int age) {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// リクエストDTO
record CreateUserRequest(
    String name,
    String email,
    int age
) {
    public CreateUserRequest {
        Objects.requireNonNull(name, "名前は必須です");
        Objects.requireNonNull(email, "メールアドレスは必須です");
        
        if (!email.contains("@")) {
            throw new IllegalArgumentException("無効なメールアドレス形式です");
        }
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("年齢は0〜150の範囲で指定してください");
        }
    }
}

// レスポンスDTO
record UserResponse(
    long id,
    String name,
    String email,
    LocalDateTime createdAt
) {
    // エンティティからDTOへの変換
    public static UserResponse from(User entity) {
        return new UserResponse(
            entity.getId(),
            entity.getName(),
            entity.getEmail(),
            entity.getCreatedAt()
        );
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// メールアドレスValue Object
record EmailAddress(String value) {
    private static final Pattern EMAIL_PATTERN = 
        Pattern.compile("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$");
    
    public EmailAddress {
        Objects.requireNonNull(value, "メールアドレスは必須です");
        if (!EMAIL_PATTERN.matcher(value).matches()) {
            throw new IllegalArgumentException("無効なメールアドレス形式: " + value);
        }
    }
    
    public String domain() {
        return value.substring(value.indexOf('@') + 1);
    }
}

// 金額Value Object
record Money(BigDecimal amount, Currency currency) {
    public Money {
        Objects.requireNonNull(amount, "金額は必須です");
        Objects.requireNonNull(currency, "通貨は必須です");
        
        if (amount.scale() > currency.getDefaultFractionDigits()) {
            throw new IllegalArgumentException("小数点以下の桁数が多すぎます");
        }
    }
    
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("通貨が異なるため加算できません");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }
    
    public Money multiply(int quantity) {
        return new Money(this.amount.multiply(BigDecimal.valueOf(quantity)), currency);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// APIレスポンスのラッパー
record ApiResponse<T>(
    boolean success,
    T data,
    String message,
    LocalDateTime timestamp
) {
    public static <T> ApiResponse<T> success(T data) {
        return new ApiResponse<>(true, data, null, LocalDateTime.now());
    }
    
    public static <T> ApiResponse<T> error(String message) {
        return new ApiResponse<>(false, null, message, LocalDateTime.now());
    }
}

// ページネーション結果
record PageResult<T>(
    List<T> items,
    int page,
    int size,
    long totalElements,
    int totalPages
) {
    public PageResult {
        items = List.copyOf(items);  // 防御的コピー
    }
    
    public boolean hasNext() {
        return page < totalPages - 1;
    }
    
    public boolean hasPrevious() {
        return page > 0;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 処理結果を表すSealed Interface
sealed interface Result<T> permits Success, Failure {
    // 共通のメソッド
    default boolean isSuccess() {
        return this instanceof Success;
    }
}

record Success<T>(T value) implements Result<T> {}
record Failure<T>(String errorCode, String message) implements Result<T> {}

// 使用例
public class ResultExample {
    public static Result<User> findUser(long id) {
        if (id <= 0) {
            return new Failure<>("INVALID_ID", "無効なユーザーIDです");
        }
        // ユーザー検索ロジック
        User user = new User(id, "田中太郎");
        return new Success<>(user);
    }
    
    public static void main(String[] args) {
        Result<User> result = findUser(1L);
        
        // パターンマッチング（Java 21+）
        switch (result) {
            case Success<User>(var user) -> 
                System.out.println("ユーザー: " + user.name());
            case Failure<User>(var code, var msg) -> 
                System.out.println("エラー[" + code + "]: " + msg);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class SalesReport {
    public List<String> generateReport(List<Sale> sales) {
        // ローカルRecord定義
        record MerchantSales(String merchantName, BigDecimal totalSales) {}
        
        return sales.stream()
            .collect(Collectors.groupingBy(
                Sale::merchantName,
                Collectors.reducing(
                    BigDecimal.ZERO,
                    Sale::amount,
                    BigDecimal::add
                )
            ))
            .entrySet().stream()
            .map(e -> new MerchantSales(e.getKey(), e.getValue()))
            .sorted((a, b) -> b.totalSales().compareTo(a.totalSales()))
            .map(ms -> String.format("%s: ¥%s", 
                ms.merchantName(), 
                ms.totalSales().toPlainString()))
            .collect(Collectors.toList());
    }
}