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");
// Идеальная потокобезопасность без накладных расходов

public class ApplicationConstants {
    // Конфигурационные параметры
    public static final List<String> SUPPORTED_LANGUAGES = 
        List.of("en", "es", "fr", "de");
    
    public static final Map<String, Integer> DEFAULT_SETTINGS = 
        Map.of("timeout", 30, "retries", 3, "cacheSize", 1000);
}

public List<String> getActiveUsers() {
    // Вместо возврата изменяемого списка
    return List.copyOf(internalUserList); // Защитная копия как неизменяемый список
}

public void processItems(List<String> items) {
    // items должен быть неизменяемым или защищенной копией
    List<String> safeItems = List.copyOf(items);
    // Далее работаем с safeItems
}

// НЕПРАВИЛЬНО: постоянное создание новых коллекций
List<String> items = List.of();
for (Item item : source) {
    items = Stream.concat(items.stream(), Stream.of(item.getName()))
                  .collect(Collectors.toUnmodifiableList()); // Очень дорого!
}

// ПРАВИЛЬНО: использование изменяемого построителя
List<String> itemsBuilder = new ArrayList<>();
for (Item item : source) {
    itemsBuilder.add(item.getName());
}
List<String> items = List.copyOf(itemsBuilder);

// Хорошо
List<String> good = List.of("A", "B", "C");

// Плохо (возвращает изменяемый список, но фиксированного размера)
List<String> bad = Arrays.asList("A", "B", "C");

public class SafeApi {
    private final List<String> data;
    
    public SafeApi(List<String> input) {
        // Защитное копирование в неизменяемый список
        this.data = List.copyOf(input);
    }
}

/**
 * Возвращает неизменяемый список активных пользователей.
 * Попытки модификации приведут к UnsupportedOperationException.
 */
public List<User> getActiveUsers() {
    return Collections.unmodifiableList(internalList);
}

// Хорошо: ясно указывает на намерение
public void processItems(List<? extends String> items) {
    // items может быть любым списком строк, включая неизменяемые
}

// Или даже лучше в Java 16+
public void processItems(SequencedCollection<String> items) {
    // Явное указание на коллекцию с определенным порядком
}

public static <T> List<T> loggingUnmodifiableList(List<T> list) {
    return new AbstractList<T>() {
        @Override
        public T get(int index) {
            return list.get(index);
        }
        
        @Override
        public int size() {
            return list.size();
        }
        
        @Override
        public void add(int index, T element) {
            logError("Attempt to modify unmodifiable list at index " + index);
            throw new UnsupportedOperationException();
        }
    };
}

// Мониторинг создания коллекций
public class CollectionMonitor {
    private static final AtomicLong listCreations = new AtomicLong();
    
    public static <E> List<E> monitoredListOf(E... elements) {
        listCreations.incrementAndGet();
        return List.of(elements);
    }
    
    public static long getCreationCount() {
        return listCreations.get();
    }
}

import java.util.*;

public class Task261225 {
    public static void main(String[] args) {
        Integer[] array = {1, 2, 3};
        List<Integer> list1 = Arrays.asList(array);
        List<Integer> list2 = List.of(array);
        List<Integer> list3 = Collections.unmodifiableList(list1);

        array[1] = 20;

        System.out.println(list2.get(1));
        System.out.println(list3.get(1));
    }
}