Коллекции

Коллекции в Java — это набор классов и интерфейсов, которые предназначены для хранения и управления группами объектов. Коллекции позволяют легко манипулировать группами данных, предоставляя методы для добавления, удаления, поиска и сортировки элементов.

Основные интерфейсы коллекций

Collection

Родительский интерфейс для большинства коллекций.
Основные методы: add(), remove(), size(), contains(), iterator().
List

Упорядоченная коллекция, допускающая дублирование элементов.
Основные реализации: ArrayList, LinkedList, Vector.
Set

Коллекция, не допускающая дублирование элементов.
Основные реализации: HashSet, LinkedHashSet, TreeSet.
Queue

Коллекция, предназначенная для хранения элементов перед их обработкой.
Основные реализации: LinkedList, PriorityQueue.
Map

Коллекция, хранящая пары ключ-значение.
Основные реализации: HashMap, LinkedHashMap, TreeMap, Hashtable.
Основные методы коллекций

add(E element): добавляет элемент в коллекцию.
remove(Object o): удаляет элемент из коллекции.
size(): возвращает количество элементов в коллекции.
contains(Object o): проверяет, содержит ли коллекция указанный элемент.
iterator(): возвращает итератор для перебора элементов коллекции.

Итераторы

Итераторы позволяют проходить по элементам коллекции:

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}

Generics в коллекциях

Использование generics позволяет коллекциям работать с определенным типом данных:

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
// list.add(1); // Ошибка компиляции, так как list предназначен для хранения только строк.
Преимущества использования коллекций

Гибкость: коллекции позволяют хранить произвольное количество объектов.
Удобство: коллекции предоставляют мощные методы для работы с данными.
Производительность: коллекции оптимизированы для различных операций, таких как добавление, удаление и поиск элементов.

#Java #Training #Collections

List, ArrayList, LinkedList

List

List — это интерфейс в Java, представляющий упорядоченную коллекцию, допускающую дублирование элементов. Основные реализации интерфейса List включают ArrayList и LinkedList.

ArrayList

ArrayList — это класс, реализующий интерфейс List, основанный на динамическом массиве. Он предоставляет быстрый доступ к элементам по индексу и эффективен для операций добавления и удаления элементов в конце списка.

Основные методы ArrayList

Создание ArrayList:

List<String> arrayList = new ArrayList<>();

Добавление элементов:

arrayList.add("Apple");
arrayList.add("Banana");
arrayList.add("Orange");

Доступ по индексу:

String fruit = arrayList.get(0); // "Apple"

Изменение элемента:

arrayList.set(1, "Grapes"); // Изменяет "Banana" на "Grapes"

Удаление элемента:

arrayList.remove(0); // Удаляет "Apple"

Размер списка:

int size = arrayList.size(); // 2

Перебор элементов:

for (String fruit : arrayList) {
    System.out.println(fruit);
}

LinkedList

LinkedList — это класс, реализующий интерфейс List, основанный на двусвязном списке. Он предоставляет эффективное добавление и удаление элементов в середине списка, но доступ по индексу медленнее по сравнению с ArrayList.

Основные методы LinkedList

Создание LinkedList:

List<String> linkedList = new LinkedList<>();

Добавление элементов:

linkedList.add("Apple");
linkedList.add("Banana");
linkedList.add("Orange");

Доступ по индексу:

String fruit = linkedList.get(0); // "Apple"

Изменение элемента:

linkedList.set(1, "Grapes"); // Изменяет "Banana" на "Grapes"

Удаление элемента:

linkedList.remove(0); // Удаляет "Apple"

Размер списка:

int size = linkedList.size(); // 2

Перебор элементов:

for (String fruit : linkedList) {
    System.out.println(fruit);
}

Сравнение ArrayList и LinkedList

Структура данных:

ArrayList основан на динамическом массиве.
LinkedList основан на двусвязном списке.

Доступ по индексу:

ArrayList обеспечивает быстрый доступ по индексу (O(1)).
LinkedList медленнее при доступе по индексу (O(n)).

Добавление и удаление элементов:

ArrayList быстрее добавляет и удаляет элементы в конце списка (O(1)).
LinkedList быстрее добавляет и удаляет элементы в середине списка (O(1) для добавления/удаления с начала/конца, O(n) для доступа по индексу).

Использование памяти:

ArrayList использует меньше памяти, так как хранит элементы в массиве.
LinkedList использует больше памяти из-за хранения ссылок на предыдущий и следующий элементы.

#Java #Training #Collections

Set, HashSet, TreeSet

Set

Set — это интерфейс в Java, представляющий коллекцию, которая не допускает дублирование элементов. Set обеспечивает хранение уникальных элементов, что полезно в случаях, когда важно отсутствие повторяющихся значений.

Основные реализации интерфейса Set:

HashSet
TreeSet
LinkedHashSet (реализует упорядоченный по порядку добавления Set)
HashSet

HashSet — это класс, реализующий интерфейс Set, основанный на хеш-таблице. Он не гарантирует упорядоченность элементов и допускает null значения.

Основные характеристики HashSet:

Неупорядоченность: Порядок элементов не гарантируется и может изменяться.
Эффективность: Основные операции (вставка, удаление, проверка наличия) выполняются за постоянное время (O(1)).
Уникальность: Не допускает дублирование элементов.

Основные методы HashSet:

Создание HashSet:

Set<String> hashSet = new HashSet<>();

Добавление элементов:

hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Orange");

Удаление элементов:

hashSet.remove("Banana");

Проверка наличия элемента:

boolean containsApple = hashSet.contains("Apple"); // true

Размер множества:

int size = hashSet.size(); // 2

Перебор элементов:

for (String fruit : hashSet) {
    System.out.println(fruit);
}

TreeSet

TreeSet — это класс, реализующий интерфейс Set, основанный на красно-черном дереве. Он гарантирует естественный порядок элементов или порядок, заданный компаратором.

Основные характеристики TreeSet:

Упорядоченность: Элементы хранятся в отсортированном порядке.
Эффективность: Основные операции (вставка, удаление, проверка наличия) выполняются за логарифмическое время (O(log n)).
Уникальность: Не допускает дублирование элементов.

Основные методы TreeSet:

Создание TreeSet:

Set<String> treeSet = new TreeSet<>();

Добавление элементов:

treeSet.add("Apple");
treeSet.add("Banana");
treeSet.add("Orange");

Удаление элементов:

treeSet.remove("Banana");

Проверка наличия элемента:

boolean containsApple = treeSet.contains("Apple"); // true

Размер множества:

int size = treeSet.size(); // 2

Перебор элементов:

for (String fruit : treeSet) {
    System.out.println(fruit);
}

Получение первого и последнего элемента:

String first = treeSet.first(); // "Apple"
String last = treeSet.last(); // "Orange"

Подмножества:

SortedSet<String> subSet = treeSet.subSet("Apple", "Orange");

Сравнение HashSet и TreeSet

Структура данных:

HashSet основан на хеш-таблице.
TreeSet основан на красно-черном дереве.

Упорядоченность:

HashSet не гарантирует упорядоченности элементов.
TreeSet хранит элементы в отсортированном порядке.

Эффективность:

HashSet выполняет основные операции за постоянное время (O(1)).
TreeSet выполняет основные операции за логарифмическое время (O(log n)).

Использование памяти:

HashSet обычно использует меньше памяти, так как не хранит информацию о порядке элементов.
TreeSet использует больше памяти из-за хранения информации о порядке.

#Java #Training #Collections

Map, HashMap, TreeMap

Map

Map — это интерфейс в Java, представляющий коллекцию пар "ключ-значение". Map не допускает дублирование ключей, но позволяет дублирование значений. Основные реализации интерфейса Map включают HashMap и TreeMap.

Основные реализации интерфейса Map:

HashMap
TreeMap
LinkedHashMap (реализует упорядоченный по порядку добавления Map)
Hashtable (устаревшая, но синхронизированная версия Map)
HashMap

HashMap — это класс, реализующий интерфейс Map, основанный на хеш-таблице. Он не гарантирует упорядоченность ключей и допускает null значения для ключей и значений.

Основные характеристики HashMap:

Неупорядоченность: Порядок ключей не гарантируется и может изменяться.
Эффективность: Основные операции (вставка, удаление, получение) выполняются за постоянное время (O(1)).
Уникальность ключей: Не допускает дублирование ключей.

Основные методы HashMap:

Создание HashMap:

Map<String, Integer> hashMap = new HashMap<>();

Добавление пар ключ-значение:

hashMap.put("Apple", 1);
hashMap.put("Banana", 2);
hashMap.put("Orange", 3);

Получение значения по ключу:

 
int value = hashMap.get("Apple"); // 1

Удаление пары по ключу:

hashMap.remove("Banana");

Проверка наличия ключа:

boolean containsKey = hashMap.containsKey("Apple"); // true

Размер карты:

int size = hashMap.size(); // 2

Перебор пар ключ-значение:

for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

TreeMap

TreeMap — это класс, реализующий интерфейс Map, основанный на красно-черном дереве. Он гарантирует естественный порядок ключей или порядок, заданный компаратором.

Основные характеристики TreeMap:

Упорядоченность: Ключи хранятся в отсортированном порядке.
Эффективность: Основные операции (вставка, удаление, получение) выполняются за логарифмическое время (O(log n)).
Уникальность ключей: Не допускает дублирование ключей.

Основные методы TreeMap:

Создание TreeMap:

Map<String, Integer> treeMap = new TreeMap<>();

Добавление пар ключ-значение:

treeMap.put("Apple", 1);
treeMap.put("Banana", 2);
treeMap.put("Orange", 3);

Получение значения по ключу:

int value = treeMap.get("Apple"); // 1

Удаление пары по ключу:

treeMap.remove("Banana");

Проверка наличия ключа:

boolean containsKey = treeMap.containsKey("Apple"); // true

Размер карты:

int size = treeMap.size(); // 2

Перебор пар ключ-значение:

for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

Получение первого и последнего ключа:

String firstKey = treeMap.firstKey(); // "Apple"
String lastKey = treeMap.lastKey(); // "Orange"

Подкарты:

SortedMap<String, Integer> subMap = treeMap.subMap("Apple", "Orange");

Сравнение HashMap и TreeMap

Структура данных:

HashMap основан на хеш-таблице.
TreeMap основан на красно-черном дереве.

Упорядоченность:

HashMap не гарантирует упорядоченности ключей.
TreeMap хранит ключи в отсортированном порядке.

Эффективность:

HashMap выполняет основные операции за постоянное время (O(1)).
TreeMap выполняет основные операции за логарифмическое время (O(log n)).

Использование памяти:

HashMap обычно использует меньше памяти, так как не хранит информацию о порядке ключей.
TreeMap использует больше памяти из-за хранения информации о порядке.

#Java #Training #Collections

Введение в Queue

Queue — это интерфейс в Java, представляющий коллекцию, предназначенную для хранения элементов в порядке, поддерживающем принципы FIFO (First-In-First-Out). Элементы добавляются в конец очереди и извлекаются из начала. Queue является частью коллекций Java и находится в пакете java.util.

Реализации Queue

Существует несколько реализаций интерфейса Queue в Java:

LinkedList: Класс LinkedList реализует интерфейс Queue и предоставляет эффективные операции вставки и удаления с обоих концов списка.

Queue<String> queue = new LinkedList<>();

PriorityQueue: Класс PriorityQueue реализует интерфейс Queue и предоставляет приоритетную очередь, в которой элементы упорядочены на основе их естественного порядка или на основе предоставленного компаратора.

Queue<String> priorityQueue = new PriorityQueue<>();

ArrayDeque: Класс ArrayDeque реализует интерфейс Deque (двусторонняя очередь) и может использоваться как Queue.

Queue<String> arrayDeque = new ArrayDeque<>();

Основные операции:

Добавление элементов:

add(E e): Добавляет элемент в конец очереди. Выбрасывает исключение IllegalStateException, если очередь ограничена и заполнена.

queue.add("Element");

offer(E e): Добавляет элемент в конец очереди. Возвращает false, если очередь ограничена и заполнена.

queue.offer("Element");

Удаление элементов:

remove(): Удаляет и возвращает элемент из начала очереди. Выбрасывает исключение NoSuchElementException, если очередь пуста.

String element = queue.remove();

poll(): Удаляет и возвращает элемент из начала очереди. Возвращает null, если очередь пуста.

String element = queue.poll();

Просмотр элементов:

element(): Возвращает, но не удаляет, элемент из начала очереди. Выбрасывает исключение NoSuchElementException, если очередь пуста.

String element = queue.element();

peek(): Возвращает, но не удаляет, элемент из начала очереди. Возвращает null, если очередь пуста.

String element = queue.peek();

Пример использования Queue

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

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();

        // Добавление элементов
        queue.add("Element 1");
        queue.offer("Element 2");

        // Просмотр элемента
        System.out.println("Peek: " + queue.peek());

        // Удаление элементов
        System.out.println("Removed: " + queue.remove());
        System.out.println("Polled: " + queue.poll());

        // Попытка просмотра/удаления из пустой очереди
        System.out.println("Peek from empty queue: " + queue.peek());
        System.out.println("Poll from empty queue: " + queue.poll());
    }
}

#Java #Training #Collections #Queue

Введение в Stack

Stack — это класс в Java, представляющий коллекцию, предназначенную для хранения элементов в порядке, поддерживающем принципы LIFO (Last-In-First-Out). Элементы добавляются и извлекаются с одного конца стека, называемого вершиной. Класс Stack находится в пакете java.util и наследуется от класса Vector.

Создание Stack

Для создания экземпляра Stack нужно импортировать класс java.util.Stack и использовать его конструктор:

Stack<String> stack = new Stack<>();

Основные операции

Добавление элементов:

push(E item): Добавляет элемент на вершину стека.

stack.push("Element");

Удаление элементов:

pop(): Удаляет и возвращает элемент с вершины стека. Выбрасывает исключение EmptyStackException, если стек пуст.

String element = stack.pop();

Просмотр элементов:

peek(): Возвращает, но не удаляет, элемент с вершины стека. Выбрасывает исключение EmptyStackException, если стек пуст.

String element = stack.peek();

Проверка состояния стека:

empty(): Проверяет, пуст ли стек. Возвращает true, если стек пуст, и false в противном случае.

boolean isEmpty = stack.empty();

search(Object o): Ищет элемент в стеке и возвращает его положение, начиная с вершины стека. Возвращает -1, если элемент не найден.

int position = stack.search("Element");

Пример использования Stack

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();

        // Добавление элементов
        stack.push("Element 1");
        stack.push("Element 2");
        stack.push("Element 3");

        // Просмотр элемента
        System.out.println("Peek: " + stack.peek());

        // Удаление элементов
        System.out.println("Popped: " + stack.pop());
        System.out.println("Popped: " + stack.pop());

        // Проверка состояния стека
        System.out.println("Is stack empty? " + stack.empty());

        // Поиск элемента
        stack.push("Element 4");
        stack.push("Element 5");
        System.out.println("Position of 'Element 4': " + stack.search("Element 4"));

        // Удаление оставшихся элементов
        System.out.println("Popped: " + stack.pop());
        System.out.println("Popped: " + stack.pop());

        // Попытка просмотра/удаления из пустого стека
        System.out.println("Is stack empty? " + stack.empty());
    }
}

Сравнение Queue и Stack
Очередь (Queue): Использует порядок FIFO (First-In-First-Out). Элементы добавляются в конец и удаляются из начала.
Стек (Stack): Использует порядок LIFO (Last-In-First-Out). Элементы добавляются и удаляются с вершины.

#Java #Training #Collections

Collections, особенности и внутреннее устройство

Работа с коллекциями — это неотъемлемая часть программирования на Java. Коллекции позволяют разработчикам удобно управлять группами объектов, будь то списки, множества, очереди или карты. Коллекции являются частью структуры данных и играют важную роль в решении множества задач, таких как сортировка, фильтрация и агрегирование данных.

Что такое коллекции?
Коллекции в Java представляют собой архитектуру, позволяющую группировать объекты, чтобы упростить управление и манипулирование ими. В Java коллекции представлены в виде интерфейсов и классов, которые обеспечивают удобные методы для работы с данными. Основные интерфейсы коллекций включают List, Set, Queue, Deque и Map. Каждый из этих интерфейсов реализуется различными классами, которые обеспечивают конкретную реализацию соответствующих структур данных.

Иерархия коллекций в Java начинается с интерфейса Collection, который является корневым интерфейсом для всех коллекций, за исключением Map. Вот основные интерфейсы и классы, которые используются для создания коллекций:
Collection: Основной интерфейс, от которого наследуются другие коллекции.

List: Коллекция, представляющая собой упорядоченный набор элементов, допускающий дублирование. Примеры: ArrayList, LinkedList.
Set: Коллекция, не допускающая дублирование элементов. Примеры: HashSet, TreeSet.
Queue: Коллекция, представляющая собой очередь, работающую по принципу FIFO (first-in, first-out). Примеры: LinkedList, PriorityQueue.
Deque: Двусторонняя очередь, позволяющая добавлять и удалять элементы с обеих сторон. Примеры: ArrayDeque, LinkedList.
Map: Интерфейс для хранения пар «ключ-значение», где каждый ключ уникален. Примеры: HashMap, TreeMap, LinkedHashMap.

Внутреннее устройство коллекций
Каждая коллекция в Java имеет свое уникальное внутреннее устройство и особенности, которые делают её подходящей для решения определенных задач:

1. ArrayList
ArrayList является реализацией интерфейса List, которая использует динамический массив для хранения элементов. Это означает, что элементы в ArrayList могут быть доступны по индексу, и этот доступ осуществляется за константное время (O(1)). Однако добавление новых элементов может потребовать перераспределения массива, что занимает время O(n). ArrayList отлично подходит для задач, где требуется частый доступ к элементам по индексу.

import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        System.out.println("List: " + list);
    }
}

2. LinkedList
LinkedList также реализует интерфейс List, но использует связный список для хранения элементов. В отличие от ArrayList, LinkedList обеспечивает эффективное добавление и удаление элементов в начале и середине списка, поскольку для этого не требуется перераспределение памяти. Однако доступ к элементам по индексу занимает больше времени, так как необходимо последовательно переходить от одного узла к другому.

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

public class LinkedListExample {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        System.out.println("List: " + list);
    }
}

#Java #Training #Medium #Collections

3. HashSet
HashSet реализует интерфейс Set и хранит элементы в виде хэш-таблицы. В HashSet не допускается дублирование элементов, и порядок их хранения не гарантируется. Хэш-таблица обеспечивает быстрый доступ к элементам (O(1)), что делает HashSet отличным выбором для задач, где важна производительность при добавлении и поиске уникальных элементов.

import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");
        set.add("Apple"); // Дубликат не будет добавлен

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

4. TreeSet
TreeSet также реализует интерфейс Set, но хранит элементы в отсортированном порядке с использованием красно-черного дерева. Доступ к элементам и операции добавления выполняются за логарифмическое время (O(log n)). TreeSet используется, когда необходимо поддерживать элементы в отсортированном порядке.

import java.util.Set;
import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("Banana");
        set.add("Apple");
        set.add("Cherry");

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

5. HashMap
HashMap реализует интерфейс Map и хранит данные в виде пар «ключ-значение». Ключи в HashMap уникальны, и доступ к значениям по ключу осуществляется за константное время (O(1)). HashMap является отличным выбором для хранения ассоциативных массивов, где важна производительность при доступе к данным по ключу.

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

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Cherry", 3);

        System.out.println("Map: " + map);
    }
}

Особенности коллекций

Изменяемые и неизменяемые коллекции: Большинство коллекций в Java являются изменяемыми, что означает, что их элементы можно добавлять, удалять и изменять. Однако существуют и неизменяемые коллекции, которые нельзя изменить после создания. Создание неизменяемых коллекций особенно важно в многопоточных приложениях для предотвращения непредсказуемого поведения.

Синхронизированные коллекции: Коллекции, такие как ArrayList и HashMap, не синхронизированы по умолчанию, что делает их небезопасными для многопоточной среды. Java предоставляет методы для создания синхронизированных коллекций, например, с использованием Collections.synchronizedList().

Производительность: Выбор правильной коллекции влияет на производительность приложения. Например, для частых операций вставки и удаления в середине списка лучше подходит LinkedList, тогда как для доступа по индексу предпочтительнее использовать ArrayList.

#Java #Training #Medium #Collections

Основные утилитные методы класса Collections

1. sort(List<T> list)
Метод sort(List<T> list) сортирует элементы списка в естественном порядке или с использованием заданного компаратора. Это один из самых часто используемых методов для упорядочивания элементов в списке.

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

public class SortExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(3);
        numbers.add(1);
        numbers.add(4);
        numbers.add(2);

        Collections.sort(numbers);

        System.out.println("Sorted list: " + numbers);
    }
}

Вывод:

Sorted list: [1, 2, 3, 4]
Этот пример демонстрирует сортировку списка целых чисел в естественном порядке (по возрастанию). Метод sort упорядочивает элементы на месте, изменяя исходный список.

2. reverse(List<?> list)
Метод reverse(List<?> list) изменяет порядок элементов в списке на противоположный. Это полезно, когда необходимо быстро изменить порядок элементов, например, для реализации функции отмены действий или для отображения данных в обратном порядке.

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

public class ReverseExample {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>();
        items.add("Apple");
        items.add("Banana");
        items.add("Cherry");

        Collections.reverse(items);

        System.out.println("Reversed list: " + items);
    }
}

Вывод:

Reversed list: [Cherry, Banana, Apple]
В этом примере список строк меняет свой порядок на противоположный с помощью метода reverse.

3. shuffle(List<?> list)
Метод shuffle(List<?> list) случайным образом перемешивает элементы списка. Этот метод полезен для создания случайных выборок данных, например, при разработке игр, тестов или при случайном перемешивании колоды карт.

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

public class ShuffleExample {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>();
        items.add("Apple");
        items.add("Banana");
        items.add("Cherry");

        Collections.shuffle(items);

        System.out.println("Shuffled list: " + items);
    }
}

Вывод может быть таким:

Shuffled list: [Banana, Cherry, Apple]
Метод shuffle перемешивает элементы списка в случайном порядке, так что каждый вызов метода может давать разный результат.

4. binarySearch(List<? extends Comparable<? super T>> list, T key)
Метод binarySearch(List<? extends Comparable<? super T>> list, T key) выполняет двоичный поиск указанного элемента в отсортированном списке. Метод возвращает индекс элемента, если он найден, и отрицательное значение, если элемент отсутствует в списке.

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

public class BinarySearchExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);

        int index = Collections.binarySearch(numbers, 3);

        if (index >= 0) {
            System.out.println("Found at index: " + index);
        } else {
            System.out.println("Not found");
        }
    }
}

Вывод:

Found at index: 2
Этот пример демонстрирует использование двоичного поиска для поиска числа 3 в отсортированном списке чисел.

#Java #Training #Medium #Collections

5. max(Collection<? extends T> coll)
Метод max(Collection<? extends T> coll) находит максимальный элемент в коллекции, используя естественный порядок или заданный компаратор. Этот метод полезен для нахождения наибольшего значения в наборе данных.

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

public class MaxExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(3);
        numbers.add(1);
        numbers.add(4);
        numbers.add(2);

        int maxNumber = Collections.max(numbers);

        System.out.println("Max number: " + maxNumber);
    }
}

Вывод:

Max number: 4
В этом примере метод max находит наибольшее число в списке чисел.

6. min(Collection<? extends T> coll)
Метод min(Collection<? extends T> coll) находит минимальный элемент в коллекции, используя естественный порядок или заданный компаратор. Этот метод часто используется вместе с max для определения диапазона значений в наборе данных.

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

public class MinExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(3);
        numbers.add(1);
        numbers.add(4);
        numbers.add(2);

        int minNumber = Collections.min(numbers);

        System.out.println("Min number: " + minNumber);
    }
}

Вывод:

Min number: 1
Метод min определяет минимальное значение в списке чисел.

7. frequency(Collection<?> c, Object o)
Метод frequency(Collection<?> c, Object o) возвращает количество раз, которое объект o встречается в коллекции c. Этот метод полезен для анализа данных и подсчета количества повторений элемента в коллекции.

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

public class FrequencyExample {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>();
        items.add("Apple");
        items.add("Banana");
        items.add("Apple");
        items.add("Cherry");
        items.add("Apple");

        int appleCount = Collections.frequency(items, "Apple");

        System.out.println("Frequency of 'Apple': " + appleCount);
    }
}

Вывод:

Frequency of 'Apple': 3
Этот пример показывает, как с помощью метода frequency можно подсчитать количество раз, когда слово "Apple" встречается в списке.

8. fill(List<? super T> list, T obj)
Метод fill(List<? super T> list, T obj) заменяет все элементы списка одним и тем же значением. Это полезно, когда требуется инициализировать или сбросить все элементы списка до одного значения.

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

public class FillExample {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>(Collections.nCopies(5, ""));
        Collections.fill(items, "Apple");

        System.out.println("Filled list: " + items);
    }
}

Вывод:

Filled list: [Apple, Apple, Apple, Apple, Apple]
Этот код заменяет все элементы в списке на строку "Apple" с помощью метода fill.

#Java #Training #Medium #Collections