Типы коллекций

На этой странице показаны общие коллекции Scala 3 и сопутствующие им методы. Scala поставляется с большим количеством типов коллекций, на изучение которых может уйти время, поэтому желательно начать с нескольких из них, а затем использовать остальные по мере необходимости. Точно так же у каждого типа коллекции есть десятки методов, облегчающих разработку, поэтому лучше начать изучение лишь с небольшого количества.

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

В конце этого раздела представлены дополнительные ссылки, для более глубокого изучения коллекций.

Три основные категории коллекций

Для коллекций Scala можно выделить три основные категории:

• Последовательности (Sequences/Seq) представляют собой последовательный набор элементов и могут быть индексированными (как массив) или линейными (как связанный список)
• Мапы (Maps) содержат набор пар ключ/значение, например Java Map, Python dictionary или Ruby Hash
• Множества (Sets) — это неупорядоченный набор уникальных элементов

Все они являются базовыми типами и имеют подтипы подходящие под конкретные задачи, таких как параллелизм (concurrency), кэширование (caching) и потоковая передача (streaming). В дополнение к этим трем основным категориям существуют и другие полезные типы коллекций, включая диапазоны (ranges), стеки (stacks) и очереди (queues).

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

В качестве краткого обзора следующие три рисунка показывают иерархию классов и трейтов в коллекциях Scala.

На первом рисунке показаны типы коллекций в пакете scala.collection. Все это высокоуровневые абстрактные классы или трейты, которые обычно имеют неизменяемые и изменяемые реализации.

На этом рисунке показаны все коллекции в пакете scala.collection.immutable:

А на этом рисунке показаны все коллекции в пакете scala.collection.mutable:

В следующих разделах представлены некоторые из распространенных типов.

Общие коллекции

Основные коллекции, используемые чаще всего:

Как показано, Map и Set бывают как изменяемыми, так и неизменяемыми.

Основы каждого типа демонстрируются в следующих разделах.

В Scala буфер (buffer), такой как ArrayBuffer или ListBuffer, представляет собой последовательность, которая может увеличиваться и уменьшаться.

Примечание о неизменяемых коллекциях

В последующих разделах всякий раз, когда используется слово immutable, можно с уверенностью сказать, что тип предназначен для использования в стиле функционального программирования (ФП). С помощью таких типов коллекция не меняется, а при вызове функциональных методов возвращается новый результат - новая коллекция.

Выбор последовательности

При выборе последовательности (последовательной коллекции элементов) нужно руководствоваться двумя основными вопросами:

• должна ли последовательность индексироваться (как массив), обеспечивая быстрый доступ к любому элементу, или она должна быть реализована как линейный связанный список?
• необходима изменяемая или неизменяемая коллекция?

Рекомендуемые универсальные последовательности:

Например, если нужна неизменяемая индексированная коллекция, в общем случае следует использовать Vector. И наоборот, если нужна изменяемая индексированная коллекция, используйте ArrayBuffer.

List и Vector часто используются при написании кода в функциональном стиле. ArrayBuffer обычно используется при написании кода в императивном стиле. ListBuffer используется тогда, когда стили смешиваются, например, при создании списка.

Следующие несколько разделов кратко демонстрируют типы List, Vector и ArrayBuffer.

List

List представляет собой линейную неизменяемую последовательность. Каждый раз, когда в список добавляются или удаляются элементы, по сути создается новый список из существующего.

Создание списка

List можно создать различными способами:

val ints = List(1, 2, 3) val names = List("Joel", "Chris", "Ed") // другой путь создания списка List val namesAgain = "Joel" :: "Chris" :: "Ed" :: Nil 

При желании тип списка можно объявить, хотя обычно в этом нет необходимости:

val ints: List[Int] = List(1, 2, 3) val names: List[String] = List("Joel", "Chris", "Ed") 

Одно исключение — когда в коллекции смешанные типы; в этом случае тип желательно указывать явно:

val things: List[Any] = List(1, "two", 3.0) 

val things: List[String | Int | Double] = List(1, "two", 3.0) // с типами объединения val thingsAny: List[Any] = List(1, "two", 3.0) // с Any 

Добавление элементов в список

Поскольку List неизменяем, в него нельзя добавлять новые элементы. Вместо этого создается новый список с добавленными к существующему списку элементами. Например, учитывая этот List:

val a = List(1, 2, 3) 

Для добавления (prepend) к началу списка одного элемента используется метод ::, для добавления нескольких — :::, как показано здесь:

val b = 0 :: a // List(0, 1, 2, 3) val c = List(-1, 0) ::: a // List(-1, 0, 1, 2, 3) 

Также можно добавить (append) элементы в конец List, но, поскольку List является односвязным, следует добавлять к нему элементы только в начало; добавление элементов в конец списка — относительно медленная операция, особенно при работе с большими последовательностями.

Совет: если необходимо добавлять к неизменяемой последовательности элементы в начало и конец, используйте Vector.

Поскольку List является связанным списком, крайне нежелательно пытаться получить доступ к элементам больших списков по значению их индекса. Например, если есть List с миллионом элементов, доступ к такому элементу, как myList(999_999), займет относительно много времени, потому что этот запрос должен пройти почти через все элементы. Если есть большая коллекция и необходимо получать доступ к элементам по их индексу, то вместо List используйте Vector или ArrayBuffer.

Как запомнить названия методов

В методах Scala символ : представляет сторону, на которой находится последовательность, поэтому, когда используется метод +:, список нужно указывать справа:

0 +: a 

Аналогично, если используется :+, список должен быть слева:

a :+ 4 

Хорошей особенностью таких символических имен у методов является то, что они стандартизированы.

Те же имена методов используются с другими неизменяемыми последовательностями, такими как Seq и Vector. Также можно использовать несимволические имена методов для добавления элементов в начало (a.prepended(4)) или конец (a.appended(4)).

Как пройтись по списку

Представим, что есть List имён:

val names = List("Joel", "Chris", "Ed") 

Напечатать каждое имя можно следующим способом:

for (name <- names) println(name) 

for name <- names do println(name) 

Вот как это выглядит в REPL:

scala> for (name <- names) println(name) Joel Chris Ed 

scala> for name <- names do println(name) Joel Chris Ed 

Преимуществом использования выражений вида for с коллекциями в том, что Scala стандартизирован, и один и тот же подход работает со всеми последовательностями, включая Array, ArrayBuffer, List, Seq, Vector, Map, Set и т.д.

Немного истории

Список Scala подобен списку из языка программирования Lisp, который был впервые представлен в 1958 году. Действительно, в дополнение к привычному способу создания списка:

val ints = List(1, 2, 3) 

точно такой же список можно создать следующим образом:

val list = 1 :: 2 :: 3 :: Nil 

REPL показывает, как это работает:

scala> val list = 1 :: 2 :: 3 :: Nil list: List[Int] = List(1, 2, 3) 

Это работает, потому что List — односвязный список, оканчивающийся элементом Nil, а :: — это метод List, работающий как оператор “cons” в Lisp.

Отступление: LazyList

Коллекции Scala также включают LazyList, который представляет собой ленивый неизменяемый связанный список. Он называется «ленивым» — или нестрогим — потому что вычисляет свои элементы только тогда, когда они необходимы.

Вы можете увидеть отложенное вычисление LazyList в REPL:

val x = LazyList.range(1, Int.MaxValue) x.take(1) // LazyList(<not computed>) x.take(5) // LazyList(<not computed>) x.map(_ + 1) // LazyList(<not computed>) 

Во всех этих примерах ничего не происходит. Действительно, ничего не произойдет, пока вы не заставите это произойти, например, вызвав метод foreach:

scala> x.take(1).foreach(println) 1 

Дополнительные сведения об использовании, преимуществах и недостатках строгих и нестрогих (ленивых) коллекций см. в обсуждениях “строгих” и “нестрогих” на странице Архитектура коллекции в Scala 2.13.

Vector

Vector - это индексируемая неизменяемая последовательность. “Индексируемая” часть описания означает, что она обеспечивает произвольный доступ и обновление за практически постоянное время, поэтому можно быстро получить доступ к элементам Vector по значению их индекса, например, получить доступ к listOfPeople(123_456_789).

В общем, за исключением той разницы, что (а) Vector индексируется, а List - нет, и (б) List имеет метод ::, эти два типа работают одинаково, поэтому мы быстро пробежимся по следующим примерам.

Вот несколько способов создания Vector:

val nums = Vector(1, 2, 3, 4, 5) val strings = Vector("one", "two") case class Person(name: String) val people = Vector( Person("Bert"), Person("Ernie"), Person("Grover") ) 

Поскольку Vector неизменяем, в него нельзя добавить новые элементы. Вместо этого создается новая последовательность, с добавленными к существующему Vector в начало или в конец элементами.

Например, так элементы добавляются в конец:

val a = Vector(1,2,3) // Vector(1, 2, 3) val b = a :+ 4 // Vector(1, 2, 3, 4) val c = a ++ Vector(4, 5) // Vector(1, 2, 3, 4, 5) 

А так - в начало Vector-а:

val a = Vector(1,2,3) // Vector(1, 2, 3) val b = 0 +: a // Vector(0, 1, 2, 3) val c = Vector(-1, 0) ++: a // Vector(-1, 0, 1, 2, 3) 

В дополнение к быстрому произвольному доступу и обновлениям, Vector обеспечивает быстрое добавление в начало и конец.

Подробную информацию о производительности Vector и других коллекций см. в характеристиках производительности коллекций.

Наконец, Vector в выражениях вида for используется точно так же, как List, ArrayBuffer или любая другая последовательность:

scala> val names = Vector("Joel", "Chris", "Ed") val names: Vector[String] = Vector(Joel, Chris, Ed) scala> for (name <- names) println(name) Joel Chris Ed 

scala> val names = Vector("Joel", "Chris", "Ed") val names: Vector[String] = Vector(Joel, Chris, Ed) scala> for name <- names do println(name) Joel Chris Ed 

ArrayBuffer

ArrayBuffer используется тогда, когда нужна изменяемая индексированная последовательность общего назначения. Поскольку ArrayBuffer индексирован, произвольный доступ к элементам выполняется быстро.

Создание ArrayBuffer

Чтобы использовать ArrayBuffer, его нужно вначале импортировать:

import scala.collection.mutable.ArrayBuffer 

Если необходимо начать с пустого ArrayBuffer, просто укажите его тип:

var strings = ArrayBuffer[String]() var ints = ArrayBuffer[Int]() var people = ArrayBuffer[Person]() 

Если известен примерный размер ArrayBuffer, его можно задать:

// готов вместить 100 000 чисел val buf = new ArrayBuffer[Int](100_000) 

Чтобы создать новый ArrayBuffer с начальными элементами, достаточно просто указать начальные элементы, как для List или Vector:

val nums = ArrayBuffer(1, 2, 3) val people = ArrayBuffer( Person("Bert"), Person("Ernie"), Person("Grover") ) 

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

Новые элементы добавляются в ArrayBuffer с помощью методов += и ++=. Также можно использовать текстовый аналог: append, appendAll, insert, insertAll, prepend и prependAll. Вот несколько примеров с += и ++=:

val nums = ArrayBuffer(1, 2, 3) // ArrayBuffer(1, 2, 3) nums += 4 // ArrayBuffer(1, 2, 3, 4) nums ++= List(5, 6) // ArrayBuffer(1, 2, 3, 4, 5, 6) 

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

ArrayBuffer является изменяемым, поэтому у него есть такие методы, как -=, --=, clear, remove и другие. Примеры с -= и --=:

val a = ArrayBuffer.range('a', 'h') // ArrayBuffer(a, b, c, d, e, f, g) a -= 'a' // ArrayBuffer(b, c, d, e, f, g) a --= Seq('b', 'c') // ArrayBuffer(d, e, f, g) a --= Set('d', 'e') // ArrayBuffer(f, g) 

Обновление элементов в ArrayBuffer

Элементы в ArrayBuffer можно обновлять, либо переназначать:

val a = ArrayBuffer.range(1,5) // ArrayBuffer(1, 2, 3, 4) a(2) = 50 // ArrayBuffer(1, 2, 50, 4) a.update(0, 10) // ArrayBuffer(10, 2, 50, 4) 

Maps

Map — это итерируемая коллекция, состоящая из пар ключей и значений. В Scala есть как изменяемые, так и неизменяемые типы Map. В этом разделе показано, как использовать неизменяемый Map.

Создание неизменяемой Map

Неизменяемая Map создается следующим образом:

val states = Map( "AK" -> "Alaska", "AL" -> "Alabama", "AZ" -> "Arizona" ) 

Перемещаться по элементам Map используя выражение for можно следующим образом:

for ((k, v) <- states) println(s"key: $k, value: $v") 

for (k, v) <- states do println(s"key: $k, value: $v") 

REPL показывает, как это работает:

scala> for ((k, v) <- states) println(s"key: $k, value: $v") key: AK, value: Alaska key: AL, value: Alabama key: AZ, value: Arizona 

scala> for (k, v) <- states do println(s"key: $k, value: $v") key: AK, value: Alaska key: AL, value: Alabama key: AZ, value: Arizona 

Доступ к элементам Map

Доступ к элементам Map осуществляется через указание в скобках значения ключа:

val ak = states("AK") // ak: String = Alaska val al = states("AL") // al: String = Alabama 

На практике также используются такие методы, как keys, keySet, keysIterator, for выражения и функции высшего порядка, такие как map, для работы с ключами и значениями Map.

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

При добавлении элементов в неизменяемую мапу с помощью + и ++, создается новая мапа:

val a = Map(1 -> "one") // a: Map(1 -> one) val b = a + (2 -> "two") // b: Map(1 -> one, 2 -> two) val c = b ++ Seq( 3 -> "three", 4 -> "four" ) // c: Map(1 -> one, 2 -> two, 3 -> three, 4 -> four) 

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

Элементы удаляются с помощью методов - или --. В случае неизменяемой Map создается новый экземпляр, который нужно присвоить новой переменной:

val a = Map( 1 -> "one", 2 -> "two", 3 -> "three", 4 -> "four" ) val b = a - 4 // b: Map(1 -> one, 2 -> two, 3 -> three) val c = a - 4 - 3 // c: Map(1 -> one, 2 -> two) 

Обновление элементов в Map

Чтобы обновить элементы на неизменяемой Map, используется метод update (или оператор +):

val a = Map( 1 -> "one", 2 -> "two", 3 -> "three" ) val b = a.updated(3, "THREE!") // b: Map(1 -> one, 2 -> two, 3 -> THREE!) val c = a + (2 -> "TWO...") // c: Map(1 -> one, 2 -> TWO..., 3 -> three) 

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

Элементы в Map можно перебрать с помощью выражения for, как и для остальных коллекций:

val states = Map( "AK" -> "Alaska", "AL" -> "Alabama", "AZ" -> "Arizona" ) for ((k, v) <- states) println(s"key: $k, value: $v") 

val states = Map( "AK" -> "Alaska", "AL" -> "Alabama", "AZ" -> "Arizona" ) for (k, v) <- states do println(s"key: $k, value: $v") 

Существует много способов работы с ключами и значениями на Map. Общие методы Map включают foreach, map, keys и values.

В Scala есть много других специализированных типов Map, включая CollisionProofHashMap, HashMap, LinkedHashMap, ListMap, SortedMap, TreeMap, WeakHashMap и другие.

Работа с множествами

Множество (Set) - итерируемая коллекция без повторяющихся элементов.

В Scala есть как изменяемые, так и неизменяемые типы Set. В этом разделе демонстрируется неизменяемое множество.

Создание множества

Создание нового пустого множества:

val nums = Set[Int]() val letters = Set[Char]() 

Создание множества с исходными данными:

val nums = Set(1, 2, 3, 3, 3) // Set(1, 2, 3) val letters = Set('a', 'b', 'c', 'c') // Set('a', 'b', 'c') 

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

В неизменяемое множество новые элементы добавляются с помощью + и ++, результат присваивается новой переменной:

val a = Set(1, 2) // Set(1, 2) val b = a + 3 // Set(1, 2, 3) val c = b ++ Seq(4, 1, 5, 5) // HashSet(5, 1, 2, 3, 4) 

Стоит отметить, что повторяющиеся элементы не добавляются в множество, а также, что порядок элементов произвольный.

Удаление элементов из множества

Элементы из множества удаляются с помощью методов - и --, результат также должен присваиваться новой переменной:

val a = Set(1, 2, 3, 4, 5) // HashSet(5, 1, 2, 3, 4) val b = a - 5 // HashSet(1, 2, 3, 4) val c = b -- Seq(3, 4) // HashSet(1, 2) 

Диапазон (Range)

Range часто используется для заполнения структур данных и для for выражений. Эти REPL примеры демонстрируют, как создавать диапазоны:

1 to 5 // Range(1, 2, 3, 4, 5) 1 until 5 // Range(1, 2, 3, 4) 1 to 10 by 2 // Range(1, 3, 5, 7, 9) 'a' to 'c' // NumericRange(a, b, c) 

Range можно использовать для заполнения коллекций:

val x = (1 to 5).toList // List(1, 2, 3, 4, 5) val x = (1 to 5).toBuffer // ArrayBuffer(1, 2, 3, 4, 5) 

Они также используются в for выражениях:

scala> for (i <- 1 to 3) println(i) 1 2 3 

scala> for i <- 1 to 3 do println(i) 1 2 3 

Во многих коллекциях есть метод range:

Vector.range(1, 5) // Vector(1, 2, 3, 4) List.range(1, 10, 2) // List(1, 3, 5, 7, 9) Set.range(1, 10) // HashSet(5, 1, 6, 9, 2, 7, 3, 8, 4) 

Диапазоны также полезны для создания тестовых коллекций:

val evens = (0 to 10 by 2).toList // List(0, 2, 4, 6, 8, 10) val odds = (1 to 10 by 2).toList // List(1, 3, 5, 7, 9) val doubles = (1 to 5).map(_ * 2.0) // Vector(2.0, 4.0, 6.0, 8.0, 10.0) // Создание Map val map = (1 to 3).map(e => (e,s"$e")).toMap // map: Map[Int, String] = Map(1 -> "1", 2 -> "2", 3 -> "3") 

Больше деталей

Если вам нужна дополнительная информация о специализированных коллекциях, см. следующие ресурсы:

• Конкретные неизменяемые классы коллекций
• Конкретные изменяемые классы коллекций
• Как устроены коллекции? Какую из них следует выбрать?