Класс Range.Range

sealed abstract class Range(val start: Int, val end: Int, val step: Int) extends AbstractSeq[Int] with IndexedSeq[Int] with IndexedSeqOps[Int, IndexedSeq, IndexedSeq[Int]] with StrictOptimizedSeqOps[Int, IndexedSeq, IndexedSeq[Int]] with IterableFactoryDefaults[Int, IndexedSeq] with Serializable

Класс Range представляет целые значения в диапазоне [start;end) с ненулевым значением шага step. Это специальный случай индексированной последовательности. Например:

val r1 = 0 until 10
val r2 = r1.start until r1.end by r1.step + 1
println(r2.length) // = 5

Диапазоны, содержащие более Int.MaxValue элементов, могут быть созданы, но эти переполненные диапазоны обладают ограниченными возможностями. Любой метод, который может потребовать создания коллекции длиной более Int.MaxValue элементов или запросить индексирование сверх Int.MaxValue элементов, выбросит исключение. Переполненные диапазоны могут безопасно уменьшиться в размере путем изменения шага (например, by 3) или взятия/удаления элементов. contains, equals, и доступ к концам диапазона (head, last, tail, init) также разрешены для переполненных диапазонов.

Абстрактные методы

Исходный код

def isInclusive: Boolean

Конкретные методы

Исходный код

final def apply(idx: Int): Int

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

Исходный код

final def by(step: Int): Range

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

Исходный код

final def contains(x: Int): Boolean

Исходный код

final override def contains[B >: Int](elem: B): Boolean

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

Исходный код

override def distinct: Range

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

Исходный код

final override def drop(n: Int): Range

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

Исходный код

final override def dropRight(n: Int): Range

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

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

Source

final override def dropWhile(p: Int => Boolean): Range

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

Source

final override def equals(other: Any): Boolean

Метод универсального равенства, определённый в AnyRef.

Source

final override def foreach[U](f: Int => U): Unit

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

Source

override def grouped(size: Int): Iterator[Range]

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

Source

final override def hashCode: Int

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

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

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

Source

final override def head: Int

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

Source

final def inclusive: Range

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

Source

final override def indexOf[B >: Int](elem: B, from: Int): Int

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

Source

final override def init: Range

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

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

Source

override def inits: Iterator[Range]

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

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

Source

final override def iterator: Iterator[Int]

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

Source

final override def last: Int

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

Source

final override def lastIndexOf[B >: Int](elem: B, end: Int): Int

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

Source

final def length: Int

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

Source

override def map[B](f: Int => B): IndexedSeq[B]

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

Источник

final override def max[A1 >: Int](implicit ord: Ordering[A1]): Int

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

Источник

final override def min[A1 >: Int](implicit ord: Ordering[A1]): Int

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

Источник

final override def reverse: Range

Возвращает обратный диапазон.

Источник

override def sameElements[B >: Int](that: IterableOnce[B]): Boolean

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

Источник

final override def slice(from: Int, until: Int): Range

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

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

Источник

override def sorted[B >: Int](implicit ord: Ordering[B]): IndexedSeq[Int]

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

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

Источник

final override def span(p: Int => Boolean): (Range, Range)

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

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

Источник

final override def splitAt(n: Int): (Range, Range)

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

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

Источник

final override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Int, S]): S & EfficientSplit

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

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

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

• Для коллекций целых чисел, Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для коллекций Double или Float, возвращается scala.collection.DoubleStepper

• Для коллекций Long возвращается scala.collection.LongStepper

• Для любого другого типа элементов возвращается scala.collection.AnyStepper

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

Источник

final override def sum[B >: Int](implicit num: Numeric[B]): Int

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

Источник

final override def tail: Range

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

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

Источник

override def tails: Iterator[Range]

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

Источник

final override def take(n: Int): Range

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

Источник

final override def takeRight(n: Int): Range

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

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

Источник

final override def takeWhile(p: Int => Boolean): Range

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

Источник

final override def toString: String

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

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

Наследуемые методы

Источник

final def ++[B >: Int](suffix: IterableOnce[B]): CC[B]

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

Источник

final override def ++:[B >: Int](prefix: IterableOnce[B]): CC[B]

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

Источник

final def +:[B >: Int](elem: B): CC[B]

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

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

Источник

final def :+[B >: Int](elem: B): CC[B]

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

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

Источник

final def :++[B >: Int](suffix: IterableOnce[B]): CC[B]

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

Источник

final def addString(b: StringBuilder): StringBuilder

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

Источник

final def addString(b: StringBuilder, sep: String): StringBuilder

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

Источник

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Добавляет все элементы этой коллекции в строковый билдер с использованием начальной, конечной и разделительных строк. Записываемый текст начинается со строки 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)

Источник

def andThen[C](k: PartialFunction[Int, C]): PartialFunction[A, C]

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

Обратите внимание, что вызов isDefinedAt для полученной частичной функции может применить первую частичную функцию и выполнить её побочный эффект. Для повышения эффективности рекомендуется использовать applyOrElse вместо isDefinedAt или apply.

Источник

override def andThen[C](k: Int => C): PartialFunction[A, C]

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

Если тип функции во время выполнения является PartialFunction, то используется другой метод andThen (обратите внимание на его предостережения).

Источник

override def appended[B >: Int](elem: B): CC[B]

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

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

Пример:

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)

Источник

override def appendedAll[B >: Int](suffix: IterableOnce[B]): CC[B]

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

Источник

def applyOrElse[A1 <: Int, B1 >: Int](x: A1, default: A1 => B1): B1

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

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

Источник

override def canEqual(that: Any): Boolean

Метод, который должен вызываться из каждой хорошо спроектированной функции equals, которая открыта для переопределения в подклассе. См. Programming in Scala, Chapter 28 для обсуждения и проектирования.

Источник

override def collect[B](pf: PartialFunction[Int, B]): CC[B]

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

Источник

def collectFirst[B](pf: PartialFunction[Int, B]): Option[B]

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

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

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

Источник

def combinations(n: Int): Iterator[C]

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

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

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

Источник

def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, B]

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

Обратите внимание, что вызов isDefinedAt для полученной частичной функции может применить первую частичную функцию и выполнить её побочный эффект. Для повышения эффективности рекомендуется использовать applyOrElse вместо isDefinedAt или apply.

Источник

def compose[A](g: A => Int): A => R

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

Источник

final override def concat[B >: Int](suffix: IterableOnce[B]): CC[B]

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

Источник

def containsSlice[B >: Int](that: Seq[B]): Boolean

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

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

Источник

def copyToArray[B >: Int](xs: Array[B], start: Int, len: Int): Int

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

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

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

Источник

def copyToArray[B >: Int](xs: Array[B], start: Int): Int

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

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

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

Источник

def copyToArray[B >: Int](xs: Array[B]): Int

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

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

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

Источник

def corresponds[B](that: IterableOnce[B])(p: (Int, B) => Boolean): Boolean

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

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

Источник

def corresponds[B](that: Seq[B])(p: (Int, B) => Boolean): Boolean

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

Источник

def count(p: Int => Boolean): Int

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

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

Источник

override def diff[B >: Int](that: Seq[B]): C

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

Источник

override def distinctBy[B](f: Int => B): C

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

Источник

def elementWise: ElementWiseExtractor[A, B]

Возвращает объект-экстрактор с методом unapplySeq, который извлекает каждый элемент данных последовательности.

val firstChar: String => Option[Char] = _.headOption
Seq("foo", "bar", "baz") match {
  case firstChar.unlift.elementWise(c0, c1, c2) =>
    println(s"$c0, $c1, $c2") // Output: f, b, b
}

Источник

override def empty: CC[A]

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

Источник

def endsWith[B >: Int](that: Iterable[B]): Boolean

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

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

Источник

def exists(p: Int => Boolean): Boolean

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

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

Источник

override def filter(pred: Int => Boolean): C

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

Источник

override def filterNot(pred: Int => Boolean): C

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

Источник

def find(p: Int => Boolean): Option[A]

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

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

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

Исходный код

def findLast(p: Int => Boolean): Option[A]

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

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

Исходный код

override def flatMap[B](f: Int => IterableOnce[B]): CC[B]

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

Например:

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)

Исходный код

override def flatten[B](implicit toIterableOnce: Int => IterableOnce[B]): CC[B]

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

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

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)

Исходный код

def fold[A1 >: Int](z: A1)(op: (A1, A1) => A1): A1

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

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

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

Исходный код

def foldLeft[B](z: B)(op: (B, Int) => B): B

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

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

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

Исходный код

override def foldRight[B](z: B)(op: (Int, B) => B): B

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

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

Исходный код

def forall(p: Int => Boolean): Boolean

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

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

Исходный код

protected def fromSpecific(coll: IterableOnce[Int]): CC[A]

Определяет, как преобразовать заданную Iterable[A] в коллекцию типа C.

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

Исходный код

def groupBy[K](f: Int => K): Map[K, C]

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

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

(xs groupBy f)(k) = xs filter (x => f(x) == k)

Исходный код

def groupMap[K, B](key: Int => K)(f: Int => B): Map[K, CC[B]]

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций по функции-дискриминатору 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)

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

Исходный код

def groupMapReduce[K, B](key: Int => K)(f: Int => B)(reduce: (B, B) => B): Map[K, B]

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

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

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

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

Исходный код

override def headOption: Option[A]

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

Исходный код

def indexOf[B >: Int](elem: B): Int

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

Исходный код

def indexOfSlice[B >: Int](that: Seq[B]): Int

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

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

Исходный код

def indexOfSlice[B >: Int](that: Seq[B], from: Int): Int

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

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

Исходный код

def indexWhere(p: Int => Boolean): Int

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

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

Исходный код

def indexWhere(p: Int => Boolean, from: Int): Int

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

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

Исходный код

def indices: Range

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

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

Исходный код

override def intersect[B >: Int](that: Seq[B]): C

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

Источник

def isDefinedAt(idx: Int): Boolean

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

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

Источник

override def isTraversableAgain: Boolean

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

Источник

override def iterableFactory: SeqFactory[IndexedSeq]

Компаньон-объект этой последовательности, предоставляющий различные методы фабрики.

Источник

override def knownSize: Int

Источник

def lastIndexOfSlice[B >: Int](that: Seq[B]): Int

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

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

Источник

def lastIndexOfSlice[B >: Int](that: Seq[B], end: Int): Int

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

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

Источник

def lastIndexWhere(p: Int => Boolean): Int

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

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

Источник

def lastIndexWhere(p: Int => Boolean, end: Int): Int

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

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

Источник

def lastOption: Option[A]

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

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

Источник

def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, Iterable]

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

Вызовы lazyZip могут быть объединены для поддержки более высоких арностей (до 4) без затрат на создание и деконструкцию промежуточных кортежей.

val xs = List(1, 2, 3)
val res = (xs lazyZip xs lazyZip xs lazyZip xs).map((a, b, c, d) => a + b + c + d)
// res == List(4, 8, 12)

Источник

final override def lengthCompare(that: Iterable[_]): Int

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

x <  0       if this.length <  that.size
x == 0       if this.length == that.size
x >  0       if this.length >  that.size

Исходный код

final override def lengthCompare(len: Int): Int

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

x <  0       if this.length <  len
x == 0       if this.length == len
x >  0       if this.length >  len

Исходный код

final def lengthIs: SizeCompareOps

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

Эти операции реализованы с использованием 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

Исходный код

def lift: A => Option[B]

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

Исходный код

def maxBy[B](f: Int => B)(implicit cmp: Ordering[B]): A

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

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

Исходный код

def maxByOption[B](f: Int => B)(implicit cmp: Ordering[B]): Option[A]

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

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

Source

def maxOption[B >: Int](implicit ord: Ordering[B]): Option[A]

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

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

Source

def minBy[B](f: Int => B)(implicit cmp: Ordering[B]): A

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

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

Source

def minByOption[B](f: Int => B)(implicit cmp: Ordering[B]): Option[A]

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

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

Source

def minOption[B >: Int](implicit ord: Ordering[B]): Option[A]

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

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

Source

final def mkString: String

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

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

Источник

final def mkString(sep: String): String

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

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

Источник

final def mkString(start: String, sep: String, end: String): String

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

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

Источник

protected def newSpecificBuilder: Builder[A, CC[A]]

Источник

def nonEmpty: Boolean

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

Источник

def orElse[A1 <: Int, B1 >: Int](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

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

Исходный код

override def padTo[B >: Int](len: Int, elem: B): CC[B]

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

Исходный код

override def partition(p: Int => Boolean): (C, C)

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

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

Исходный код

override def partitionMap[A1, A2](f: Int => Either[A1, A2]): (CC[A1], CC[A2])

Применяет функцию 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))

Исходный код

override def patch[B >: Int](from: Int, other: IterableOnce[B], replaced: Int): CC[B]

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

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

Источник

def permutations: Iterator[C]

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

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

Источник

override def prepended[B >: Int](elem: B): CC[B]

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

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

Пример:

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)

Источник

override def prependedAll[B >: Int](prefix: IterableOnce[B]): CC[B]

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

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

Источник

def product[B >: Int](implicit num: Numeric[B]): B

Произведение элементов этой коллекции.

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

Источник

def reduce[B >: Int](op: (B, B) => B): B

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

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

Источник

def reduceLeft[B >: Int](op: (B, Int) => B): B

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

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

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

Источник

def reduceLeftOption[B >: Int](op: (B, Int) => B): Option[B]

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

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

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

Источник

def reduceOption[B >: Int](op: (B, B) => B): Option[B]

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

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

Источник

def reduceRight[B >: Int](op: (Int, B) => B): B

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

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

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

Исходный код

def reduceRightOption[B >: Int](op: (Int, B) => B): Option[B]

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

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

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

Исходный код

override def reverseIterator: Iterator[A]

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

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

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

Исходный код

override protected def reversed: Iterable[A]

Исходный код

def runWith[U](action: Int => U): A => Boolean

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

Обратите внимание, что выражение pf.runWith(action)(x) эквивалентно

if(pf isDefinedAt x) { action(pf(x)); true } else false

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

Исходный код

def scan[B >: Int](z: B)(op: (B, B) => B): CC[B]

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

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

Исходный код

override def scanLeft[B](z: B)(op: (B, Int) => B): CC[B]

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

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

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

Исходный код

def scanRight[B](z: B)(op: (Int, B) => B): CC[B]

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

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

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

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

Пример:

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

Исходный код

override def search[B >: Int](elem: B, from: Int, to: Int)(implicit ord: Ordering[B]): SearchResult

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

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

Исходный код

override def search[B >: Int](elem: B)(implicit ord: Ordering[B]): SearchResult

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

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

Исходный код

def segmentLength(p: Int => Boolean, from: Int): Int

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

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

Исходный код

final def segmentLength(p: Int => Boolean): Int

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

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

Исходный код

final override def size: Int

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

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

Исходный код

final override def sizeCompare(that: Iterable[_]): Int

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

x <  0       if this.size <  that.size
x == 0       if this.size == that.size
x >  0       if this.size >  that.size

Исходный код

final override def sizeCompare(otherSize: Int): Int

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

x <  0       if this.size <  otherSize
x == 0       if this.size == otherSize
x >  0       if this.size >  otherSize

Source

final def sizeIs: SizeCompareOps

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

Эти операции реализованы в терминах 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

Source

def sliding(size: Int, step: Int): Iterator[C]

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

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

Source

def sliding(size: Int): Iterator[C]

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

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

Source

def sortBy[B](f: Int => B)(implicit ord: Ordering[B]): C

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

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

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

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

val words = "The quick brown fox jumped over the lazy dog".split(' ')
// this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]]
words.sortBy(x => (x.length, x.head))
res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped)

Source

def sortWith(lt: (Int, Int) => Boolean): C

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

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

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

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

List("Steve", "Tom", "John", "Bob").sortWith(_.compareTo(_) < 0) =
List("Bob", "John", "Steve", "Tom")

Source

def startsWith[B >: Int](that: IterableOnce[B], offset: Int): Boolean

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

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

Source

override def tapEach[U](f: Int => U): C

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

Source

def to[C1](factory: Factory[Int, C1]): C1

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

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

Source

def toArray[B >: Int : ClassTag]: Array[B]

Преобразовать коллекцию в массив.

Примечание реализации: НЕ вызывайте Array.from из этого метода.

Source

final def toBuffer[B >: Int]: Buffer[B]

Source

final override def toIndexedSeq: IndexedSeq[A]

Source

def toList: List[A]

Source

def toMap[K, V](implicit ev: Int <:< (K, V)): Map[K, V]

Source

final override def toSeq: Seq.this.type

Source

def toSet[B >: Int]: Set[B]

Source

def toVector: Vector[A]

Source

def transpose[B](implicit asIterable: Int => Iterable[B]): CC[CC[B]]

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

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

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

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

Source

def unapply(a: Int): Option[B]

Попытка извлечь B из A в выражении сопоставления с образцом.

Source

override def unzip[A1, A2](implicit asPair: Int => (A1, A2)): (CC[A1], CC[A2])

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

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

Source

override def unzip3[A1, A2, A3](implicit asTriple: Int => (A1, A2, A3)): (CC[A1], CC[A2], CC[A3])

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

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

Source

override def updated[B >: Int](index: Int, elem: B): CC[B]

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

Source

override def view: IndexedSeqView[A]

Представление над элементами этой коллекции.

Source

def withFilter(p: Int => Boolean): WithFilter[A, CC]

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

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

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

Source

override def zip[B](that: IterableOnce[B]): CC[(A, B)]

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

Source

def zipAll[A1 >: Int, B](that: Iterable[B], thisElem: A1, thatElem: B): CC[(A1, B)]

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

Source

override def zipWithIndex: CC[(A, Int)]

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

Concrete fields

Source

val end: Int

Source

final override val isEmpty: Boolean

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

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

Источник

val start: Int

Источник

val step: Int