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;
    // Методы для работы с сегментами карты
}
Каждая операция, которая изменяет данные, блокирует только соответствующий сегмент, что значительно увеличивает параллелизм и производительность по сравнению с глобальной блокировкой.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
        List<String> syncList = Collections.synchronizedList(list);

        synchronized(syncList) {
            for (String s : syncList) {
                syncList.remove(s);
            }
        }
        
        System.out.println(syncList);
    }
}

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

public class RequestHistoryManager {
    private final Map<String, List<String>> clientRequestHistory = Collections.synchronizedMap(new HashMap<>());

    public void addRequest(String clientId, String request) {
        clientRequestHistory.computeIfAbsent(clientId, k -> Collections.synchronizedList(new ArrayList<>())).add(request);
    }

    public List<String> getRequestHistory(String clientId) {
        return clientRequestHistory.getOrDefault(clientId, new ArrayList<>());
    }
}

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

manager.addRequest("client1", "GET /index.html");
manager.addRequest("client1", "POST /login");
manager.addRequest("client2", "GET /products");

System.out.println(manager.getRequestHistory("client1"));
System.out.println(manager.getRequestHistory("client2"));
В этом примере clientRequestHistory представляет собой синхронизированную карту, а списки запросов для каждого клиента также являются синхронизированными. Это гарантирует, что добавление и получение истории запросов будет происходить корректно даже при параллельном доступе.

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

public class TaskQueueManager {
    private final List<String> taskQueue = Collections.synchronizedList(new LinkedList<>());

    public void addTask(String task) {
        taskQueue.add(task);
    }

    public String getNextTask() {
        if (taskQueue.isEmpty()) {
            return null;
        }
        return taskQueue.remove(0);
    }
}

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

// Добавление задач
taskQueueManager.addTask("Task 1");
taskQueueManager.addTask("Task 2");
taskQueueManager.addTask("Task 3");

// Потоки обработки задач
Runnable worker = () -> {
    String task;
    while ((task = taskQueueManager.getNextTask()) != null) {
        System.out.println(Thread.currentThread().getName() + " processing " + task);
    }
};

Thread worker1 = new Thread(worker);
Thread worker2 = new Thread(worker);

worker1.start();
worker2.start();
Здесь taskQueue — это синхронизированный список, используемый как очередь задач. Потоки worker1 и worker2 одновременно извлекают задания из этой очереди и обрабатывают их. Благодаря синхронизации, мы гарантируем, что каждое задание будет обработано только одним потоком.

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

public class VisitCounter {
    private final Map<String, Integer> visitCounts = Collections.synchronizedMap(new HashMap<>());

    public void recordVisit(String page) {
        visitCounts.merge(page, 1, Integer::sum);
    }

    public int getVisitCount(String page) {
        return visitCounts.getOrDefault(page, 0);
    }
}

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

// Моделируем посещения страниц
Runnable visitSimulator = () -> {
    for (int i = 0; i < 1000; i++) {
        visitCounter.recordVisit("/index.html");
        visitCounter.recordVisit("/contact.html");
    }
};

Thread thread1 = new Thread(visitSimulator);
Thread thread2 = new Thread(visitSimulator);

thread1.start();
thread2.start();

try {
    thread1.join();
    thread2.join();
} catch (InterruptedException e) {
    e.printStackTrace();
}

System.out.println("Index Page Visits: " + visitCounter.getVisitCount("/index.html"));
System.out.println("Contact Page Visits: " + visitCounter.getVisitCount("/contact.html"));
В этом примере мы используем synchronizedMap для подсчета посещений страниц. Метод merge() безопасен для использования в многопоточной среде, что позволяет корректно увеличивать счетчики.

import java.util.Queue;
import java.util.LinkedList;
import java.util.Collections;

public class SynchronizedTaskQueue {
    private final Queue<String> taskQueue = Collections.synchronizedList(new LinkedList<>());

    public void addTask(String task) {
        synchronized (taskQueue) {
            taskQueue.add(task);
            taskQueue.notify(); // Уведомляем ждущий поток о новой задаче
        }
    }

    public String getTask() throws InterruptedException {
        synchronized (taskQueue) {
            while (taskQueue.isEmpty()) {
                taskQueue.wait(); // Ждем, пока появится новая задача
            }
            return taskQueue.poll();
        }
    }
}

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

// Поток для добавления задач
Thread producer = new Thread(() -> {
    for (int i = 0; i < 5; i++) {
        queue.addTask("Task " + i);
    }
});

// Поток для обработки задач
Thread consumer = new Thread(() -> {
    try {
        for (int i = 0; i < 5; i++) {
            String task = queue.getTask();
            System.out.println("Processing " + task);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
});

producer.start();
consumer.start();
В этом примере мы используем синхронизированную очередь задач, где метод addTask() добавляет задачи в очередь и уведомляет ждущие потоки, а метод getTask() ждет появления новой задачи, если очередь пуста. Таким образом, обеспечивается безопасный доступ к общему ресурсу в многопоточной среде.

public class Properties extends Hashtable<Object, Object> {
    // Хранение значений по умолчанию
    protected Properties defaults;

    // Конструкторы
    public Properties() {
        this(null);
    }

    public Properties(Properties defaults) {
        this.defaults = defaults;
    }

    // Основные методы
    public String getProperty(String key) {
        Object oval = super.get(key);
        String sval = (oval instanceof String) ? (String)oval : null;
        return ((sval == null) && (defaults != null)) ? defaults.getProperty(key) : sval;
    }

    public String getProperty(String key, String defaultValue) {
        String val = getProperty(key);
        return (val == null) ? defaultValue : val;
    }

    public Object setProperty(String key, String value) {
        return put(key, value);
    }

    // Методы для работы с файлами
    public void load(InputStream inStream) throws IOException {
        // ...
    }

    public void store(OutputStream out, String comments) throws IOException {
        // ...
    }
}

database.url=jdbc:mysql://localhost:3306/mydb
database.username=root
database.password=12345
Файл .properties имеет простой формат: каждая строка представляет собой пару "ключ=значение". Комментарии могут быть добавлены с помощью символов # или ! в начале строки.

Properties defaults = new Properties();
defaults.setProperty("language", "English");

Properties config = new Properties(defaults);
config.setProperty("database.url", "jdbc:mysql://localhost:3306/mydb");

System.out.println(config.getProperty("language")); // Выведет: English
В данном примере, если запрашиваемое свойство не найдено в объекте config, оно будет искаться в объекте defaults.

try (FileInputStream input = new FileInputStream("config.properties")) {
    Properties config = new Properties();
    config.load(input);
    System.out.println(config.getProperty("database.url"));
} catch (IOException e) {
    e.printStackTrace();
}
В этом примере Properties загружаются из файла config.properties, и после этого можно получить доступ к его значениям.

public class Main {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        int c = a;
        a = b;
        b = c;

        System.out.println(a + " " + b + " " + c);
    }
}