import java.util.BitSet;

public class Main {
    public static void main(String[] args) {
        BitSet bitset = new BitSet(10);
        bitset.set(0);
        bitset.set(3);
        bitset.set(5);
        bitset.set(7);
        bitset.flip(0, 6);
        bitset.clear(7);
        
        for (int i = 0; i < 10; i++) {
            System.out.print(bitset.get(i) ? "1" : "0");
        }
    }
}

BitSet bitSet = new BitSet();
bitSet.set(2); // Устанавливает бит с индексом 2 в true
bitSet.set(4, 7); // Устанавливает биты с индексами 4, 5 и 6 в true
Если указать диапазон, все биты в этом диапазоне будут установлены в true.

bitSet.clear(2); // Сбрасывает бит с индексом 2 в false
bitSet.clear(4, 7); // Сбрасывает биты с индексами 4, 5 и 6 в false
Полезно для обнуления значений или удаления флагов.

boolean value = bitSet.get(2); // Получает значение бита с индексом 2
BitSet subSet = bitSet.get(4, 7); // Получает поднабор битов с 4 до 6
Возвращаемое значение может быть true или false, а в случае диапазона — новый BitSet.

bitSet.flip(2); // Инвертирует бит с индексом 2
bitSet.flip(4, 7); // Инвертирует биты с 4 до 6
Если бит был true, он станет false, и наоборот.

System.out.println("Length: " + bitSet.length()); // Логическая длина BitSet
System.out.println("Size: " + bitSet.size()); // Текущий размер внутреннего массива
Эти методы полезны для анализа содержимого BitSet и его текущего состояния.

int numberOfBits = bitSet.cardinality(); // Количество установленных битов
Полезно, когда нужно узнать, сколько значений true содержится в наборе.

BitSet bitSet1 = new BitSet();
bitSet1.set(1);
bitSet1.set(3);

BitSet bitSet2 = new BitSet();
bitSet2.set(2);
bitSet2.set(3);

bitSet1.and(bitSet2); // AND операция между bitSet1 и bitSet2
bitSet1.or(bitSet2);  // OR операция между bitSet1 и bitSet2
bitSet1.xor(bitSet2); // XOR операция между bitSet1 и bitSet2
Эти методы полезны для выполнения сложных битовых операций между двумя наборами.

boolean hasIntersection = bitSet1.intersects(bitSet2); // true, если есть общие биты
Метод возвращает true, если есть хотя бы один бит, который установлен в true в обоих наборах.

boolean isEmpty = bitSet.isEmpty(); // true, если все биты сброшены
Полезно для проверки пустоты множества.

bitSet.stream().forEach(System.out::println); // Выводит индексы установленных битов
Это удобный способ итерирования по установленным битам с использованием функциональных возможностей Java.

BitSet largeSet = new BitSet();
for (int i = 0; i < 1000000; i++) {
    if (i % 2 == 0) {
        largeSet.set(i);
    }
}

System.out.println("Количество установленных битов: " + largeSet.cardinality());
В этом примере BitSet используется для хранения большого количества булевых значений, что значительно экономит память по сравнению с использованием массивов boolean[].

NavigableSet<Integer> navigableSet = new TreeSet<>();
navigableSet.add(5);
navigableSet.add(2);
navigableSet.add(9);

System.out.println(navigableSet); // [2, 5, 9]

NavigableSet<String> navigableSet = new ConcurrentSkipListSet<>();
navigableSet.add("banana");
navigableSet.add("apple");
navigableSet.add("cherry");

System.out.println(navigableSet); // [apple, banana, cherry]

import java.util.*;

public class Main {
    public static void main(String[] args) {
        NavigableSet<Integer> set = new TreeSet<>(Arrays.asList(10, 20, 30, 40, 50));
        System.out.println(set.lower(30));
        System.out.println(set.floor(30));
        System.out.println(set.ceiling(25));
        System.out.println(set.higher(50));
    }
}

NavigableSet<Integer> set = new TreeSet<>(Arrays.asList(1, 2, 3, 4, 5));
System.out.println(set.lower(3)); // Output: 2

System.out.println(set.floor(3)); // Output: 3
System.out.println(set.floor(6)); // Output: 5

System.out.println(set.ceiling(3)); // Output: 3
System.out.println(set.ceiling(0)); // Output: 1

System.out.println(set.higher(3)); // Output: 4
System.out.println(set.higher(5)); // Output: null

NavigableSet<String> set = new TreeSet<>(Arrays.asList("apple", "banana", "cherry"));
System.out.println(set.pollFirst()); // Output: apple
System.out.println(set.pollLast());  // Output: cherry
System.out.println(set);             // Output: [banana]

NavigableSet<String> set = new TreeSet<>(Arrays.asList("apple", "banana", "cherry"));
NavigableSet<String> descendingSet = set.descendingSet();
System.out.println(descendingSet); // Output: [cherry, banana, apple]

NavigableSet<Integer> set = new TreeSet<>(Arrays.asList(1, 2, 3, 4, 5));
NavigableSet<Integer> subSet = set.subSet(2, true, 4, false);
System.out.println(subSet); // Output: [2, 3]

NavigableSet<Integer> headSet = set.headSet(4, true);
System.out.println(headSet); // Output: [1, 2, 3, 4]

NavigableSet<Integer> tailSet = set.tailSet(3, false);
System.out.println(tailSet); // Output: [4, 5]

NavigableSet<Integer> temperatures = new TreeSet<>(Arrays.asList(10, 15, 20, 25, 30));
NavigableSet<Integer> comfortableTemperatures = temperatures.subSet(15, true, 25, true);
System.out.println(comfortableTemperatures); // Output: [15, 20, 25]

NavigableSet<LocalDate> dates = new TreeSet<>(Arrays.asList(
    LocalDate.of(2023, 8, 20),
    LocalDate.of(2023, 9, 5),
    LocalDate.of(2023, 10, 10)
));

LocalDate today = LocalDate.of(2023, 8, 25);
LocalDate nextDate = dates.ceiling(today);

System.out.println(nextDate); // Output: 2023-09-05

List<String> immutableList = List.of("apple", "banana", "cherry");
Set<Integer> immutableSet = Set.of(1, 2, 3);
Map<Integer, String> immutableMap = Map.of(1, "one", 2, "two", 3, "three");
Эти коллекции обеспечивают высокую производительность и компактность, так как они реализованы с использованием специализированных внутренних структур данных.

List<String> mutableList = new ArrayList<>(Arrays.asList("apple", "banana", "cherry"));
List<String> immutableList = Collections.unmodifiableList(mutableList);
Однако важно помнить, что хотя сам объект коллекции становится неизменяемым, если исходная коллекция, переданная в метод, изменится, это отразится и на неизменяемой коллекции.

List<String> guavaImmutableList = ImmutableList.of("apple", "banana", "cherry");
Set<Integer> guavaImmutableSet = ImmutableSet.of(1, 2, 3);
Коллекции Guava полностью независимы от оригинальной коллекции и не изменяются, даже если исходная коллекция изменяется.

List<String> listWithNull = List.of("apple", null, "cherry"); // Throws NullPointerException

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> list = List.of("apple", "banana", "cherry");
        list.add("date");
        System.out.println(list);
    }
}

import java.util.List;

public class ConfigurationManager {
    private final List<String> configurations;

    public ConfigurationManager(List<String> configurations) {
        this.configurations = List.copyOf(configurations);
    }

    public List<String> getConfigurations() {
        return configurations;
    }
}

// Пример использования
List<String> initialConfigs = Arrays.asList("config1", "config2", "config3");
ConfigurationManager manager = new ConfigurationManager(initialConfigs);

List<String> configs = manager.getConfigurations();
configs.forEach(System.out::println);
В этом примере, использование List.copyOf() в конструкторе ConfigurationManager гарантирует, что коллекция configurations будет неизменяемой, и любые попытки изменить ее извне будут заблокированы.

import java.util.Collections;
import java.util.List;

public class Company {
    private final List<String> employees;

    public Company(List<String> employees) {
        this.employees = Collections.unmodifiableList(employees);
    }

    public List<String> getEmployees() {
        return employees;
    }
}

// Пример использования
List<String> employeeList = Arrays.asList("Alice", "Bob", "Charlie");
Company company = new Company(employeeList);

List<String> employees = company.getEmployees();
employees.forEach(System.out::println);

// Попытка изменения списка приведет к исключению UnsupportedOperationException
employees.add("David"); // This line will throw an exception
Здесь мы используем Collections.unmodifiableList(), чтобы создать неизменяемый список сотрудников. Это предотвращает любые попытки изменить список и гарантирует его неизменность в течение всего жизненного цикла программы.

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

public class CalculationManager {
    private final Map<List<Integer>, Integer> calculationResults = new HashMap<>();

    public void addCalculationResult(List<Integer> params, int result) {
        List<Integer> immutableParams = List.copyOf(params);
        calculationResults.put(immutableParams, result);
    }

    public Integer getResult(List<Integer> params) {
        return calculationResults.get(params);
    }
}

// Пример использования
CalculationManager manager = new CalculationManager();

List<Integer> params = Arrays.asList(1, 2, 3);
manager.addCalculationResult(params, 10);

params.set(0, 5); // Изменение оригинального списка не повлияет на ключ в Map
System.out.println(manager.getResult(Arrays.asList(1, 2, 3))); // Output: 10
В этом примере мы используем List.copyOf() для создания неизменяемой версии списка параметров перед добавлением его в Map. Это гарантирует, что изменения оригинального списка params не повлияют на ключ в Map, сохраняя целостность данных.

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

public class CacheManager {
    private final Map<List<Integer>, Integer> cache = new HashMap<>();

    public Integer computeIfAbsent(List<Integer> params, Calculation calculation) {
        List<Integer> immutableParams = List.copyOf(params);
        return cache.computeIfAbsent(immutableParams, calculation::calculate);
    }

    public interface Calculation {
        Integer calculate(List<Integer> params);
    }
}

// Пример использования
CacheManager cacheManager = new CacheManager();

List<Integer> params = Arrays.asList(2, 3, 4);
int result = cacheManager.computeIfAbsent(params, (p) -> p.stream().reduce(1, (a, b) -> a * b));

System.out.println(result); // Output: 24

// Повторный вызов с теми же параметрами вернет кэшированный результат
result = cacheManager.computeIfAbsent(params, (p) -> p.stream().reduce(1, (a, b) -> a * b));
System.out.println(result); // Output: 24
Здесь неизменяемая коллекция используется в качестве ключа для кэширования результата вычислений. Это позволяет избежать проблем с изменением параметров, которые могут привести к некорректному поведению кэша.

List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());
Set<Integer> synchronizedSet = Collections.synchronizedSet(new HashSet<>());
Map<Integer, String> synchronizedMap = Collections.synchronizedMap(new HashMap<>());
Эти методы оборачивают оригинальные коллекции в специальные прокси-объекты, которые обеспечивают синхронизацию доступа к ним.

List<String> copyOnWriteList = new CopyOnWriteArrayList<>();
Set<String> copyOnWriteSet = new CopyOnWriteArraySet<>();
Эти коллекции оптимизированы для сценариев, где частое чтение данных значительно превосходит частоту их изменения, так как они избегают блокировок при чтении.

Map<Integer, String> concurrentMap = new ConcurrentHashMap<>();
В отличие от Collections.synchronizedMap(), ConcurrentHashMap предоставляет более гибкие методы для работы с параллельными потоками, такие как putIfAbsent(), replace() и computeIfAbsent().

public static <T> List<T> synchronizedList(List<T> list) {
    return new SynchronizedList<>(list);
}

static class SynchronizedList<E> implements List<E> {
    private final List<E> list;

    public synchronized boolean add(E e) {
        synchronized (this) {
            return list.add(e);
        }
    }

    // Другие методы с аналогичной синхронизацией
}
В данном примере каждый метод обернут в блок synchronized, что гарантирует, что только один поток сможет выполнять операцию над коллекцией в любой момент времени.

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}
Здесь используется ReentrantLock для блокировки доступа при изменении коллекции, а чтение происходит без блокировок, что делает коллекцию чрезвычайно эффективной при большом количестве операций чтения.

static class Segment<K,V> extends ReentrantLock {
    volatile HashEntry<K,V>[] table;
    // Методы для работы с сегментами карты
}
Каждая операция, которая изменяет данные, блокирует только соответствующий сегмент, что значительно увеличивает параллелизм и производительность по сравнению с глобальной блокировкой.