Класс scala.collection.immutable.HashMap.HashTrieMap

Тестирование двух объектов на неравенство.

Эквивалентно x.hashCode за исключением упакованных числовых типов и null. Для числовых типов возвращает значение хэша, согласованное с равенством значений: если два экземпляра типа значения сравниваются как true, то ## вернёт одинаковое значение хэша для каждого из них. Для null возвращает хэш-код, где null.hashCode генерирует NullPointerException.

Добавляет два или более элемента в это множество и возвращает новое множество.

Добавляет пару ключ/значение в этот словарь, возвращая новый словарь.

Добавляет ряд элементов, предоставленных объектом перебора, и возвращает новое множество с добавленными элементами.

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

Как и ++, возвращает новую коллекцию, содержащую элементы из левого операнда, за которыми следуют элементы из правого операнда.

Она отличается от ++ тем, что правый операнд определяет тип возвращаемой коллекции, а не левый. Мемоническое правило: двоеточие находится со стороны типа новой коллекции.

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

Этот перегруз существует, потому что: для реализации ++: мы должны повторно использовать реализацию ++, так как многие коллекции переопределяют её более эффективными версиями.

Поскольку у TraversableOnce нет метода ++, нам нужно реализовать его напрямую, но Traversable и ниже могут использовать перегруз.

Как и ++, возвращает новую коллекцию, содержащую элементы из левого операнда, за которыми следуют элементы из правого операнда.

Она отличается от ++ тем, что правый операнд определяет тип возвращаемой коллекции, а не левый. Мемоническое правило: двоеточие находится со стороны типа новой коллекции.

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

Удаляет ключ из этой карты, возвращая новую карту.

Создает новую коллекцию из этой коллекции с удаленными элементами.

Этот метод принимает два или более элемента для удаления. Другой перегруженный вариант этого метода обрабатывает случай удаления одного элемента.

Создает новую коллекцию из этой коллекции, удаляя все элементы другой коллекции.

Применяет бинарный оператор к начальному значению и всем элементам этого перечислимого объекта или итератора слева направо.

Примечание: /: — альтернативная запись для foldLeft; z /: xs — то же самое, что и xs foldLeft z.

Примеры:

Обратите внимание, что функция свёртки, используемая для вычисления b, эквивалентна функции, используемой для вычисления c.

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = (5 /: a)(_+_)
b: Int = 15

scala> val c = (5 /: a)((x,y) => x + y)
c: Int = 15

Примечание: не завершится для бесконечных коллекций.

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

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

Примечание: :\ — альтернативная запись для foldRight; xs :\ z — то же самое, что и xs foldRight z.

Примечание: не завершится для бесконечных коллекций.

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

Примеры:

Обратите внимание, что функция свёртки, используемая для вычисления b, эквивалентна функции, используемой для вычисления c.

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = (a :\ 5)(_+_)
b: Int = 15

scala> val c = (a :\ 5)((x,y) => x + y)
c: Int = 15

Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

Добавляет все пары (ключ-значение) этой карты в строку-строитель, используя начальную, конечную и разделительные строки. Написанный текст начинается со строки start и заканчивается строкой end. Внутри строковые представления всех пар (ключ-значение) этой карты, в форме key -> value, разделены строкой sep.

Добавляет все элементы этого перечислимого объекта или итератора в строку-строитель. Написанный текст состоит из строковых представлений (относительно метода toString) всех элементов этого перечислимого объекта или итератора без какой-либо разделительной строки.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> val h = a.addString(b)
h: StringBuilder = 1234

Добавляет все элементы этого итерируемого объекта или итератора в строковый буфер с использованием разделительной строки. Записываемый текст состоит из строковых представлений (в соответствии с методом toString) всех элементов этого итерируемого объекта или итератора, разделенных строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b, ", ")
res0: StringBuilder = 1, 2, 3, 4

Агрегирует результаты применения оператора к последующим элементам.

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

aggregate разделяет итерируемый объект или итератор на разделы и обрабатывает каждый раздел последовательным применением seqop, начиная с z (как в foldLeft). Эти промежуточные результаты затем объединяются с помощью combop (как в fold). Реализация этой операции может использовать произвольное количество разделов коллекции (даже 1), поэтому combop может быть вызвана произвольное количество раз (даже 0).

Например, рассмотрим суммирование целочисленных значений списка символов. Начальное значение суммы равно 0. Сначала seqop преобразует каждый символ ввода в целое число и добавляет его к сумме (раздела). Затем combop просто суммирует промежуточные результаты разделов:

List('a', 'b', 'c').aggregate(0)({ (sum, ch) => sum + ch.toInt }, { (p1, p2) => p1 + p2 })

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

Возвращает значение, связанное с данным ключом. Этот метод вызывает метод default карты, если нет отображения от данного ключа к значению. Если не переопределен, метод default выбрасывает NoSuchElementException.

Применяет эту частичную функцию к заданному аргументу, если он содержится в области определения функции. Применяет функцию-обработчик, если данная частичная функция не определена.

Обратите внимание, что выражение pf.applyOrElse(x, default) эквивалентно

if(pf isDefinedAt x) pf(x) else default(x)

за исключением того, что метод applyOrElse может быть реализован более эффективно. Для всех частичных функций-литералов компилятор генерирует реализацию applyOrElse, которая избегает двойной оценки проверок шаблонов и условий. Это делает applyOrElse основой для эффективной реализации во многих операциях и сценариях, таких как:

комбинирование частичных функций в цепочки orElse/andThen не приводит к избыточной оценке apply/isDefinedAt lift и unlift не оценивают исходные функции дважды при каждом вызове runWith позволяет эффективно объединять частичные функции с условными действиями

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

Приводит объект-получатель к типу T0.

Обратите внимание, что успех приведения типов во время выполнения зависит от семантики стирания типов Scala. Следовательно, выражение 1.asInstanceOf[String] приведет к исключению ClassCastException во время выполнения, а выражение List(1).asInstanceOf[List[String]] — нет. В последнем примере, так как тип аргумента стирается во время компиляции, невозможно проверить, соответствуют ли содержимое списка запрошенному типу.

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

Создаёт копию объекта-получателя.

По умолчанию реализация метода clone зависит от платформы.

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

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

Примечание: может не завершиться для бесконечных коллекций.

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

Объект-компаньон-фабрика, создающий экземпляры класса immutable.Iterable. (или его Iterable суперкласса, если класс immutable.Iterable не является Seq).

Компонует две функции Function1 в новую Function1, при этом эта функция применяется последней.

Проверяет, содержит ли эта карта привязку для ключа.

Копирует элементы этой неизменяемой хеш-карты в массив. Заполняет заданный массив xs не более чем len элементами этой неизменяемой хеш-карты, начиная с позиции start. Копирование прекратится, как только будет достигнут конец текущей неизменяемой хеш-карты, или конец целевого массива, или len элементов будут скопированы.

Копирует элементы этой неизменяемой хеш-карты в массив. Заполняет заданный массив xs значениями этой неизменяемой хеш-карты. Копирование прекратится, как только будет достигнут конец текущей неизменяемой хеш-карты или конец целевого массива.

Копирует элементы этой неизменяемой хеш-карты в массив. Заполняет заданный массив xs значениями этой неизменяемой хеш-карты, начиная с индекса start. Копирование прекратится, как только будет достигнут конец текущей неизменяемой хеш-карты или конец целевого массива.

Копирует все элементы этого итерируемого объекта или итератора в буфер.

Примечание: не завершится для коллекций бесконечного размера.

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

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

Выбирает все элементы, кроме первых n.

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

Выбирает все элементы, кроме последних n.

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

Удаляет самую длинную префиксную часть элементов, удовлетворяющих предикату.

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

Пустой словарь того же типа, что и этот словарь.

Проверяет, является ли аргумент (that) ссылкой на объект-получатель (this).

Метод eq реализует отношение эквивалентности отношение эквивалентности для не-null экземпляров AnyRef, и имеет три дополнительных свойства:

Он согласован: для любых не-null экземпляров x и y типа AnyRef, многократные вызовы x.eq(y) последовательно возвращают true или последовательно возвращают false. Для любого не-null экземпляра x типа AnyRef, x.eq(null) и null.eq(x) возвращают false. null.eq(null) возвращает true.

При переопределении методов equals или hashCode важно обеспечить согласованность их поведения со ссылкой на равенство. Поэтому, если два объекта являются ссылками друг на друга (o1 eq o2), они должны быть равны друг другу (o1 == o2) и должны иметь одинаковое значение хэша (o1.hashCode == o2.hashCode).

Структурно сравнивает два словаря; т.е. проверяет, содержатся ли все сопоставления, содержащиеся в этом словаре, также и в другом словаре, и наоборот.

Проверяет, выполняется ли предикат хотя бы для одного элемента этого итерируемого набора.

Примечание: может не завершиться для бесконечных коллекций.

Выбирает все элементы этого неизменяемого хэш-словаря, которые удовлетворяют предикату.

Фильтры этого словаря, сохраняя только ключи, удовлетворяющие предикату.

Возвращает новый словарь, полученный путем удаления всех пар ключ/значение, для которых предикат p возвращает true.

Примечание: Этот метод работает путем последовательного удаления элементов, для которых предикат является истинным из этого набора. Если удаление медленное, или ожидается, что большинство элементов набора будут удалены, можно рассмотреть возможность использования filter с отрицающим предикатом вместо этого.

Вызывается сборщиком мусора для объекта-получателя, когда к объекту больше нет ссылок.

Детали того, когда и вызывается метод finalize, а также взаимодействие между finalize и нелокальными возвратами и исключениями, зависят от платформы.

Находит первый элемент в итерируемой коллекции, удовлетворяющий предикату, если таковой имеется.

Примечание: может не завершиться для коллекций бесконечного размера.

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

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

Например:

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

Тип результирующей коллекции определяется статическим типом неизменяемой хеш-карты. Это может иногда приводить к неожиданным результатам. Например:

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set
def lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap (word => word.toSeq)

// xs will be an Iterable[Int]
val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)

// ys will be a Map[Int, Int]
val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

Преобразует эту неизменяемую хеш-карту итерируемых коллекций в неизменяемую хеш-карту, образованную элементами этих итерируемых коллекций.

Тип результирующей коллекции определяется статическим типом неизменяемой хеш-карты. Например:

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

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

Порядок выполнения операций над элементами не определен и может быть не детерминированным.

Примечание: не завершится для коллекций бесконечного размера.

Применяет бинарный оператор к начальному значению и всем элементам этой итерируемой или итерационной коллекции слева направо.

Примечание: не завершится для коллекций бесконечного размера.

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

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

Примечание: не завершится для коллекций бесконечного размера.

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

Проверяет, выполняется ли предикат для всех элементов этого итерируемого набора.

Примечание: может не завершиться для коллекций бесконечного размера.

Применяет функцию f ко всем элементам этой неизменяемой хеш-карты.

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

Возвращает строку, отформатированную в соответствии с заданной строкой format. Строки формата аналогичны строкам String.format (@см. java.lang.String.format).

Неявный генератор, который создает экземпляры Traversable с произвольными типами элементов.

Возвращает значение, связанное с ключом, если оно существует.

Возвращает представление класса объекта во время выполнения.

Возвращает значение, связанное с ключом, или значение по умолчанию, если ключ не содержится в карте.

Разделяет эту коллекцию на карту коллекций согласно функции-дискриминатору.

Примечание: этот метод не переопределяется представлениями. Это означает, что при применении к представлению он всегда заставит представление выполнить вычисления и вернуть новую коллекцию.

Разделяет элементы на итерабельные коллекции фиксированного размера.

Проверяет, известен ли конечный размер этой коллекции. Все строгие коллекции имеют известный конечный размер. Для нестрогой коллекции, такой как Stream, предикат возвращает true , если все элементы были вычислены. Он возвращает false , если поток ещё не был прочитан до конца. Непустые итераторы обычно возвращают false , даже если они были созданы из коллекции с известным конечным размером.

Примечание: многие методы коллекций не работают с коллекциями бесконечных размеров. Типичный режим сбоя – бесконечный цикл. Эти методы всегда пытаются выполнить обход, не проверяя сначала, что hasDefiniteSize возвращает true. Однако, проверка hasDefiniteSize может гарантировать, что размер определён и бесконечное выполнение не является проблемой.

Метод hashCode для ссылочных типов. См. hashCode в scala.Any.

Выбирает первый элемент этой итерабельной коллекции.

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

Возвращает первый элемент в виде Option.

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

Выбирает все элементы, кроме последнего.

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

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

Проверяет, содержит ли эта карта привязку для ключа. Этот метод, реализующий абстрактный метод тройки PartialFunction, эквивалентен contains.

Проверяет, пуста ли карта.

Проверяет, является ли динамический тип объекта-получателя T0.

Обратите внимание, что результат проверки производится с учетом стирания семантики Scala. Поэтому выражение 1.isInstanceOf[String] вернет false, а выражение List(1).isInstanceOf[List[String]] вернет true. В последнем примере, поскольку тип аргумента стирается при компиляции, проверить, содержат ли элементы списка указанный тип, невозможно.

Проверяет, может ли эта итерируемая коллекция быть многократно итерируемой.

Создает новый итератор по всем парам ключ/значение этой карты

Собрать все ключи этой карты в множестве.

Собрать все ключи этой карты в итерируемой коллекции.

Создает итератор для всех ключей.

Выбирает последний элемент.

Примечание: результаты могут отличаться при разных запусках, если тип базового набора не упорядочен.

Выбирает последний элемент (возможно).

Примечание: результаты могут отличаться при разных запусках, если тип базового набора не упорядочен.

Преобразует эту частичную функцию в обычную функцию, возвращающую Option результат.

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

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

Находит наибольший элемент.

Находит первый элемент, который дает наибольшее значение, измеренное функцией f.

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

Использует указанную функцию разрешения коллизий, если ключи совпадают. Функция разрешения коллизий всегда берёт первый аргумент из this карты и второй из that.

Метод merged в среднем более производителен, чем обход и построение новой неизменяемой карты с нуля или ++.

Находит наименьший элемент.

Находит первый элемент, который даёт наименьшее значение, измеренное функцией f.

Отображает все элементы этого обхода или итератора в строке.

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

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

Эквивалентно !(this eq that).

Общее реализация newBuilder для всех карт в терминах empty. Переопределено для изменяемых карт в mutable.MapLike.

Проверяет, не является ли итератор или коллекция пустым.

Разбудит единственную нить, которая ожидает монитора объекта-получателя.

Разбудит все нити, которые ожидают монитора объекта-получателя.

Компонует данную частичную функцию с резервной частичной функцией, которая применяется в тех случаях, когда данная частичная функция не определена.

Возвращает параллельную реализацию данной коллекции.

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

Специальные коллекции (например, ParArray или mutable.ParHashMap) переопределяют это поведение, создавая параллельную коллекцию, которая использует те же самые данные. Для этих коллекций этот метод работает за постоянное или подлинейное время.

Все параллельные коллекции возвращают ссылку на самих себя.

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

Разделяет данную коллекцию на две части согласно предикату.

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

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

Порядок выполнения операций над элементами не определён и может быть недетерминированным.

Применяет бинарный оператор ко всем элементам этого обозримого или итератора слева направо.

Примечание: не завершит работу для коллекций бесконечного размера.

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

При необходимости применяет бинарный оператор ко всем элементам этого обозримого или итератора слева направо.

Примечание: не завершит работу для коллекций бесконечного размера.

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

Сводит элементы этого обозримого или итератора (если таковые имеются), используя указанный ассоциативный бинарный оператор.

Порядок выполнения операций над элементами не определён и может быть недетерминированным.

Применяет бинарный оператор ко всем элементам этой коллекции итерируемых объектов справа налево.

Примечание: не завершит работу для коллекций бесконечного размера.

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

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

Примечание: не будет завершаться для бесконечно больших коллекций.

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

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

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

Обратите внимание, что выражение pf.runWith(action)(x) эквивалентно

if(pf isDefinedAt x) { action(pf(x)); true } else false

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

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

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

Вычисляет префиксное сканирование элементов коллекции.

Примечание: нейтральный элемент z может применяться более одного раза.

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

Примечание: не завершится для коллекций бесконечного размера.

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

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

Примечание: не завершится для коллекций бесконечного размера.

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

Пример:

List(1, 2, 3, 4).scanRight(0)(_ + _) == List(10, 9, 7, 4, 0)

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

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

Размер этой неизменяемой хеш-карты.

Размер этой коллекции или итератора, если его можно вычислить недорого

Выбирает интервал элементов. Полученный набор состоит из всех элементов x, которые удовлетворяют инварианту:

from <= indexOf(x) < until

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

Группирует элементы в блоки фиксированного размера, пропуская «скользящее окно» по ним (в отличие от разбиения на части, как в grouped.)

Группирует элементы в блоки фиксированного размера, пропуская «скользящее окно» по ним (в отличие от разбиения на части, как в grouped.) Шаг «скользящего окна» установлен в единицу.

Разделяет этот проходимый набор на пару префикс/суффикс в соответствии с предикатом.

Примечание: c span p эквивалентно (но, возможно, более эффективно, чем) (c takeWhile p, c dropWhile p), при условии, что вычисление предиката p не вызывает побочных эффектов.

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

Разделяет этот проходимый набор на два в заданной позиции. Примечание: c splitAt n эквивалентно (но, возможно, более эффективно, чем) (c take n, c drop n).

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

Определяет префикс представления этого объекта.

Суммирует элементы этого набора.

Выбирает все элементы, кроме первого.

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

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

Выбирает первые n элементов.

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

Выбирает последние n элементов.

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

Берет наибольший префикс элементов, удовлетворяющих предикату.

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

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

Преобразует эту неизменяемую хеш-карту в другую, копируя все элементы.

Преобразует эту неизменяемую хеш-карту в массив.

Использует содержимое этой карты для создания нового изменяемого буфера.

Преобразование из коллекций типа Repr в объекты Iterable. По умолчанию это реализуется просто как приведение типа, но это можно переопределить.

Преобразует эту итерацию или итератор в индексированную последовательность.

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

Возвращает эту итерабельную коллекцию как итерабельную коллекцию.

Новая коллекция не будет создана; ленивые коллекции останутся ленивыми.

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

Возвращает итератор по элементам в этой итерабельной коллекции. Возвращает тот же результат, что и iterator.

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

Преобразует эту итерацию или итератор в список.

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

Возвращает эту неизменяемую карту как неизменяемую карту.

Новая карта не будет создана; ленивые коллекции останутся ленивыми.

Преобразует эту карту в последовательность. Как и в toIterable, в этой реализации по умолчанию это лениво, так как эта TraversableOnce может быть ленивой и неоцениваемой.

Преобразует эту коллекцию итераций в множество.

Примечание: не завершится для бесконечно больших коллекций.

Преобразует эту итерируемую коллекцию в поток.

Преобразует эту карту в строку.

Преобразует эту итерируемую коллекцию в неопределённое Traversable. Возвращает ту же коллекцию, если этот экземпляр уже Traversable.

Примечание: не завершится для бесконечно больших коллекций.

Преобразует эту итерируемую коллекцию или итератор в вектор.

Примечание: не завершится для бесконечно больших коллекций.

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

Транспонирует это множество коллекций в коллекцию коллекций.

Тип результирующей коллекции будет определяться статическим типом коллекции. Например:

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

Преобразует это множество пар в два множества первой и второй половины каждой пары.

val xs = Traversable(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (Traversable(1, 2, 3),
//        Traversable(one, two, three))

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

val xs = Traversable(
           (1, "one", '1'),
           (2, "two", '2'),
           (3, "three", '3')).unzip3
// xs == (Traversable(1, 2, 3),
//        Traversable(one, two, three),
//        Traversable(1, 2, 3))

Добавляет пару ключ/значение в эту карту.

Собирает все значения этой карты в итерируемую коллекцию.

Создает итератор для всех значений в этой карте.

Создаёт нестрогую (non-strict) представление среза этого итерируемого набора.

Примечание: разница между view и slice заключается в том, что view создаёт представление текущего итерируемого набора, тогда как slice создаёт новый итерируемый набор.

Примечание: view(from, to) эквивалентно view.slice(from, to)

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

Создаёт нестрогое (non-strict) представление этого итерируемого набора.

Такой же набор с заданной функцией по умолчанию. Примечание: get, contains, iterator, keys, и т.д. не затрагиваются withDefault.

Вызов методов трансформации (например, map) не сохранит значение по умолчанию.

Такой же набор с заданным значением по умолчанию. Примечание: get, contains, iterator, keys, и т.д. не затрагиваются withDefaultValue.

Вызов методов трансформации (например, map) не сохранит значение по умолчанию.

Создаёт нестрогое (non-strict) фильтрацию этого итерируемого набора.

Примечание: разница между c filter p и c withFilter p заключается в том, что первый создаёт новый набор, а второй только ограничивает область действия последующих map, flatMap, foreach, и withFilter операций.

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

Возвращает неизменяемую карту хешей, образованную из этой неизменяемой карты хешей и другой итерируемой коллекции, объединяя соответствующие элементы парами. Если одна из двух коллекций длиннее другой, оставшиеся элементы игнорируются.

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

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

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

Объединяет эту неизменяемую карту хешей с её индексами.

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