import java.util.*;

public class ImmutableCollections {
    
    public static void main(String[] args) {
        //Антипаттерн: попытка модифицировать иммутабельные коллекции
        
        // Collections.emptyList()
        List<String> empty = Collections.emptyList();
        try {
            empty.add("item"); // UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot add to emptyList: " + e);
        }
        
        // List.of() (Java 9+)
        List<String> of = List.of("A", "B", "C");
        try {
            of.add("D"); // UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot add to List.of: " + e);
        }
        
        try {
            of.set(0, "Z"); // Тоже исключение! Даже замена элемента запрещена
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot set in List.of: " + e);
        }
        
        // Collections.singletonList()
        List<String> singleton = Collections.singletonList("only");
        try {
            singleton.add("second"); // UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot add to singletonList: " + e);
        }
        
        //Правильное использование: read-only операции
        List<String> readOnly = List.of("Red", "Green", "Blue");
        for (String color : readOnly) {
            System.out.print(color + " ");
        }
        System.out.println();
        String first = readOnly.get(0);
        boolean contains = readOnly.contains("Green");
        
        //Решение 1: создание изменяемой копии
        List<String> mutable = new ArrayList<>(readOnly);
        mutable.add("Yellow");
        mutable.set(0, "Cyan");
        System.out.println("Mutable copy: " + mutable);
        
        //Решение 2: создание изменяемой пустой коллекции
        List<String> mutableEmpty = new ArrayList<>();
        mutableEmpty.add("item"); // Работает
        
        //Решение 3: защитное копирование в API
        public static List<String> getInternalList() {
            // Возвращаем иммутабельный список, чтобы защитить внутреннее состояние
            return List.of("internal1", "internal2");
        }
        
        // Получатель, который хочет модифицировать:
        List<String> fromApi = getInternalList();
        List<String> myWorkingCopy = new ArrayList<>(fromApi);
        myWorkingCopy.add("myItem");
        
        // Различия между видами иммутабельных списков
        List<String> oldStyleEmpty = Collections.emptyList(); // Пустой, иммутабельный
        List<String> newStyleEmpty = List.of();              // То же самое, но короче
        
        List<String> oldStyleSingle = Collections.singletonList("one");
        List<String> newStyleSingle = List.of("one");
        
        // List.of() не допускает null
        try {
            List.of("a", null, "b"); // NullPointerException
        } catch (NullPointerException e) {
            System.out.println("List.of() rejects nulls");
        }
        
        // Collections.emptyList() допускает null? Нет, при добавлении, но сам список может содержать null? 
        // Сам список пуст, но методы типа contains(null) работают без исключения
        System.out.println("emptyList contains null: " + Collections.emptyList().contains(null)); // false
    }
}

import java.util.*;

public class Task050526 {
    public static void main(String[] args) {
        List<String> list1 = Collections.emptyList();
        List<String> list2 = List.of();
        List<String> list3 = new ArrayList<>(List.of("a", "b"));
        List<String> list4 = list3.subList(0, 2);

        list1.add("x");
        list2.add("x");
        list3.add("x");
        list4.add("x");

        System.out.println("Done");
    }
}

// Упрощенный псевдокод инициализации из OpenJDK
FileOutputStream fdOut = new FileOutputStream(FileDescriptor.out);
BufferedOutputStream bufOut = new BufferedOutputStream(fdOut, 128);
System.out = new PrintStream(bufOut, true, charset); // autoFlush = true

// Эта строка форматируется всегда, даже если вывод не нужен
System.out.println("User " + userId + " performed " + operation + " at " + Instant.now());

// Антипаттерн: ручное форматирование метаданных
System.out.println("[" + Thread.currentThread().getName() + "] [" + 
    LocalDateTime.now() + "] [INFO] [" + getClass().getName() + 
    "] User " + userId + " not found");

public class Task060526 {
    private static String getValue() {
        try {
            return "try";
        } finally {
            System.out.print("finally ");
        }
    }

    public static void main(String[] args) {
        System.out.print(getValue() + " ");
        System.out.println("main");
    }
}

public class Singleton {
    
    //Антипаттерн: double-checked locking без volatile
    private static Singleton instance; // отсутствует volatile!
    
    public static Singleton getInstanceBad() {
        if (instance == null) { // Первая проверка
            synchronized (Singleton.class) {
                if (instance == null) { // Вторая проверка
                    instance = new Singleton(); // Может быть переупорядочено!
                }
            }
        }
        return instance;
    }
    
    //Решение: volatile гарантирует корректность
    private static volatile Singleton instance;
    
    public static Singleton getInstanceGood() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton(); // Теперь безопасно
                }
            }
        }
        return instance;
    }
    
    //Лучшее решение без синхронизации: Initialization-on-demand holder
    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstanceHolder() {
        return Holder.INSTANCE; // Инициализация при первом обращении
    }
    
    //enum-синглтон (сериализация безопасна)
    public enum EnumSingleton {
        INSTANCE;
        public void doSomething() { }
    }
    
    private Singleton() { }
}

public class Task070926 {
    static int a = getB();
    static int b = 5;
    static int getB() { return b; }

    public static void main(String[] args) {
        System.out.println("a=" + a + ", b=" + b);
    }
}