Какие плюсы и минусы имутабельных объектов?

# Плюсы и минусы имутабельных (неизменяемых) объектов

Определение

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

// ✅ Имутабельный объект
public final class Point {
    private final int x;
    private final int y;
    
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public int getX() { return x; }
    public int getY() { return y; }
    // Нет сеттеров!
}

// ❌ Мутабельный объект
public class MutablePoint {
    private int x;
    private int y;
    
    public void setX(int x) { this.x = x; }  // Можно изменять
    public void setY(int y) { this.y = y; }
}

ПЛЮСЫ имутабельных объектов

1. Потокобезопасность

Имутабельные объекты безопасны для многопоточного доступа:

public final class ImmutableUser {
    private final String name;
    private final String email;
    
    public ImmutableUser(String name, String email) {
        this.name = name;
        this.email = email;
    }
    
    public String getName() { return name; }
    public String getEmail() { return email; }
}

// Потокобезопасно - не нужны synchronized или locks
Executor executor = Executors.newFixedThreadPool(10);
ImmutableUser user = new ImmutableUser("John", "john@example.com");

for (int i = 0; i < 1000; i++) {
    executor.execute(() -> {
        System.out.println(user.getName());  // Безопасно
    });
}

Преимущество: не нужны synchronized блоки, AtomicReference, ReentrantLock и т.д.

2. Простота тестирования

@Test
public void testImmutableObject() {
    ImmutableUser user = new ImmutableUser("John", "john@example.com");
    
    // Состояние никогда не изменится
    assertEquals("John", user.getName());
    assertEquals("john@example.com", user.getEmail());
    
    // После этой строки состояние все еще не изменилось
    ImmutableUser sameUser = user;
    
    assertEquals(user, sameUser);  // Гарантированно true
}

3. Кэширование и оптимизация

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

public final class Integer {
    // JVM кэширует целые числа от -128 до 127
    Integer a = 127;
    Integer b = 127;
    System.out.println(a == b);  // true - один объект в памяти
    
    Integer c = 128;
    Integer d = 128;
    System.out.println(c == d);  // false - разные объекты
}

4. Использование в HashSet и HashMap

public final class ImmutableKey {
    private final String value;
    private final int hashCode;
    
    public ImmutableKey(String value) {
        this.value = value;
        this.hashCode = Objects.hash(value);  // Кэшируем hashCode
    }
    
    @Override
    public int hashCode() {
        return hashCode;  // Всегда одно значение
    }
}

Set<ImmutableKey> set = new HashSet<>();
set.add(new ImmutableKey("key1"));
set.add(new ImmutableKey("key1"));  // Правильно работает

Map<ImmutableKey, String> map = new HashMap<>();
ImmutableKey key = new ImmutableKey("key1");
map.put(key, "value");  // Безопасно, hashCode не изменится

5. Идеальны как аргументы функций

public class UserService {
    // Уверен, что user не изменится внутри метода
    public void sendGreeting(final User user) {
        String message = "Hello, " + user.getName();
        emailService.send(user.getEmail(), message);
        // Гарантировано что user.getName() и user.getEmail() не изменились
    }
}

6. Более понятный код

// ✅ Ясно: создаем новый объект
Address newAddress = address.withCity("New York");

// ❌ Неясно: что произойдет с исходным объектом?
address.setCity("New York");

7. Безопасность от побочных эффектов

public class Config {
    private final ImmutableList<String> servers;
    
    public Config(List<String> servers) {
        // Копируем в неизменяемый список
        this.servers = Collections.unmodifiableList(new ArrayList<>(servers));
    }
    
    public List<String> getServers() {
        return servers;  // Безопасно возвращать
    }
}

// Даже если кто-то попытается изменить, получит ошибку
List<String> servers = config.getServers();
servers.add("new-server");  // UnsupportedOperationException

МИНУСЫ имутабельных объектов

1. Создание новых объектов при каждом изменении

// ❌ Неэффективно
ImmutableUser user = new ImmutableUser("John", "john@example.com");
user = new ImmutableUser("Jane", user.getEmail());  // Новый объект
user = new ImmutableUser(user.getName(), "jane@example.com");  // Еще новый объект

// Потреблено память на 3 объекта вместо 1

2. Использование больше памяти

Для каждого изменения создается новый объект:

public final class ImmutableUserBuilder {
    private String name;
    private String email;
    
    // Часто используют Builder pattern для оптимизации
    public ImmutableUser build() {
        return new ImmutableUser(name, email);
    }
}

// Но даже с Builder все равно много объектов создается

3. Сложнее работать с графами объектов

// ❌ Сложно обновлять вложенные структуры
public final class Company {
    private final List<ImmutableDepartment> departments;
    
    // Нужно копировать весь граф при изменении одного отдела
    public Company withUpdatedDepartment(int index, ImmutableDepartment dept) {
        List<ImmutableDepartment> newDepts = new ArrayList<>(departments);
        newDepts.set(index, dept);
        return new Company(Collections.unmodifiableList(newDepts));
    }
}

4. Более сложный код инициализации

// ✅ Просто с мутабельным объектом
MutableUser user = new MutableUser();
user.setName("John");
user.setEmail("john@example.com");
user.setPhone("123-456");
user.setAge(30);

// ❌ Сложнее с имутабельным объектом
ImmutableUser user = new ImmutableUser("John", "john@example.com", "123-456", 30);
// Или нужен Builder
ImmutableUser user = new ImmutableUser.Builder()
    .name("John")
    .email("john@example.com")
    .phone("123-456")
    .age(30)
    .build();

5. Невозможно отложить инициализацию

// ❌ С имутабельным объектом нужно знать все значения
Final class UserProfile {
    private final String bio;  // Может быть неизвестна при создании
    
    public UserProfile(String bio) {
        this.bio = bio;
    }
}

// Нужно либо делать null
private final String bio;  // null до загрузки из БД

// Либо создавать объект заново когда знаем значение

6. Сложнее с наследованием

// ❌ Имутабельность нарушается подклассом
public final class ImmutableDate {
    // ...
}

// ✅ Нужно делать final
public final class ImmutableDate {
    private final LocalDate date;
    // final класс - никто не может переопределить методы
}

Практические примеры

Пример 1: Правильный имутабельный объект

public final class Money {
    private final BigDecimal amount;
    private final Currency currency;
    
    public Money(BigDecimal amount, Currency currency) {
        this.amount = amount;
        this.currency = currency;
    }
    
    // Операции возвращают новый объект
    public Money add(Money other) {
        if (!currency.equals(other.currency)) {
            throw new IllegalArgumentException("Different currencies");
        }
        return new Money(amount.add(other.amount), currency);
    }
    
    public Money multiply(BigDecimal factor) {
        return new Money(amount.multiply(factor), currency);
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Money)) return false;
        Money other = (Money) obj;
        return Objects.equals(amount, other.amount) &&
               Objects.equals(currency, other.currency);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(amount, currency);
    }
}

// Использование
Money price = new Money(new BigDecimal("100.00"), Currency.USD);
Money discountedPrice = price.multiply(new BigDecimal("0.9"));
Money totalPrice = price.add(discountedPrice);

// Исходные объекты не изменились
System.out.println(price);  // 100.00
System.out.println(discountedPrice);  // 90.00

Пример 2: С Builder pattern

public final class User {
    private final String name;
    private final String email;
    private final int age;
    private final String phone;
    
    private User(Builder builder) {
        this.name = builder.name;
        this.email = builder.email;
        this.age = builder.age;
        this.phone = builder.phone;
    }
    
    public static class Builder {
        private String name;
        private String email;
        private int age;
        private String phone;
        
        public Builder name(String name) {
            this.name = name;
            return this;
        }
        
        public Builder email(String email) {
            this.email = email;
            return this;
        }
        
        public Builder age(int age) {
            this.age = age;
            return this;
        }
        
        public Builder phone(String phone) {
            this.phone = phone;
            return this;
        }
        
        public User build() {
            return new User(this);
        }
    }
}

// Использование
User user = new User.Builder()
    .name("John")
    .email("john@example.com")
    .age(30)
    .phone("123-456")
    .build();

Когда использовать имутабельные объекты

Чеклист создания имутабельного объекта

☐ Класс объявлен как final
☐ Все поля private и final
☐ Нет сеттеров
☐ Конструктор инициализирует все поля
☐ Если есть коллекции - возвращаем неизменяемые копии
☐ Реализованы equals() и hashCode()
☐ toString() переопределен для удобства
☐ Методы, которые изменяют состояние, возвращают новый объект

Вывод

Имутабельные объекты:

• ✅ Потокобезопасны
• ✅ Легче тестировать
• ✅ Проще рассуждать о коде
• ❌ Требуют больше памяти
• ❌ Могут быть медленнее из-за создания новых объектов

Используй имутабельные объекты для:

• Value Objects
• DTOs
• Configuration
• Многопоточных сценариев

Используй мутабельные объекты для:

• Entity с частыми обновлениями
• Больших объектных графов
• Сценариев с интенсивными изменениями