Коллекции

Коллекции в 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

Коллекции в Java

Глава 1. Введение в коллекции

Обзор Java Collections Framework. Интерфейсы Collection и Map. Иерархия коллекций. Отличия коллекций от массивов

Java Collections Framework (JCF) — это набор интерфейсов, классов и алгоритмов в пакете java.util, предназначенный для работы с коллекциями данных. JCF предоставляет унифицированный способ хранения и манипуляции объектами, делая код более гибким и эффективным.

- Компоненты JCF:
- Интерфейсы: Определяют контракт (что можно делать с коллекцией).
- Реализации: Конкретные классы, реализующие интерфейсы (например, ArrayList для List).
- Алгоритмы: Встроенные методы для сортировки, поиска и т.д. (в классе Collections).

JCF введен в Java 1.2 и значительно улучшен в Java 5 с generics (обобщениями), которые обеспечивают типобезопасность.

- Преимущества JCF:
- Гибкость: Динамический размер, в отличие от массивов.
- Типобезопасность: С generics — компилятор проверяет типы.
- Эффективность: Разные реализации для разных сценариев (быстрый доступ, уникальность элементов и т.д.).
- Полиморфизм: Работа через интерфейсы, легко менять реализации.


Интерфейсы Collection и Map

JCF построен вокруг двух основных интерфейсов: Collection для последовательностей объектов и Map для пар ключ-значение.

1. Интерфейс Collection<E>:
- Это базовый интерфейс для коллекций, где E — тип элементов (generics).
- Представляет группу объектов, позволяя добавлять, удалять, перебирать.
- Не гарантирует порядок или уникальность — зависит от реализации.

- Основные методы:
- add(E e): Добавляет элемент.
- remove(Object o): Удаляет элемент.
- size(): Возвращает размер.
- isEmpty(): Проверяет пустоту.
- iterator(): Для перебора (Iterator).
- contains(Object o): Проверяет наличие.

- Нюанс: Collection не индексирован (нет get(int index)), для этого — подинтерфейсы как List.

2. Интерфейс Map<K, V>:
- Представляет отображение: пары ключ-значение, где K — тип ключа, V — тип значения.
- Ключи уникальны, значения могут дублироваться.
- Не является подтипом Collection (Map не коллекция элементов, а ассоциация).

- Основные методы:
- put(K key, V value): Добавляет/обновляет пару.
- get(Object key): Возвращает значение по ключу.
- remove(Object key): Удаляет по ключу.
- size(), isEmpty().
- keySet(): Коллекция ключей (Set<K>).
- values(): Коллекция значений (Collection<V>).
- entrySet(): Коллекция пар (Set<Map.Entry<K, V>>).

- Нюанс: Map не упорядочен (кроме SortedMap), ключи не null (в большинстве реализаций).


#Java #для_новичков #beginner #Collections #Map

Иерархия коллекций в JCF

JCF имеет иерархию интерфейсов и реализаций. Вот подробная структура:

1. Иерархия Collection:

- Collection<E> (базовый):
- List<E>: Упорядоченная коллекция, позволяет дубликаты, индексация.
- Реализации: ArrayList (быстрый доступ), LinkedList (быстрые вставки/удаления), Vector (устаревший, synchronized).
- Set<E>: Неупорядоченная коллекция уникальных элементов.
- Реализации: HashSet (быстрый поиск), TreeSet (отсортированный), LinkedHashSet (сохраняет порядок вставки).
- Queue<E>: Для очередей (FIFO), или приоритетных.
- Реализации: LinkedList (как Queue), PriorityQueue (приоритетная), ArrayDeque (deque).
- Deque<E>: Двусторонняя очередь (добавление/удаление с обоих концов).
- Реализации: ArrayDeque, LinkedList.

2. Иерархия Map:

- Map<K, V> (базовый):
- HashMap<K, V>: Быстрый поиск по хэшу, не упорядочен.
- TreeMap<K, V>: Отсортированный по ключам (SortedMap).
- LinkedHashMap<K, V>: Сохраняет порядок вставки.
- Hashtable<K, V>: Устаревший, synchronized.

- Generics: С Java 5: Collection<String> list = new ArrayList<>(); — типобезопасно.

- Нюансы иерархии:
- Все реализации — concrete классы, кроме абстрактных helper-классов (AbstractList).
- Synchronized: Для многопоточности используйте Collections.synchronized*() или Concurrent* классы (ConcurrentHashMap).
- Performance: Выбирайте по нуждам — HashSet O(1) поиск, TreeSet O(log n) с сортировкой.
- Immutability: Collections.unmodifiable*() для read-only коллекций.


Отличия коллекций от массивов

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

- Подробное сравнение:
1. Размер:
- Массивы: Фиксированный (int[] arr = new int[10]; — нельзя изменить).
- Коллекции: Динамический (ArrayList.add() расширяет автоматически).

2. Типы элементов:
- Массивы: Могут хранить примитивы (int[]) или объекты.
- Коллекции: Только объекты (Collection<Integer> для примитивов через wrapper).

3. Методы:
- Массивы: Ограничены (длина .length, доступ по индексу).
- Коллекции: Богатый API (add, remove, contains, sort, iterator).

4. Generics:
- Массивы: Нет (Object[] может хранить всё, но без проверки).
- Коллекции: С generics — типобезопасно (компилятор проверяет).

5. Performance:
- Массивы: Быстрее для фиксированного размера и примитивов.
- Коллекции: Overhead, но удобнее; ArrayList близок к массиву.

6. Многомерность:
- Массивы: Легко (int[][]).
- Коллекции: Вложенные (List<List<Integer>>).

7. Null и дубликаты:
- Оба позволяют, но Set в коллекциях запрещает дубликаты.

Пример перехода от массива к коллекции:

Массив:

String[] names = new String[3];
names[0] = "Алексей";
// Нет add, нужно вручную управлять размером

Коллекция:

List<String> names = new ArrayList<>();
names.add("Алексей");  // Динамично
names.remove(0);       // Легко удалить

- Нюанс: Коллекции используют массивы внутри (ArrayList — resizable array).


Как работать с JCF в IntelliJ IDEA

1. Импорт: Импортируйте java.util.* или конкретно (IDE подскажет Ctrl+Space).
2. Generics: Напишите List<String> — IDE проверит типы.
3. Коллекции: New → Collection → Выберите реализацию.
4. Методы: Автодополнение для add, remove и т.д.
5. Debug: В отладке смотрите содержимое коллекций.


Полезные советы для новичков

- Выбирайте интерфейс: Кодьте под List, а не ArrayList — легко сменить реализацию.
- Generics всегда: Избегайте raw types (List без <E> — устарело).
- Коллекции vs массивы: Массивы для фиксированных примитивов, коллекции для всего остального.
- Performance: ArrayList для доступа, LinkedList для вставок, HashSet для уникальности.


#Java #для_новичков #beginner #Collections #Map

Коллекции в Java

Глава 1. Введение в коллекции

Основные характеристики коллекций: время доступа (Big O), хранение уникальных элементов, упорядоченность и сортировка

Big O (или O-нотация) — это математическая нотация, которая описывает, как растет время выполнения операции (или использование памяти) в зависимости от размера данных (n — количество элементов). Она оценивает "наихудший случай" и помогает сравнивать эффективность коллекций.

Основные обозначения Big O:
- O(1): Постоянное время — операция не зависит от размера (например, доступ по индексу в массиве).
- O(log n): Логарифмическое время — быстро растет, но эффективно (например, поиск в отсортированном дереве).
- O(n): Линейное время — пропорционально размеру (например, перебор списка).
- O(n log n): Для сортировки (например, TreeSet).
- O(n²): Квадратичное — медленно для больших n (избегайте).

Для коллекций Big O применяется к основным операциям: добавление (add), удаление (remove), поиск (contains/get), вставка.

Почему важно: Выбор коллекции влияет на производительность. Для миллионов элементов O(1) лучше O(n).


Хранение уникальных элементов

Коллекции различаются по тому, позволяют ли они дубликаты элементов.

Коллекции с уникальными элементами:
- Интерфейс Set<E>: Не позволяет дубликаты. Если добавить существующий элемент, он игнорируется (add() возвращает false).
- Пример: HashSet, TreeSet, LinkedHashSet.
- Нюанс: Уникальность определяется методом equals() и hashCode() (для HashSet). Переопределите их для custom классов.

Коллекции с дубликатами:
- Интерфейс List<E>: Позволяет дубликаты и хранит их в порядке вставки.
- Пример: ArrayList, LinkedList.
- Queue<E> и Deque<E>: Могут позволять дубликаты, в зависимости от реализации.

- Map<K, V>: Ключи уникальны (как Set), значения могут дублироваться.

Пример кода для уникальности:

import java.util.HashSet;
import java.util.Set;
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // Set: Уникальные элементы
        Set<String> uniqueNames = new HashSet<>();
        uniqueNames.add("Алексей");
        uniqueNames.add("Алексей");  // Игнорируется
        System.out.println(uniqueNames.size());  // 1

        // List: Дубликаты разрешены
        List<String> names = new ArrayList<>();
        names.add("Алексей");
        names.add("Алексей");
        System.out.println(names.size());  // 2
    }
}

- Нюанс: Для custom объектов в Set переопределите equals() и hashCode(), иначе дубликаты возможны (сравнение по ссылке).

#Java #для_новичков #beginner #Collections #BigO

Упорядоченность элементов

Упорядоченность — это сохранение порядка элементов (по вставке или сортировке).

Коллекции с порядком вставки:
- List<E>: Всегда упорядочены по индексу (порядок добавления).
- Пример: ArrayList, LinkedList.
- LinkedHashSet<E>: Set с порядком вставки.
- LinkedHashMap<K, V>: Map с порядком вставки.

Коллекции без порядка:
- HashSet<E>: Не гарантирует порядок (зависит от хэша).
- HashMap<K, V>: Не упорядочен.

Отсортированные коллекции: Подробнее в разделе о сортировке.

Пример:

import java.util.HashSet;
import java.util.LinkedHashSet;

public class Main {
    public static void main(String[] args) {
        // HashSet: Без порядка
        Set<String> hashSet = new HashSet<>();
        hashSet.add("Яблоко");
        hashSet.add("Банан");
        hashSet.add("Апельсин");
        System.out.println(hashSet);  // Может быть [Банан, Яблоко, Апельсин] — непредсказуемо

        // LinkedHashSet: Порядок вставки
        Set<String> linkedSet = new LinkedHashSet<>();
        linkedSet.add("Яблоко");
        linkedSet.add("Банан");
        linkedSet.add("Апельсин");
        System.out.println(linkedSet);  // [Яблоко, Банан, Апельсин] — сохраняет порядок
    }
}

- Нюанс: Порядок в HashSet может меняться при ресайзе (rehashing), так что не полагайтесь на него.


Сортировка элементов

Сортировка — это автоматическое упорядочивание элементов по какому-то критерию (натуральный порядок или Comparator).

Отсортированные коллекции:
- SortedSet<E> (подинтерфейс Set): Уникальные, отсортированные элементы.
- Реализация: TreeSet<E> — использует красно-черное дерево.
- SortedMap<K, V> (подинтерфейс Map): Отсортированные ключи.
- Реализация: TreeMap<K, V>.

Как работает сортировка:
- Элементы должны быть Comparable<E> (метод compareTo()) для натурального порядка (числа по возрастанию, строки по алфавиту).
- Или используйте Comparator при создании: new TreeSet<>(comparator).
- Нюанс: Добавление/поиск — O(log n), так как дерево балансировано.

Пример TreeSet:

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

public class Main {
    public static void main(String[] args) {
        Set<Integer> numbers = new TreeSet<>();
        numbers.add(5);
        numbers.add(1);
        numbers.add(3);
        System.out.println(numbers);  // [1, 3, 5] — отсортировано

        // Custom Comparator для обратного порядка
        Set<Integer> reverseNumbers = new TreeSet<>((a, b) -> b - a);
        reverseNumbers.add(5);
        reverseNumbers.add(1);
        reverseNumbers.add(3);
        System.out.println(reverseNumbers);  // [5, 3, 1]
    }
}

- Нюанс: TreeSet не позволяет null (NullPointerException), так как сравнивает элементы.
Для сортировки существующих коллекций используйте Collections.sort(List list) или List.sort(Comparator).


Полезные советы для новичков

- Big O в практике: Для малого n (сотни элементов) разница мала, но для миллионов — критична (выберите HashSet для быстрого contains).
- Уникальность: Set для словарей, List для списков с повторами.
- Упорядоченность: Linked* для сохранения вставки, Tree* для автосортировки.
- Сортировка: TreeSet/Map для постоянной сортировки; Collections.sort() для разовой.
- Ошибки: Null в TreeSet — NPE; дубли в Set — игнор.
- Ресурсы: Java API docs для java.util.


#Java #для_новичков #beginner #Collections #BigO

Раздел 6. Коллекции в Java

Глава 1. Введение в коллекции

(Практика):
Начать проект «Библиотека».
Создать класс Book с полями title, author, year.
Сделать список книг (пока как массив) и вывести их на экран

Перед тем, как писать код, важно правильно настроить среду разработки. Это обеспечит удобную работу и избежание ошибок на старте.

Запустите IntelliJ IDEA:
Если IDE не открыта, запустите её. Убедитесь, что у вас установлен JDK. Если проект новый, выберите "New Project" на приветственном экране.

Создайте новый проект:
В окне создания проекта выберите "Java" как тип.
Укажите имя проекта, например, "LibraryProject".
Выберите JDK в поле Project SDK (если не настроено, добавьте путь к JDK).
Оставьте остальные настройки по умолчанию (без Maven или Gradle для простоты) и нажмите "Create".
IDE создаст структуру проекта с папкой src для исходного кода.

Настройте структуру проекта:
В дереве проекта (слева) найдите src.
Если нужно, создайте пакет для организации кода: Правой кнопкой на src → New → Package → Назовите "library" (или другое имя). Это хорошая практика для группировки классов.

Создание класса Book
Теперь создадим основной класс для представления книги. Это будет простой класс с полями, который позже расширим.

Создайте класс Book:
В пакете (или прямо в src, если без пакета) щелкните правой кнопкой → New → Java Class.
Назовите класс "Book".
IDE создаст файл Book.java с базовой структурой

public class Book {}

Добавьте поля:
В теле класса объявите три приватных поля:
title типа String (для названия книги).
author типа String (для автора).
year типа int (для года издания).

Используйте модификатор private для инкапсуляции, как мы изучали в ООП.

Добавьте конструктор:
Создайте публичный конструктор, который принимает три параметра (String title, String author, int year) и присваивает их соответствующим полям с помощью this.
Это позволит создавать объекты Book с начальными значениями.

Добавьте метод для вывода:
Создайте публичный метод, например, printDetails(), который выводит информацию о книге на экран с помощью System.out.println.
В нём используйте поля для формирования строки вроде "Название: [title], Автор: [author], Год: [year]".


Создание списка книг с использованием массива

Пока мы используем массив как простую структуру для хранения списка книг — это поможет сравнить с коллекциями позже.

Создайте класс Main:
Аналогично создайте новый класс "Main" в том же пакете.
Добавьте статический метод main(String[] args) — точку входа.

Объявите массив:
В методе main объявите массив объектов Book фиксированного размера, например, Book[] books = new Book[3]; (размер выберите небольшой для теста).

Инициализируйте массив:
Создайте несколько объектов Book с помощью new Book(title, author, year) и присвойте их элементам массива (books[0] = new Book(...); и т.д.).
Используйте разные значения для демонстрации (например, книги разных авторов и годов).

Выведите список на экран:
Используйте цикл for (или for-each: for (Book book : books)) для перебора массива.
В цикле вызовите метод printDetails() для каждого элемента, чтобы вывести информацию о книгах.

#Java #для_новичков #beginner #Collections #Практика

Тестирование и отладка проекта

После реализации протестируйте проект, чтобы убедиться, что всё работает.

Запустите проект:
Правой кнопкой на файле Main.java → Run 'Main.main()'.
В консоли IDE вы должны увидеть вывод списка книг с их деталями.

Отладка:
Если ошибки: Проверьте синтаксис (точки с запятой, скобки).
Используйте отладчик: Установите breakpoint (красная точка слева от строки в main), запустите в debug-режиме (Shift+F9) и шагайте по коду (F8).
Общие проблемы: NullPointerException (если массив не инициализирован), IndexOutOfBoundsException (если выход за пределы массива).

Проверьте вывод:
Убедитесь, что книги выводятся в порядке добавления в массив.
Попробуйте изменить размер массива или добавить больше книг — увидите, как фиксированный размер ограничивает (это мотивирует к коллекциям позже).


Полезные советы для новичков

Организация кода: Используйте пакеты для группировки (например, library.models для Book).
Инкапсуляция: Даже в простом проекте делайте поля private и добавьте геттеры/сеттеры, если нужно изменять.
Массивы vs коллекции: Заметьте ограничения массива (фиксированный размер, ручное управление) — в следующих уроках заменим на ArrayList.
Комментарии: Добавляйте // комментарии к шагам, чтобы код был читаемым.
Версионирование: Если используете Git, создайте репозиторий и закоммитьте начальную версию проекта.
Ресурсы: Документация Oracle по классам и массивам для напоминания синтаксиса.


Практическое задание

Задача 1: Расширьте класс Book, добавив приватное поле isbn (String) и обновите конструктор и метод printDetails() для его включения.
Задача 2: Увеличьте массив до 5 элементов, добавьте больше книг и убедитесь, что вывод работает.
Задача 3: Попробуйте вывести только книги после определенного года — используйте if в цикле перебора массива.

Реализуйте эти задачи самостоятельно, следуя шагам урока. Это поможет закрепить основы перед переходом к коллекциям.

#Java #для_новичков #beginner #Collections #Практика