Трейт scala.collection.immutable.LinearSeqOps

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

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

Псевдоним для concat

Псевдоним для prependedAll

Псевдоним для prepended.

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

Псевдоним для appended

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

Псевдоним для appendedAll

Проверка двух объектов на равенство. Выражение 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)

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

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

Пример:

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)

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

Получить элемент по указанному индексу. Эта операция предоставляется для удобства в Seq. Не следует предполагать, что она будет эффективной, если у вас нет IndexedSeq.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Заполняет заданный массив xs начиная с индекса start не более чем len элементами этой коллекции.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пустая итерируемая коллекция того же типа, что и эта итерируемая коллекция

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

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

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

Любая реализация этого метода должна быть отношением эквивалентности:

Он рефлексивен: для любого экземпляра x типа Any, x.equals(x) должен возвращать true.Он симметричен: для любых экземпляров x и y типа Any, x.equals(y) должен возвращать true тогда и только тогда, когда y.equals(x) возвращает true.Он транзитивен: для любых экземпляров x, y, и z типа Any если x.equals(y) возвращает true и y.equals(z) возвращает true, то x.equals(z) должен возвращать true.

Если вы переопределяете этот метод, вы должны убедиться, что ваша реализация остается отношением эквивалентности. Кроме того, при переопределении этого метода обычно необходимо переопределить hashCode для обеспечения того, что объекты, которые являются «равными» (o1.equals(o2) возвращает true), хэшируются в тот же scala.Int. (o1.hashCode.equals(o2.hashCode)).

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

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

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

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

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

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

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

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

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

Например:

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: String) => 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)

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

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

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

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

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

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

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

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

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

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

Применяет f к каждому элементу для его побочных эффектов. Примечание: параметр [U] необходим для помощи выводу типа scalac.

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

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

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

Разбивает эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с функцией-дискриминатором key. Каждый элемент в группе преобразуется в значение типа B с помощью функции value.

Эквивалентно groupBy(key).mapValues(_.map(f)), но более эффективно.

case class User(name: String, age: Int)

def namesByAge(users: Seq[User]): Map[Int, Seq[String]] =
  users.groupMap(_.age)(_.name)

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

Разбивает эту итерируемую коллекцию на карту в соответствии с функцией-дискриминатором key. Все значения с одинаковым дискриминатором затем преобразуются функцией value и затем сводятся к одному значению с помощью функции reduce.

Эквивалентно groupBy(key).mapValues(_.map(f).reduce(reduce)), но более эффективно.

def occurrences[A](as: Seq[A]): Map[A, Int] =
  as.groupMapReduce(identity)(_ => 1)(_ + _)

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

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

Вычисляет значение хэш-кода для объекта.

Алгоритм хэширования по умолчанию зависит от платформы.

Следует понимать, что для двух объектов могут быть одинаковые хэш-коды (o1.hashCode.equals(o2.hashCode)) , но они при этом могут не быть равны (o1.equals(o2) возвращает false). Вырожденная реализация может всегда возвращать 0. Однако, требуется, чтобы если два объекта равны (o1.equals(o2) возвращает true), у них были одинаковые хэш-коды (o1.hashCode.equals(o2.hashCode)). Поэтому при переопределении этого метода необходимо убедиться, что поведение согласуется с методом equals.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Начальная часть коллекции без её последнего элемента.

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

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

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

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

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

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

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

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

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

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

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

Итератор может быть использован только один раз

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

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

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

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

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

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

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

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

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

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

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

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

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

Длина (количество элементов) последовательности. size является псевдонимом для length в Seq коллекциях.

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

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

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

Эти операции реализованы на основе lengthCompare(Int), и допускают следующие более читаемые варианты использования:

this.lengthIs < len     // this.lengthCompare(len) < 0
this.lengthIs <= len    // this.lengthCompare(len) <= 0
this.lengthIs == len    // this.lengthCompare(len) == 0
this.lengthIs != len    // this.lengthCompare(len) != 0
this.lengthIs >= len    // this.lengthCompare(len) >= 0
this.lengthIs > len     // this.lengthCompare(len) > 0

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

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

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

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

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

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

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

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

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

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

Делегирует addString, который может быть переопределён.

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

Делегирует addString, который может быть переопределён.

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

Делегирует addString, который может быть переопределён.

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

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

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

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

Применяет функцию f к каждому элементу итерируемой коллекции и возвращает пару итерируемых коллекций: первая состоит из тех значений, возвращенных f, которые были обернуты в scala.util.Left, а вторая — из тех, которые были обернуты в scala.util.Right.

Пример:

val xs = Iterable(1, "one", 2, "two", 3, "three") partitionMap {
 case i: Int => Left(i)
 case s: String => Right(s)
}
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

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

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

Итерирует по различным перестановкам.

Примечание: Даже при применении к представлению или ленивой коллекции это всегда будет приводить к принудительной обработке элементов.

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

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

Пример:

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает результат применения бинарного оператора ко всем элементам этого набора, справа налево (по желанию).

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

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

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

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

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

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

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

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

Являются ли элементы этого набора такими же (и в таком же порядке), как и элементы that?

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

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

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

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

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

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

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

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

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

Пример:

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

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

Последовательность должна быть отсортирована с использованием того же Ordering перед вызовом; в противном случае результаты не определены.

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

Последовательность должна быть отсортирована с использованием того же Ordering перед вызовом; в противном случае результаты не определены.

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

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

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

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

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

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

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

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

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

Эти операции реализованы через sizeCompare(Int), и позволяют использовать следующие более читаемые конструкции:

this.sizeIs < size     // this.sizeCompare(size) < 0
this.sizeIs <= size    // this.sizeCompare(size) <= 0
this.sizeIs == size    // this.sizeCompare(size) == 0
this.sizeIs != size    // this.sizeCompare(size) != 0
this.sizeIs >= size    // this.sizeCompare(size) >= 0
this.sizeIs > size     // this.sizeCompare(size) > 0

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

from <= indexOf(x) < until

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

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

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

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

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

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

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

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

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

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

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

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

Сортировка стабильна. То есть элементы, которые равны (как определено функцией ord.compare), появляются в отсортированной последовательности в том же порядке, что и в исходной.

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

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

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

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

Примечание: c splitAt n эквивалентно (но, возможно, более эффективно, чем) (c take n, c drop n).

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

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

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

Возвращает Stepper для элементов этого набора.

Stepper позволяет создавать поток Java для работы с коллекцией, см. scala.jdk.StreamConverters. Для коллекций, содержащих примитивные значения, Stepper может использоваться как итератор, который не упаковывает элементы.

Неявный параметр StepperShape определяет тип возвращаемого Stepper в соответствии с типом элемента этой коллекции.

Для коллекций Int, Short, Byte или Char, возвращается IntStepperДля коллекций Double или Float, возвращается DoubleStepperДля коллекций Long, возвращается LongStepperДля любого другого типа элементов возвращается AnyStepper

Обратите внимание, что этот метод переопределен в подклассах, и тип возвращаемого значения уточняется до S with EfficientSplit, например, IndexedSeqOps.stepper. Для Steppers, помеченных scala.collection.Stepper.EfficientSplit, конвертеры в scala.jdk.StreamConverters позволяют создавать параллельные потоки, тогда как обычные Steppers могут быть преобразованы только в последовательные потоки.

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

Остаток коллекции без первого элемента.

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

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

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

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

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

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

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

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

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

xs.to(List) xs.to(ArrayBuffer) xs.to(BitSet) // для xs: Iterable[Int]

Преобразовать набор в массив.

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

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

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

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

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 = Iterable(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

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

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

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

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

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

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

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

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

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

Объединяет эту итерируемую коллекцию со своими индексами.