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

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

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

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

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

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

Пример:

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 и ниже могут использовать перегрузку.

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

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

Пример:

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)

Копия диапазона с добавленным элементом в начало.

Обратите внимание, что операторы с окончанием двоеточием являются правоассоциативными (см. пример). Мнемоника для +: по сравнению с :+ такова: двоеточие ставится со стороны коллекции.

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

Пример:

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

scala> val y = 2 +: x
y: List[Int] = List(2, 1)

scala> println(x)
List(1)

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

Примечание: /: — это альтернативная запись для 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

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

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

Копия этого диапазона с добавленным элементом в конец.

Мнемоника для +: по сравнению с :+ такова: двоеточие ставится со стороны коллекции.

Пример:

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

scala> val b = a :+ 2
b: List[Int] = List(1, 2)

scala> println(a)
List(1)

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

Примечание: :\ — это альтернативная запись для 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 преобразует каждый входной символ в целое число и добавляет его к сумме (раздела). Затем, combop просто суммирует промежуточные результаты разделов:

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

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

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

Пример:

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

scala> x(3)
res1: Int = 4

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

Обратите внимание, что выражение 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]] не выбросит. В последнем примере, так как тип аргумента стирается при компиляции, невозможно проверить, соответствуют ли элементы списка запрошенному типу.

Создает новый диапазон с start и end значениями этого диапазона и новым step.

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

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

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

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

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

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

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

Итерируется по комбинациям. _Комбинация_ длины n — это подпоследовательность исходной последовательности, элементы которой взяты в порядке следования. Таким образом, "xy" и "yy" — это комбинации длины 2 исходной последовательности "xyy", но "yx" не является таковой. Если существует более одного способа сгенерировать одну и ту же подпоследовательность, будет возвращена только одна.

Например, "xyyy" имеет три способа сгенерировать "xy" в зависимости от того, какой первый, второй или третий "y" элемент был выбран. Однако, поскольку все они идентичны, будет выбран только один. Какой из трёх будет выбран, является реализационным деталью и не определён.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Создает новую последовательность из этой последовательности без дублируемых элементов.

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

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

Примечание: этот метод не использует билдеры для построения нового диапазона, и его сложность составляет O(1).

Создает новый диапазон, состоящий из начальных length - n элементов диапазона.

Примечание: этот метод не использует билдеры для построения нового диапазона, и его сложность составляет O(1).

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

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

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

Проверяет, является ли аргумент (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).

Метод equals для произвольных последовательностей. Сравнивает эту последовательность с каким-либо другим объектом.

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

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

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

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

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

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

Хеш-коды для IndexedSeq производят значение из хеш-кодов всех элементов последовательности.

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

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

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

Находит индекс первого вхождения некоторого значения в этом диапазоне после или на некотором начальном индексе.

Находит индекс первого вхождения некоторого значения в этом диапазоне.

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

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

Находит первый индекс, где эта последовательность содержит заданную последовательность как срез.

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

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

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

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

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

Создаёт диапазон всех индексов этой последовательности.

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

Примечание: этот метод не использует билдеры для построения нового диапазона, и его сложность составляет O(1).

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

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

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

Реализации методов apply и isDefinedAt преобразуют Seq[A] в PartialFunction[Int, A].

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

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

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

Проверяет, можно ли многократно проходить по коллекции.

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

Последний элемент этого диапазона. Этот метод возвращает корректное значение даже если элементов слишком много для итерации.

Находит индекс последнего вхождения значения в этом диапазоне до или на заданном индексе.

Находит индекс последнего вхождения значения в этом диапазоне.

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

Находит последний индекс, где эта последовательность содержит заданную последовательность в качестве среза.

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

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

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

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

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

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

Длина диапазона.

Примечание: xs.length и xs.size дают одинаковый результат.

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

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

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

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

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

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

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

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

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

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

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

Построитель, который создает экземпляры типа Traversable[A]

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

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

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

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

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

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

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

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

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

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

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

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

Проходит по различным перестановкам.

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

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

Умножает элементы этой коллекции.

Уменьшает элементы этого итерируемого объекта или итератора с помощью указанного ассоциативного бинарного оператора.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание: этот метод не использует билдеры для построения нового диапазона, и его сложность составляет O(1).

Итератор, возвращающий элементы в обратном порядке.

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

Примечание: xs.reverseIterator эквивалентно xs.reverse.iterator, но может быть более эффективным.

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

Примечание: xs.reverseMap(f) эквивалентно xs.reverse.map(f), но может быть более эффективным.

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

Обратите внимание, что выражение 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).

Размер этого диапазона, эквивалентный length.

Размер этой последовательности, если его можно вычислить дёшево.

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

Примечание: этот метод не использует билдеры для построения нового диапазона, и его сложность составляет O(1).

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

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

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

Сортирует эту последовательность в соответствии с функцией сравнения.

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

Сортировка стабильна. То есть, элементы, которые равны (как определено lt), появляются в отсортированной последовательности в том же порядке, что и в оригинале.

Сортирует эту последовательность в соответствии с упорядочиванием.

Сортировка стабильна. То есть, элементы, которые равны (как определено lt), появляются в отсортированной последовательности в том же порядке, что и в оригинале.

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

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

Создаёт пару новых диапазонов, первый из элементов перед n, а второй — из элементов после n.

Примечание: этот метод не использует билдеры для построения нового диапазона, и его сложность составляет O(1).

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

Примечание: Если оба объекта-получателя this и аргумент that являются бесконечными последовательностями, этот метод может не завершиться.

Проверяет, начинается ли эта общая последовательность с заданной последовательности.

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

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

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

Примечание: этот метод не использует билдеры для построения нового диапазона, и его сложность составляет O(1).

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

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

Примечание: этот метод не использует билдеры для построения нового диапазона, и его сложность составляет O(1).

Создаёт новый диапазон, состоящий из последних n элементов диапазона.

Примечание: этот метод не использует билдеры для создания нового диапазона, и его сложность составляет O(1).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Создает новую последовательность, содержащую все элементы этого диапазона и все элементы заданной последовательности. xs union ys эквивалентно xs ++ ys.

Другой способ выразить это - xs union ys вычисляет объединение множеств xs и ys, сохраняя порядок элементов. union таким образом является аналогом diff и intersect, которые также работают с множествами.

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

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 операций.

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

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

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

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