Какие плюсы и минусы неизменяемых классов?

Плюсы и минусы неизменяемых (Immutable) классов

Неизменяемые классы — важный паттерн в Java, особенно в многопоточных приложениях. Важно понимать их преимущества и недостатки.

Плюсы неизменяемых классов

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

// Immutable класс
public final class User {
    private final Long id;
    private final String name;
    private final String email;
    
    public User(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }
    
    public Long getId() { return id; }
    public String getName() { return name; }
    public String getEmail() { return email; }
    // Нет setters!
}

// Потокобезопасно без синхронизации
User user = new User(1L, "John", "john@example.com");

// Несколько потоков могут одновременно читать
ExecutorService executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < 100; i++) {
    executor.submit(() -> {
        System.out.println(user.getName());  // Безопасно!
    });
}
// Никакие синхронизирующие примитивы не нужны

Плюс: не нужны synchronized блоки или ReentrantLock для защиты данных.

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

public class CachedUserService {
    private final Map<Long, User> cache = new ConcurrentHashMap<>();
    
    public User getUser(Long id) {
        return cache.computeIfAbsent(id, userId -> {
            // fetchFromDB возвращает immutable User
            User user = fetchFromDB(userId);
            // Можем безопасно кешировать
            return user;  // Никто не изменит кешированный объект
        });
    }
    
    // Mutable класс — проблема
    public void problem() {
        User user1 = cache.get(1L);
        User user2 = cache.get(1L);
        user1.setName("Hacked");  // ИЗМЕНИЛИ кешированный объект!
        // Теперь user2 тоже повреждён
    }
}

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

public void demoHashMap() {
    Map<User, String> userMap = new HashMap<>();
    User user = new User(1L, "John", "john@example.com");
    
    userMap.put(user, "Developer");
    
    // Если бы User был mutable:
    // user.setName("Jane");  // hashCode() изменится
    // userMap.get(user);  // null! HashMap не найдёт ключ
    
    // С immutable: безопасно
    String role = userMap.get(user);  // Всегда найдёт
}

Плюс: hashCode() всегда одинаковый, можно использовать как ключ в Map.

4. Упрощённое мышление и отладка

public class OrderService {
    // Immutable: легко понять
    public BigDecimal calculateTotal(Order order) {
        // order не может измениться во время выполнения
        BigDecimal subtotal = order.getSubtotal();
        BigDecimal tax = subtotal.multiply(BigDecimal.valueOf(0.1));
        return subtotal.add(tax);
    }
    
    // Mutable: сложнее
    public void updateOrder(Order order) {
        order.setStatus("PROCESSING");
        // Кто-то другой может изменить order параллельно
        // Трудно рассуждать о значении
    }
}

Плюс: легче писать правильный код, меньше багов.

5. Безопасность

public class SecureUser {
    private final List<String> roles;  // Immutable
    
    public SecureUser(List<String> roles) {
        // ВАЖНО: сделай копию!
        this.roles = new ArrayList<>(roles);
    }
    
    public List<String> getRoles() {
        // ВАЖНО: возвращай копию!
        return new ArrayList<>(roles);
    }
}

// Использование
List<String> userRoles = new ArrayList<>();
userRoles.add("ADMIN");

SecureUser user = new SecureUser(userRoles);
userRoles.add("HACKER");  // Попытка модифицировать

System.out.println(user.getRoles());  // [ADMIN] — не повреждён!

6. Версионирование и history

public class ImmutableDocument {
    private final String content;
    private final LocalDateTime createdAt;
    private final int version;
    
    // Для изменения: создаём новый объект
    public ImmutableDocument updateContent(String newContent) {
        return new ImmutableDocument(
            newContent,
            this.createdAt,
            this.version + 1
        );
    }
}

// Легко хранить историю
ImmutableDocument doc1 = new ImmutableDocument("Version 1");
ImmutableDocument doc2 = doc1.updateContent("Version 2");
ImmutableDocument doc3 = doc2.updateContent("Version 3");

// doc1, doc2, doc3 — все версии доступны

Минусы неизменяемых классов

1. Overhead памяти

// Для каждого изменения создаём новый объект
ImmutableUser user1 = new ImmutableUser(1L, "John", 25);
ImmutableUser user2 = new ImmutableUser(1L, "John", 26);  // Новый объект!
ImmutableUser user3 = new ImmutableUser(1L, "John", 27);  // Ещё новый!

// Против: mutable
MutableUser user = new MutableUser(1L, "John", 25);
user.setAge(26);  // Изменение in-place
user.setAge(27);  // Изменение in-place
// Одинкторалось только одного объекта в памяти

Минус: больше объектов в памяти = больше GC.

2. Усложнение кода

// Immutable — многословно
public final class Address {
    private final String street;
    private final String city;
    private final String zip;
    private final String country;
    
    public Address(String street, String city, String zip, String country) {
        this.street = street;
        this.city = city;
        this.zip = zip;
        this.country = country;
    }
    
    public Address withCity(String city) {
        return new Address(this.street, city, this.zip, this.country);
    }
    
    public Address withZip(String zip) {
        return new Address(this.street, this.city, zip, this.country);
    }
    // ... ещё withters для каждого поля
}

// Mutable — проще
public class MutableAddress {
    private String street;
    private String city;
    private String zip;
    private String country;
    
    public void setCity(String city) { this.city = city; }
    public void setZip(String zip) { this.zip = zip; }
}

3. Производительность

// Копирование всех полей при каждом изменении
for (int i = 0; i < 1_000_000; i++) {
    user = user.withAge(user.getAge() + 1);
    // Создаём новый объект каждый раз — медленно!
}

// Mutable — быстрее
for (int i = 0; i < 1_000_000; i++) {
    user.setAge(user.getAge() + 1);  // in-place — быстро
}

4. Сложность с коллекциями

public final class Team {
    private final List<Employee> members;
    
    public Team(List<Employee> members) {
        // Защита: копируем
        this.members = new ArrayList<>(members);
    }
    
    public List<Employee> getMembers() {
        // Защита: копируем обратно
        return new ArrayList<>(members);
    }
    
    // Для добавления члена: новый объект
    public Team addMember(Employee employee) {
        List<Employee> newMembers = new ArrayList<>(members);
        newMembers.add(employee);
        return new Team(newMembers);
    }
}

// Много копирований!

Минус: при работе с коллекциями много overhead'а.

5. Builder pattern — усложнение

// Для удобства создания используем Builder
public final class User {
    private final Long id;
    private final String name;
    private final String email;
    private final int age;
    private final List<String> roles;
    
    private User(Builder builder) {
        this.id = builder.id;
        this.name = builder.name;
        this.email = builder.email;
        this.age = builder.age;
        this.roles = new ArrayList<>(builder.roles);
    }
    
    public static class Builder {
        private Long id;
        private String name;
        private String email;
        private int age;
        private List<String> roles = new ArrayList<>();
        
        public Builder id(Long id) { this.id = id; return this; }
        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 roles(List<String> roles) {
            this.roles = roles;
            return this;
        }
        
        public User build() {
            return new User(this);
        }
    }
}

// Использование
User user = new User.Builder()
    .id(1L)
    .name("John")
    .email("john@example.com")
    .age(25)
    .roles(List.of("USER", "ADMIN"))
    .build();

6. Lombok упрощает

@Value  // Immutable класс с Lombok
public class User {
    Long id;
    String name;
    String email;
    int age;
    
    // Lombok генерирует:
    // - constructor
    // - getters
    // - equals, hashCode, toString
    // - все final
}

// Используй @Builder для удобства
@Value
@Builder
public class User {
    Long id;
    String name;
    String email;
    int age;
}

// Теперь просто
User user = User.builder()
    .id(1L)
    .name("John")
    .email("john@example.com")
    .age(25)
    .build();

Когда использовать

Immutable — хороший выбор когда:

• Объект используется в многопоточной среде
• Объект используется как ключ в Map
• Нужна версионирование/история
• Объект часто копируется
• Нужна безопасность (DTO, Security)

Mutable — хороший выбор когда:

• Объект часто изменяется
• Производительность критична
• Нет многопоточности
• Объект имеет сложное состояние

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

// DTO — всегда immutable
@Value
@Builder
public class UserDTO {
    Long id;
    String name;
    String email;
}

// Entity в слое persistence — может быть mutable
@Entity
public class UserEntity {
    @Id
    private Long id;
    private String name;
    private String email;
    
    public void setEmail(String email) { this.email = email; }
}

// Domain model — immutable
@Value
public class User {
    Long id;
    String name;
    String email;
    
    public User changeEmail(String newEmail) {
        return new User(this.id, this.name, newEmail);
    }
}

Резюме

Плюсы:

1. Потокобезопасность
2. Кешируемость
3. Использование в HashMap
4. Простота мышления
5. Безопасность
6. Версионирование

Минусы:

1. Overhead памяти
2. Усложнение кода
3. Производительность
4. Сложность с коллекциями
5. Builder паттерн

Рекомендация: используй immutable для DTO и domain models, mutable для entities и сложных объектов с частыми изменениями.