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

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

Эквивалентно 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)

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

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

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

Пример:

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 ко всем элементам этого диапазона.

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

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

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

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

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

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

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

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

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

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

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

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

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

Делает диапазон инклюзивным.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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