Класс scala.collection.immutable.TreeMap

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

Эквивалентно 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 преобразует каждый входной символ в Int и добавляет его к сумме (раздела). Затем 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 реализует отношение эквивалентности на непустых экземплярах AnyRef, и имеет три дополнительных свойства:

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

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

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

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

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

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

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

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

Возвращает новую карту, полученную путём удаления всех пар ключ/значение, для которых предикат 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 (@see java.lang.String.format).

Создаёт проекцию диапазона этого набора без верхней границы.

Общий билдер, который создаёт экземпляры Traversable для произвольных типов элементов.

Проверяет, отображает ли эта карта key на значение, и возвращает значение, если оно существует.

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

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

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

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

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

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

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

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

Возвращает первый элемент этого неизменяемого дерева отображений.

Возвращает первый элемент, если он существует.

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

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

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

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

Проверяет, пусто ли отображение.

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

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

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

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

Создаёт итератор по всем парам "ключ/значение", содержащимся в этом словаре, у которых ключ больше или равен start в соответствии с порядком этого словаря. x.iteratorFrom(y) эквивалентно, но часто эффективнее, чем x.from(y).iterator.

Собирает все ключи этого словаря в множество.

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

Создаёт итератор по всем ключам.

Создаёт итератор по всем ключам (или элементам) этого набора, которые больше или равны start в соответствии с порядком этого набора. x.keysIteratorFrom(y) эквивалентно, но часто эффективнее, чем x.from(y).keysIterator.

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

Возвращает последний ключ набора.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Разбудит один поток, ждущий монитора объекта-получателя.

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

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

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

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

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

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

Реализация 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).

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

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

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

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

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

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

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

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

Создать проекцию диапазона этой коллекции без нижней границы.

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

Преобразует это неизменяемое дерево карт в массив.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Эта функция преобразует все значения отображений, содержащихся в этой карте, с помощью функции 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))

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

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

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

Создаёт итератор по всем значениям, содержащимся в этой карте, которые связаны с ключом, большим или равным start, согласно порядку этой карты. x.valuesIteratorFrom(y) эквивалентно, но часто более эффективно, чем x.from(y).valuesIterator.

Создаёт нестрогую (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) не сохранит значение по умолчанию.

Создаёт нестрогий фильтр этого итерируемого набора.

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

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

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

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

Сжимает эту неизменяемую карту дерева со своими индексами.