Кофе-брейк #185. Подробное руководство по Java Collection Framework

Источник: Medium Данное руководство поможет вам лучше изучить работу различных классов и интерфейсов, входящих в Java Collection Framework. Java Collection — это фреймворк, который обеспечивает унифицированную архитектуру для хранения и управления группой объектов. По своей сути, это набор классов и интерфейсов, которые обеспечивают стандартный способ представления коллекций объектов и управления ими на языке Java. Также фреймворк помогает в реализации часто используемых структур данных, таких как List, Set и Map. Java Collection Framework включает несколько интерфейсов и классов. Вот список некоторых из них:

Интерфейсы

Интерфейсы в Java Collection Framework определяют общее поведение и операции, которые могут выполняться с коллекциями. Сюда входят добавление или удаление элементов, повторение элементов в коллекции и многое другое.

• Collection: корневой (root) интерфейс в иерархии коллекций, представляющий группу объектов, известных как элементы.
• List: упорядоченная коллекция элементов, допускающая дублирование.
• Set: коллекция элементов, не допускающих дублирования.
• Map: коллекция пар ключ-значение (key-value), где каждый ключ уникален.
• Queue: очередь — это структура данных, которая используется для хранения элементов в порядке появления (First-In-First-Out, FIFO).

В этот список вошли далеко не все, а только наиболее используемые интерфейсы в Java Collection Framework. Теперь давайте подробно рассмотрим каждый их них.

Collection

Коллекция (Collection) представляет собой группу объектов, известных как ее элементы. Это объект, который может содержать ссылки на другие объекты. Интерфейс Collection является корнем иерархии коллекций. Это базовый интерфейс для всех коллекций в Java Collection Framework. Он определяет основные методы, которые должны быть реализованы во всех коллекциях, такие как add(), remove() и contains(). Вот пример использования коллекций в Java Collection Framework. Здесь интерфейс Collection применяется для добавления и удаления элементов из коллекции:

import java.util.Collection;
import java.util.ArrayList;

public class CollectionExample {
    public static void main(String[] args) {
        // Создаем новую коллекцию
        Collection<String> stringCollection = new ArrayList<>();
        
        // Добавляем несколько элементов в коллекцию
        stringCollection.add("hello");
        stringCollection.add("world");
        stringCollection.add("foo");
        stringCollection.add("bar");
        
        // Печатаем число элементов в коллекции
        System.out.println("Number of elements: " + stringCollection.size());
        
        // Удаляем элемент из коллекции
        stringCollection.remove("foo");
        
        // Опять печатаем число элементов в коллекции
        System.out.println("Number of elements: " + stringCollection.size());
    }
}

На выводе получаем: Как видите, интерфейс Collection представляет собой простой и удобный способ выполнения стандартных операций с коллекцией объектов. Он часто используется в качестве отправной точки при работе с коллекциями в Java. Java Collection Framework включает в себя несколько интерфейсов, которые определяют общее поведение для разных типов коллекций. Некоторые из них входят в группу интерфейсов java.util.Collection:

• java.util.List
• java.util.set
• java.util.Queue

java.util.List

List (список) — это упорядоченный набор объектов, каждый элемент которого занимает определенную позицию в списке. Интерфейс List расширяет интерфейс Collection и добавляет в него несколько методов для работы со списками, таких как методы доступа к элементам по их положению в списке и методы поиска и сортировки списков. List может содержать повторяющиеся элементы, доступ к этим элементам можно получить по их положению в списке. Вот пример использования интерфейса List для добавления, удаления и доступа к элементам в списке:

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

public class ListExample {
    public static void main(String[] args) {
        // Создаем новый список
        List<String> stringList = new ArrayList<>();
        
        // Добавляем несколько элементов в список
        stringList.add("India");
        stringList.add("UAE");
        stringList.add("London");
        stringList.add("US");
        
        // Печатаем первый элемент в списке
        System.out.println("First element: " + stringList.get(0));
        
        // Удаляем второй элемент из списка 
        stringList.remove(1);
        
        // Печатаем второй элемент в списке
        System.out.println("Second element: " + stringList.get(1));
    }
}

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

java.util.Set

Set в Java Collection Framework — это неупорядоченное множество уникальных элементов, в котором не допускаются повторяющиеся элементы. Интерфейс Set расширяет интерфейс Collection и добавляет в него несколько методов, таких как методы проверки наличия элемента в множестве (set) и методы добавления и удаления элементов из множества. Вот пример использования интерфейса Set для добавления и удаления элементов из множества в Java Collection Framework:

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

public class SetExample {
    public static void main(String[] args) {
        // Создаем новый set
        Set<String> stringSet = new HashSet<>();
        
        // Добавляем несколько элементов в set
        stringSet.add("Jan");
        stringSet.add("Feb");
        stringSet.add("March");
        stringSet.add("April");
        
        // Проверяем наличие в set элемента "March"
        if (stringSet.contains("March")) {
            System.out.println("The set contains the element 'March'");
        }
        
        // Удаляем элемент "April" из set
        stringSet.remove("April");
        
        // Опять проверяем наличие элемента "April" в set 
        if (!stringSet.contains("April")) {
            System.out.println("The set no longer contains the element 'April'");
        }
    }
}

Вывод:

java.util.Queue

Queue (очередь) — это структура данных, которая используется для хранения элементов в порядке их появления (FIFO). Это означает, что первый элемент, добавленный в очередь, будет первым удаленным. Вот пример того, как использовать очередь в Java Collection Framework:

// Создание очереди
Queue<String> queue = new LinkedList<>();

// Добавление элементов в очередь
queue.add("apple");
queue.add("banana");
queue.add("orange");
// Печатаем очередь
System.out.println("Queue: " + queue);
// Удаляем элемент из очереди
String element = queue.remove();
System.out.println("Removed element: " + element);
// Печатаем обновленную очередь
System.out.println("Queue: " + queue);

В данном примере мы создали очередь строк и добавили в нее три элемента: “apple”, “banana” и “orange”. Затем мы печатаем очередь, чтобы увидеть ее текущее состояние. Далее мы удаляем элемент из очереди и выводим его на консоль. Наконец, мы печатаем обновленную очередь, чтобы убедиться, что удаленный элемент больше не находится в очереди.

Map

Интерфейс java.util.Map в Java Collection Framework используется для сопоставления ключей со значениями. Он позволяет хранить элементы в виде пар ключ-значение и предоставляет методы для доступа, изменения и повторения элементов на карте. Ниже приведен пример использования интерфейса Map:

// Создаем Map
 Map<String, Integer> map = new  HashMap <>(); 
// Добавляем элементы в Map
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);
// Печать Map
 System.out.println("Map: " + map);
// Получаем значение для определенного ключа 
int  value  = map.get( "banana" ); 
System.out.println("Value for 'banana': " + value);
// Удаляем элемент из Map
map.remove("orange"); 
// Печать обновленной карты
 System.out.println( "Map: " + map);

В этом примере мы создаем карту (map) строк и целых чисел, добавляя к ней три элемента: “apple” сопоставляется с 1, “banana” сопоставляется с 2 и “orange” сопоставляется с 3. Затем мы печатаем карту, чтобы увидеть ее текущее значение. После этого мы получаем значение ключа “banana” и выводим его на консоль. Наконец, мы удаляем пару ключ-значение для “orange” с карты и печатаем обновленную карту, чтобы увидеть, что удаленного элемента больше на ней нет.

Classes

Класс (Class) — это конкретная реализация интерфейса коллекции. Он предоставляет конкретные реализации общего поведения и операций, определенных интерфейсами во фреймворке.

• ArrayList: реализация интерфейса List с изменяемым размером массива.
• LinkedList: двусвязный список, реализация интерфейсов List и Deque.
• HashSet: реализация Set, использующая хеш-таблицу для хранения.
• TreeSet: реализация Set, использующая дерево для хранения.
• HashMap: реализация Map, использующая хеш-таблицу для хранения.

Приведенный выше список является одним из наиболее часто используемых классов в Java Collection Framework. Теперь давайте рассмотрим подробное объяснение этих классов.

ArrayList

Класс java.util.ArrayList в коллекциях Java используется для хранения изменяемого размера массива элементов в списке. Это широко используемая реализация интерфейса java.util.List, которая использует массив для хранения элементов и предоставляет эффективные методы для доступа, изменения и повторения элементов в списке. Класс java.util.ArrayList обеспечивает быстрый произвольный доступ к своим элементам, но медленную вставку и удаление в произвольных позициях. Ниже приведен пример использования класса ArrayList в Java Collection Framework:

// Создаем array list
List<String> list = new ArrayList<>();
// Добавляем элементы в array list
list.add("qa");
list.add("devops");
list.add("dev");
// Печатаем array list
System.out.println("Array list: " + list);
// Доступ к элементу по определенному индексу 
String element = list.get(1);
System.out.println("Element at index 1: " + element);
// Удаление элемента из the array list
list.remove(1);
// Print the updated array list
System.out.println("Array list: " + list);

Как видите, мы создали массив строк и добавили в него три элемента: “qa”, “devops” и “dev”. Затем мы напечатали список массивов, чтобы увидеть его текущее состояние. После этого мы получаем доступ к элементу с индексом 1 и выводим его на консоль. Наконец, мы удаляем элемент с индексом 1 из списка массивов и печатаем обновленный список массивов, чтобы убедиться, что удаленного элемента больше нет в списке.

LinkedList

Класс java.util.LinkedList в Java Collection Framework наследует класс AbstractList и реализует интерфейсы List и Deque. Он предоставляет эффективные методы для добавления, удаления и доступа к элементам в начале и конце списка. Также этот Класс является реализацией интерфейса List, в которой для хранения элементов используется двусвязный список (doubly-linked list). Он обеспечивает быструю вставку и удаление в произвольных позициях, но медленный произвольный доступ к своим элементам. Вот пример того, как использовать класс LinkedList в Java Collection Framework:

// Создаем linked list
List<String> list = new LinkedList<>();
// Добавляем элементы в linked list
list.add("selenium");
list.add("cypress");
list.add("playwright");
// Печатаем linked list
System.out.println("Linked list: " + list);
// Добавляем элемент в начало списка 
list.add(0, "webdriver.io");
// Печатаем обновленный linked list
System.out.println("Linked list: " + list);
// Удаляем первый элемент в списке
list.remove(0);
// Еще раз печатаем обновленный linked list
System.out.println("Linked list: " + list);

В данном примере мы создали связанный список (linked list) строк и добавили в него три элемента: “selenium”, “cypress” и “playwright”. Затем мы печатаем связанный список, чтобы увидеть его текущее состояние. Далее мы добавляем элемент “webdriver.io” в начало списка и печатаем обновленный связанный список. Наконец, мы удаляем первый элемент из списка и опять печатаем обновленный связанный список, чтобы увидеть, что удаленного элемента больше нет в списке.

HashSet

Класс java.util.HashSet в Java Collection Framework используется для хранения коллекции уникальных элементов в set (наборе, можестве). Он обеспечивает реализацию интерфейса java.util.Set на основе хэш-таблицы. Также он обеспечивает быструю вставку, удаление и поиск, но не сохраняет порядок своих элементов. Ниже приведен пример использования класса HashSet в Java Collection Framework:

// Создаем hash set
Set<String> set = new HashSet<>();

// Добавляем элементы в hash set
set.add("rose");
set.add("lily");
set.add("lotus");
// Попытка добавить повторяющийся элемент
set.add("rose");
// Печатаем hash set
System.out.println("Hash set: " + set);
// Удаляем элемент из hash set
set.remove("lily");
// Печать обновленного hash set
System.out.println("Hash set: " + set);

Здесь мы создали хеш-набор (hash set) строк и добавили к нему три элемента: “rose”, “lily” и “lotus”. Затем мы снова пытаемся добавить элемент “rose”, но поскольку набор хэшей не допускает дублирования, он не будет добавлен. После этого мы печатаем hash set, чтобы увидеть его текущее состояние. Затем мы удаляем элемент “lily” из set и печатаем обновленный hash set, чтобы увидеть, что удаленного элемента больше нет в set.

TreeSet

Класс java.util.TreeSet в Java Collection Framework используется для хранения коллекции уникальных элементов в множестве (set), отсортированном в порядке возрастания. Он обеспечивает древовидную реализацию интерфейса java.util.Set, для хранения элементов, не допуская дублирования элементов. Класс обеспечивает быструю вставку, удаление и поиск и поддерживает порядок своих элементов в соответствии с их естественным порядком или компаратором. Вот пример того, как использовать класс TreeSet в Java Collection Framework:

// Создаем tree set
Set<String> set = new TreeSet<>();

// Добавляем элементы в tree set
set.add("apple");
set.add("banana");
set.add("orange");
// Попытка добавить повторяющийся элемент
set.add("apple");
// Печатаем tree set
System.out.println("Tree set: " + set);
// Удаляем элемент из tree set
set.remove("banana");
// Печатаем обновленный tree set
System.out.println("Tree set: " + set);

В этом примере мы создаем древовидный набор строк и добавляем к нему три элемента: “apple”, “banana” и “orange”. Затем мы снова пытаемся добавить элемент “apple”, но поскольку tree set не допускает дублирования, он не будет добавлен. После этого мы печатаем tree set, чтобы увидеть его текущее состояние. Поскольку tree set отсортирован в порядке возрастания, элементы будут напечатаны в порядке: “apple”, “banana” и “orange”. Затем мы удаляем элемент “banana” из набора и печатаем обновленный tree set, чтобы увидеть, что удаленного элемента больше нет в наборе.

HashMap

Класс java.util.HashMap в Java Collection Framework используется для хранения сопоставления ключей со значениями на карте. Он обеспечивает реализацию интерфейса java.util.Map на основе хеш-таблицы и позволяет хранить элементы в виде пар ключ-значение. Класс обеспечивает быструю вставку, удаление и поиск, но не сохраняет порядок своих элементов. Вот пример того, как использовать класс HashMap в Java Collection Framework:

// Создаем hash map
Map<String, Integer> map = new HashMap<>();

// Добавляем элементы в hash map
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);
// Печатаем hash map
System.out.println("Hash map: " + map);
// Получаем значение для определенного ключа 
int value = map.get("banana");
System.out.println("Value for 'banana': " + value);
// Удаляем элемент из hash map
map.remove("orange");
// Печатаем обновленный hash map
System.out.println("Hash map: " + map);

В данном примере мы создаем хэш-карту строк с целыми числами и добавляем к ней три элемента: “apple” сопоставляется с 1, “banana” сопоставляется с 2 и “orange” сопоставляется с 3. Затем мы печатаем хэш-карту, чтобы увидеть его текущее состояние. После этого мы получаем значение ключа “banana” и выводим его на консоль. Наконец, мы удаляем пару ключ-значение для “orange” из хэш-карты и печатаем обновленную хэш-карту, чтобы увидеть, что удаленного элемента в ней больше нет.

Заключение

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