Для чего нужно делать класс иммутабельным?

# Иммутабельные классы в Java: Зачем и как

Иммутабельный класс — это класс, объекты которого не могут быть изменены после создания. Его состояние остаётся неизменным на протяжении всего времени жизни объекта. Это один из ключевых паттернов в Java, имеющий множество практических преимуществ.

Основные причины использования иммутабельных классов

1. Потокобезопасность (Thread Safety)

Это главное преимущество. Иммутабельные объекты по сути потокобезопасны без синхронизации:

// Мутабельный класс — опасен в многопоточной среде
public class MutablePoint {
    private int x, y;
    
    public MutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public void setX(int x) { this.x = x; }
    public void setY(int y) { this.y = y; }
}

// Потокобезопасное использование требует синхронизации
synchronized(point) {
    point.setX(10);
    point.setY(20);
}

// Иммутабельный класс — потокобезопасен
public final class ImmutablePoint {
    private final int x;
    private final int y;
    
    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public int getX() { return x; }
    public int getY() { return y; }
}

// Можно использовать в нескольких потоках без синхронизации
ImmutablePoint point = new ImmutablePoint(10, 20);
// Разные потоки могут читать одновременно без проблем

Это особенно критично в высоконагруженных системах, где синхронизация может стать узким местом.

2. Безопасность при использовании в HashMap и HashSet

Иммутабельные объекты идеальны как ключи в HashMap, потому что их хеш-код никогда не изменяется:

// Проблема с мутабельным ключом
public class MutableUser {
    private String email;
    
    public MutableUser(String email) {
        this.email = email;
    }
    
    public void setEmail(String email) { this.email = email; }
    
    public int hashCode() {
        return email.hashCode();
    }
    
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof MutableUser)) return false;
        return email.equals(((MutableUser) obj).email);
    }
}

Map<MutableUser, String> map = new HashMap<>();
MutableUser user = new MutableUser("john@example.com");
map.put(user, "John Doe");

user.setEmail("jane@example.com"); // Изменяем хеш-код!
// Теперь пользователь потерян в HashMap

// С иммутабельным ключом проблемы нет
public final class ImmutableUser {
    private final String email;
    
    public ImmutableUser(String email) {
        this.email = email;
    }
    
    public int hashCode() {
        return email.hashCode();
    }
    
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof ImmutableUser)) return false;
        return email.equals(((ImmutableUser) obj).email);
    }
}

Map<ImmutableUser, String> map = new HashMap<>();
ImmutableUser user = new ImmutableUser("john@example.com");
map.put(user, "John Doe");
// Хеш-код никогда не изменится

3. Кэширование результатов

Иммутабельные объекты можно безопасно кэшировать:

public final class ImmutableConfig {
    private final String apiKey;
    private final int timeout;
    private final boolean debug;
    
    public ImmutableConfig(String apiKey, int timeout, boolean debug) {
        this.apiKey = apiKey;
        this.timeout = timeout;
        this.debug = debug;
    }
    
    // Конфигурация может быть статически кэширована
    private static final Map<String, ImmutableConfig> CACHE = new HashMap<>();
    
    public static ImmutableConfig getCached(String key) {
        return CACHE.computeIfAbsent(key, k -> new ImmutableConfig(k, 30, false));
    }
}

4. Безопасное совместное использование данных

Иммутабельные объекты защищают от случайного (или намеренного) изменения данных другими компонентами системы.

5. Упрощение тестирования

Иммутабельные объекты проще для unit-тестов — нет боязни, что объект изменится во время теста или при многопоточном доступе.

Как сделать класс иммутабельным

Правила создания иммутабельного класса

public final class ImmutableProduct {  // 1. final класс
    private final String id;            // 2. final поля
    private final String name;
    private final BigDecimal price;
    private final List<String> tags;   // 3. Даже коллекции
    
    public ImmutableProduct(String id, String name, BigDecimal price, List<String> tags) {
        this.id = id;
        this.name = name;
        this.price = price;
        // 4. Копируем мутабельные объекты
        this.tags = List.copyOf(tags);
    }
    
    // 5. Только getter'ы (без setter'ов)
    public String getId() { return id; }
    public String getName() { return name; }
    public BigDecimal getPrice() { return price; }
    public List<String> getTags() { return tags; }
    
    public int hashCode() {
        return Objects.hash(id, name, price, tags);
    }
    
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof ImmutableProduct)) return false;
        ImmutableProduct other = (ImmutableProduct) obj;
        return Objects.equals(id, other.id) &&
               Objects.equals(name, other.name) &&
               Objects.equals(price, other.price) &&
               Objects.equals(tags, other.tags);
    }
}

Checklist иммутабельности

1. Класс объявлен как final
2. Все поля объявлены как final
3. Нет setter'ов
4. Мутабельные объекты копируются при создании
5. Возвращаемые коллекции неизменяемы
6. Правильно реализованы equals() и hashCode()

Java Records (Java 14+)

В Java 14+ есть records — удобный способ создавать иммутабельные классы:

public record Product(
    String id,
    String name,
    BigDecimal price,
    List<String> tags
) {}

// Record автоматически:
// - final класс
// - final поля
// - Конструктор
// - Getter'ы (без get приставки)
// - equals(), hashCode(), toString()

Когда НЕ использовать иммутабельность

• Высокочастотное создание новых объектов с небольшими изменениями (может быть неэффективно)
• Очень сложные объекты с большим количеством полей
• Когда по дизайну нужна именно мутабельность

В заключение: иммутабельные классы — это мощный инструмент для написания надёжного, потокобезопасного и легко поддерживаемого кода. Их использование особенно ценно в многопоточных приложениях и при работе с общими данными.