import java.util.*;

public class Task241225 {
    public static void main(String[] args) {
        Set<Integer> set = new LinkedHashSet<>(Arrays.asList(5, 2, 8, 1));

        set.removeIf(x -> x > 3);

        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()) {
            Integer x = iterator.next();
            set.add(x * 2);
        }

        System.out.println("Set: " + set);
    }
}

import java.util.HashMap;
import java.util.Map;

public class Task251225 {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("a", 1);
        map.put("b", 2);
        map.put("c", 3);
        
        long count = map.entrySet().stream()
            .filter(entry -> {
                if (entry.getKey().equals("b")) {
                    map.put("b", 20);
                }
                return entry.getValue() > 1;
            })
            .count();
            
        System.out.println("Count: " + count);
        System.out.println("Map: " + map);
    }
}

// Различные сигнатуры
List.of()                    // Пустой список
List.of(e1)                  // Один элемент
List.of(e1, e2)              // Два элемента
// ... до 10 элементов
List.of(e1, e2, ..., e10)    // Десять элементов
List.of(elements...)         // Varargs для любого количества

Set.of("a", "b", "c");        // Допустимо
Set.of("a", "b", "a");        // IllegalArgumentException: дубликат

// Прямое создание пар (до 10 пар)
Map.of(k1, v1, k2, v2, ..., k10, v10)

// Создание из пар Map.Entry
Map.ofEntries(
    Map.entry(k1, v1),
    Map.entry(k2, v2),
    // ...
)

// Концептуальная реализация unmodifiableList
public static <T> List<T> unmodifiableList(List<? extends T> list) {
    return (list instanceof UnmodifiableList) ? 
           (List<T>) list : 
           new UnmodifiableList<>(list);
}

static class UnmodifiableList<E> implements List<E> {
    private final List<E> list;
    
    UnmodifiableList(List<E> list) {
        this.list = list;
    }
    
    public E get(int index) {
        return list.get(index); // Делегирование
    }
    
    public void add(int index, E element) {
        throw new UnsupportedOperationException(); // Запрет модификации
    }
    // ... остальные методы
}

List<StringBuilder> list = new ArrayList<>();
list.add(new StringBuilder("Hello"));
List<StringBuilder> unmodifiable = Collections.unmodifiableList(list);

// Нельзя изменить структуру
unmodifiable.add(new StringBuilder("World")); // UnsupportedOperationException

// Но можно изменить содержимое элементов
unmodifiable.get(0).append(" World"); // Допустимо!

// Пример с List.of()
List<String> immutable = List.of("A", "B", "C");
// Любая попытка модификации: UnsupportedOperationException

// Пример с unmodifiableList
List<String> mutable = new ArrayList<>(Arrays.asList("A", "B", "C"));
List<String> wrapper = Collections.unmodifiableList(mutable);

mutable.add("D"); // Изменяем исходный список
System.out.println(wrapper); // ["A", "B", "C", "D"] - обертка отражает изменения
Это фундаментальное различие: List.of() создает полностью независимую коллекцию, тогда как unmodifiableList() создает зависимое представление.

// Концептуально для List.of(e1, e2)
class List2<E> extends AbstractImmutableList<E> {
    private final E e0, e1;
    
    public E get(int index) {
        return switch (index) {
            case 0 -> e0;
            case 1 -> e1;
            default -> throw new IndexOutOfBoundsException();
        };
    }
}

// Для List
List<String> list = List.<String>builder()
    .add("A")
    .addAll(anotherList)
    .build();

// Для Map
Map<String, Integer> map = Map.<String, Integer>builder()
    .put("key1", 1)
    .put("key2", 2)
    .build();

Эти строители позволяют создавать неизменяемые коллекции инкрементально, что особенно полезно при динамическом построении.

List<String> mutable = Arrays.asList("A", "B", "C", null, "D");

// Фильтрация null и создание неизменяемого списка
List<String> immutable = mutable.stream()
    .filter(Objects::nonNull)
    .map(String::toUpperCase)
    .collect(Collectors.toUnmodifiableList());

// Безопасная публикация
public class Configuration {
    public static final List<String> SETTINGS = List.of("A", "B", "C");
    // Все потоки увидят полностью инициализированную коллекцию
}

// Synchronized подход (устаревший)
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
// Требует внешней синхронизации для compound операций

// CopyOnWriteArrayList (частичная неизменяемость)
CopyOnWriteArrayList<String> copyOnWrite = new CopyOnWriteArrayList<>();
// Дорогие операции записи, но безопасное чтение

// Полностью неизменяемый подход
List<String> immutable = List.of("A", "B", "C");
// Идеальная потокобезопасность без накладных расходов