Класс Range.Inclusive

final class Inclusive(start: Int, end: Int, step: Int) extends Range

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

Исходный код

def isInclusive: Boolean

Наследованные методы

Исходный код

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. Обратите внимание, что операторы, оканчивающиеся на двоеточие, являются правоассоциативными (см. пример). Мnemonic для +: по сравнению с :+ таков: двоеточие ставится со стороны коллекции.

Исходный код

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

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

Исходный код

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]

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

Исходный код

final def apply(idx: Int): Int

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

Исходный код

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

Источник

final def by(step: Int): Range

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

Источник

override def canEqual(that: Any): Boolean

Метод, который должен вызываться из каждого хорошо спроектированного метода equals, который может быть переопределен в подклассе. См. Programming in Scala, Глава 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]

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

Исходный код

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

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

Источник

final def contains(x: Int): Boolean

Источник

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 значениями этой коллекции.

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

Source

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

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

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

Source

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

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

Источник

override def distinct: Range

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

Источник

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

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

Источник

final override def drop(n: Int): Range

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

Источник

final override def dropRight(n: Int): Range

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

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

Источник

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

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

Source

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
}

Source

override def empty: CC[A]

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

Source

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

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

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

Source

final override def equals(other: Any): Boolean

Универсальный метод равенства, определённый в AnyRef.

Source

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

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

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

Source

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

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

Source

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

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

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

Источник

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

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

Source

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

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

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

Source

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

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

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

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

Source

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)

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

Source

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 grouped(size: Int): Iterator[Range]

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

Исходный код

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.

Исходный код

final override def head: Int

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

Исходный код

override def headOption: Option[A]

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

Исходный код

final def inclusive: Range

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

final override def init: Range

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

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

Исходный код

override def inits: Iterator[Range]

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

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

Исходный код

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

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

Исходный код

override def iterableFactory: SeqFactory[IndexedSeq]

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

Исходный код

final override def iterator: Iterator[Int]

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

Исходный код

override def knownSize: Int

Исходный код

final override def last: Int

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

Исходный код

final override def lastIndexOf[B >: Int](elem: B, end: Int): 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 def length: Int

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

Исходный код

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.

Исходный код

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

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

Исходный код

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

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

Источник

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.

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

Источник

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

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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]

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

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

Source

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)

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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]

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

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

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

Источник

final override def reverse: Range

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

Источник

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

Источник

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

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

Источник

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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)

Источник

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

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

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

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

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

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

Источник

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

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

Сортировка стабильна. То есть, элементы, которые равны (как определено в 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).

Источник

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

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

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

Источник

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

Source

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

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

Source

final override def tail: Range

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

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

Source

override def tails: Iterator[Range]

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

Source

final override def take(n: Int): Range

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

Source

final override def takeRight(n: Int): Range

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

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

Source

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

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

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]

Источник

final override def toString: String

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

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

Источник

def toVector: Vector[A]

Источник

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

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

Источник

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

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

Источник

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

Источник

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

Источник

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

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

Источник

override def view: IndexedSeqView[A]

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

Источник

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

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

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

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

Источник

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

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

Источник

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

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

Источник

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

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

Унаследованные поля

Источник

final override val isEmpty: Boolean

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

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