Класс scala.collection.immutable.SortedMap.DefaultKeySortedSet

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

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

Вычисляет пересечение данного множества с другим множеством.

Примечание: То же самое, что и intersect.

Разность этого множества и другого множества.

Примечание: То же самое, что и diff.

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

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

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

Пример:

scala> val a = Set(1, 3) + 2 + 3
a: scala.collection.immutable.Set[Int] = Set(1, 3, 2)

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

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

Пример:

scala> val a = Set(1, 2) ++ Set(2, "a")
a: scala.collection.immutable.Set[Any] = Set(1, 2, a)

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

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

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

Пример:

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).

Добавляет все элементы этого итерируемого объекта или итератора в строковый буфер. Записываемый текст состоит из строковых представлений (с использованием метода 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

Добавляет все элементы этого итерируемого объекта или итератора в строковый буфер с использованием начальной, конечной и разделительной строк. Записываемый текст начинается со строки start и заканчивается строкой end. Внутри строковые представления (с использованием метода 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 , "List(" , ", " , ")")
res5: StringBuilder = List(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 })

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

Проверяет, содержится ли в этом множестве некоторый элемент.

Этот метод эквивалентен contains. Он позволяет рассматривать множества как предикаты.

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

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

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

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

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

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

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

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

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

Объект-компаньон-фабрика, который создаёт экземпляры класса immutable.Set. (или его Iterable суперкласса, если класс immutable.Set не является 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).

Сравнивает этот набор с другим объектом на равенство.

Примечание: Эта операция содержит неконтролируемое приведение типов: если that является набором, она предположит с помощью неконтролируемого приведения типов, что он имеет тот же тип элементов, что и этот набор. Любой последующий ClassCastException обрабатывается как результат false.

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

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

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

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

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

Подробности о том, когда и если вызывается метод 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)

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

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

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 для произвольных типов элементов.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вычисляет пересечение между этим множеством и другим множеством.

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

Проверка, является ли динамический тип объекта-приёмника 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Перемножает элементы этого набора.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание: нейтральный элемент 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).

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

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

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

Итератор по всем подмножествам этого множества.

Итератор по всем подмножествам этого множества заданного размера. Если запрошенный размер недостижим, возвращается пустой итератор.

Суммирует элементы этой коллекции.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Преобразует это неизменяемое отсортированное множество в карту. Этот метод недоступен, если элементы не являются членами Tuple2, при этом каждый ((T, U)) становится парой ключ-значение в карте. Повторяющиеся ключи будут перезаписываться последующими ключами: если это неупорядоченная коллекция, то какой ключ находится в результирующей карте не определено.

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

Возвращает это неизменяемое отсортированное множество как неизменяемое множество, возможно принимающее более широкий диапазон элементов. Поскольку это уже неизменяемое множество, оно будет перестроено только в том случае, если базовая структура не может быть расширена для включения произвольных типов элементов. Например, BitSet и SortedSet будут перестроены, так как они требуют Int и соответственно сортируемых элементов.

В случае сомнений множество будет перестроено. Перестроенные множества больше никогда не должны перестраиваться.

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

Создает строковое представление этого объекта. По умолчанию представление зависит от платформы. На платформе Java это конкатенация имени класса, «@» и хэш-кода объекта в шестнадцатеричном формате.

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

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

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

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

Транспонирует это множество итерируемых множеств в множество множеств.

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

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))

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

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

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

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

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

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

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

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

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

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

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

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

Объединяет это неизменяемое отсортированное множество с его индексами.

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

Вычисляет объединение между этим множеством и другим множеством.

Примечание: То же самое, что и union.