PrepBro
← Назад к вопросам

Как понимаешь "изменить элемент" в иммутабельной коллекции

2.0 Middle🔥 111 комментариев
#Коллекции#Основы Java

Комментарии (1)

🐱
claude-haiku-4.5PrepBro AI22 мар. 2026 г.(ред.)

Ответ сгенерирован нейросетью и может содержать ошибки

# Изменение элемента в иммутабельной (неизменяемой) коллекции

Вопрос о "изменении элемента" в иммутабельной коллекции часто вызывает путаницу. Разберём, что это значит и как с этим работать.

1. Понимание иммутабельности

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

// ❌ Иммутабельная коллекция
List<String> immutable = List.of("apple", "banana", "orange");

// Все эти операции выбросят UnsupportedOperationException
immutable.add("grape");           // Ошибка!
immutable.remove(0);              // Ошибка!
immutable.set(0, "pear");         // Ошибка!

// ✅ Обычная коллекция (мутабельная)
List<String> mutable = new ArrayList<>(Arrays.asList("apple", "banana"));
mutable.add("grape");             // OK
mutable.set(0, "pear");           // OK

2. Что означает "изменить элемент" в иммутабельной коллекции

"Изменить элемент" в контексте иммутабельной коллекции означает:

Создать НОВУЮ коллекцию с изменённым значением, оставив старую без изменений.

// Исходная иммутабельная коллекция
List<String> original = List.of("apple", "banana", "orange");
// original: [apple, banana, orange]

// "Изменяем" первый элемент
// На самом деле: создаём новую коллекцию
List<String> modified = new ArrayList<>(original);
modified.set(0, "pear");

// Результат:
// original: [apple, banana, orange]  ← не изменилась
// modified: [pear, banana, orange]   ← новая коллекция

3. Способ 1: Stream API (функциональный подход)

Самый элегантный способ для функционального стиля.

List<String> original = List.of("apple", "banana", "orange");

// Создаём новую коллекцию с изменённым элементом
List<String> modified = original.stream()
    .map((String fruit) -> {
        if (fruit.equals("banana")) {
            return "mango";  // Заменяем banana на mango
        }
        return fruit;
    })
    .collect(Collectors.toList());

// Результат:
// original: [apple, banana, orange]
// modified: [apple, mango, orange]

4. Способ 2: Конструктор + set

Множество, но понятный способ.

List<String> original = List.of(1, 2, 3, 4, 5);

// Создаём новую коллекцию
List<Integer> modified = new ArrayList<>(original);
modified.set(2, 999);  // Изменяем элемент с индексом 2

// Результат:
// original: [1, 2, 3, 4, 5]
// modified: [1, 2, 999, 4, 5]

5. Способ 3: Stream с индексом

Для больших данных и сложной логики.

List<User> original = List.of(
    new User(1, "Alice"),
    new User(2, "Bob"),
    new User(3, "Charlie")
);

// Изменяем элемент с индексом 1
int targetIndex = 1;
List<User> modified = original.stream()
    .map(user -> {
        if (user.getId() == 2) {
            return new User(user.getId(), "Robert");  // Меняем Bob на Robert
        }
        return user;
    })
    .collect(Collectors.toList());

// Результат:
// original: [User(1, Alice), User(2, Bob), User(3, Charlie)]
// modified: [User(1, Alice), User(2, Robert), User(3, Charlie)]

6. Иммутабельные объекты vs иммутабельные коллекции

Важное различие!

// Иммутабельная коллекция ≠ иммутабельные объекты
List<StringBuilder> notReallyImmutable = List.of(
    new StringBuilder("hello"),
    new StringBuilder("world")
);

// Нельзя изменить коллекцию
notReallyImmutable.add(new StringBuilder("!"));  // Ошибка!

// НО можно изменить сами объекты!
notReallyImmutable.get(0).append(" modified");
// notReallyImmutable: [hello modified, world]

// ✅ Правильно: иммутабельная коллекция иммутабельных объектов
record User(int id, String name) {}  // Record с final полями

List<User> truelyImmutable = List.of(
    new User(1, "Alice"),
    new User(2, "Bob")
);

// Ни коллекцию, ни объекты менять нельзя
// truelyImmutable.add(...);          // Ошибка!
// truelyImmutable.get(0).setName();  // Метод setName не существует!

7. Работа с вложенными структурами

@Data
class Order {
    int id;
    String status;
    List<Item> items;
}

@Data
class Item {
    int id;
    String name;
    int quantity;
}

// Иммутабельная коллекция заказов
List<Order> orders = List.of(
    new Order(1, "PENDING", List.of(
        new Item(1, "Laptop", 1),
        new Item(2, "Mouse", 2)
    )),
    new Order(2, "SHIPPED", List.of(
        new Item(3, "Keyboard", 1)
    ))
);

// Изменяем статус первого заказа
List<Order> updated = orders.stream()
    .map(order -> {
        if (order.id == 1) {
            // Создаём новый Order с изменённым статусом
            return new Order(order.id, "COMPLETED", order.items);
        }
        return order;
    })
    .collect(Collectors.toList());

// Или с использованием copy constructor:
List<Order> updated2 = orders.stream()
    .peek(order -> {
        if (order.id == 1) {
            order.setStatus("COMPLETED");  // ❌ Изменяем исходный объект!
        }
    })
    .collect(Collectors.toList());
// ⚠️ Это испортит исходный список orders!

8. Java Records для истинной иммутабельности

Rcords (Java 14+) — идеальны для иммутабельности.


// Record — автоматически иммутабельный
public record User(int id, String name, List<String> roles) {}

// Нельзя изменить поля
User user = new User(1, "Alice", List.of("admin"));
user.id = 2;              // Ошибка! final поле
user.name = "Bob";        // Ошибка! final поле
user.roles.add("user");   // Ошибка! это List.of (иммутабельный)

// Для "изменения" создаём новый record
User updated = new User(user.id(), "Bob", user.roles());

// Или используем copy method (доступен в новых версиях Java)
User updated2 = user.withName("Bob");

9. Google's Immutables Library

Для удобной работы с иммутабельными объектами.

<dependency>
    <groupId>org.immutables</groupId>
    <artifactId>value</artifactId>
    <version>2.9.1</version>
    <scope>provided</scope>
</dependency>

// Интерфейс
import org.immutables.value.Value;

@Value.Immutable
public interface UserValue {
    int id();
    String name();
    List<String> roles();
}

// Использование
UserValue user = ImmutableUserValue.builder()
    .id(1)
    .name("Alice")
    .addRoles("admin")
    .build();

// "Изменение" — создание новой копии
UserValue updated = ImmutableUserValue.copyOf(user)
    .withName("Bob");

10. Copy-on-Write Collections

Для многопоточного доступа.

import java.util.concurrent.CopyOnWriteArrayList;

// Потокобезопасная коллекция
List<String> list = new CopyOnWriteArrayList<>(List.of("apple", "banana"));

// Изменение создаёт новый массив внутренне
list.set(0, "pear");
// Исходная коллекция: [apple, banana]
// Новая коллекция: [pear, banana]

// Отлично для конкурентного доступа
ExecutorService executor = Executors.newFixedThreadPool(4);
for (int i = 0; i < 100; i++) {
    executor.submit(() -> list.add(UUID.randomUUID().toString()));
}

11. Performance подсказки

// ❌ Неэффективно: создаём новую коллекцию для каждого изменения
List<Integer> result = list;
for (int i = 0; i < 1000; i++) {
    result = result.stream()
        .map(x -> x % 2 == 0 ? x * 2 : x)
        .collect(Collectors.toList());
}

// ✅ Эффективнее: используй одну stream pipeline
List<Integer> result = list.stream()
    .map(x -> x % 2 == 0 ? x * 2 : x)
    .collect(Collectors.toList());

// ✅ Самое эффективное: обнови мутабельную копию
List<Integer> result = new ArrayList<>(list);
for (int i = 0; i < result.size(); i++) {
    if (result.get(i) % 2 == 0) {
        result.set(i, result.get(i) * 2);
    }
}

12. Best Practices

// ✅ Используй List.of() для иммутабельных коллекций
List<String> immutable = List.of("a", "b", "c");

// ✅ Для изменения — создай новую коллекцию
List<String> modified = immutable.stream()
    .map(s -> s.equals("b") ? "B" : s)
    .collect(Collectors.toList());

// ✅ Используй Records для иммутабельных данных
record Person(int id, String name) {}

// ✅ Используй CopyOnWriteArrayList для конкурентного доступа
List<String> concurrent = new CopyOnWriteArrayList<>(data);

// ❌ Не изменяй исходную иммутабельную коллекцию
List<String> original = List.of(...);
original.set(0, "new");  // UnsupportedOperationException!

// ❌ Не полагайся только на иммутабельность коллекции
// если элементы мутабельны

Выводы

  1. Иммутабельная коллекция — коллекция, которую нельзя менять
  2. "Изменить" элемент означает создать новую коллекцию
  3. Stream API — лучший способ для функционального стиля
  4. Records — идеальны для истинной иммутабельности
  5. CopyOnWriteArrayList — для многопоточного доступа
  6. Иммутабельность коллекции ≠ иммутабельность элементов
  7. Performance — помни о создании новых копий при изменениях
Как понимаешь "изменить элемент" в иммутабельной коллекции | PrepBro