Тракт LinearSeq.LinearSeq

тракт LinearSeq[+A] extends Seq[A] with LinearSeq[A] with LinearSeqOps[A, LinearSeq, LinearSeq[A]] with IterableFactoryDefaults[A, LinearSeq]

Базовый тракт для неизменяемых линейных последовательностей, обладающих эффективной head и tail

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

Исходный код

переопределение def iterableFactory: SeqFactory[LinearSeq]

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

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

Исходный код

конечный def ++[B >: A](suffix: IterableOnce[B]): CC[B]

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

Исходный код

конечное переопределение def ++:[B >: A](prefix: IterableOnce[B]): CC[B]

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

Исходный код

конечный def +:[B >: A](elem: B): CC[B]

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

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

Исходный код

конечный def :+[B >: A](elem: B): CC[B]

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

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

Исходный код

конечный def :++[B >: A](suffix: IterableOnce[B]): CC[B]

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

Исходный код

конечный 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

Исходный код

конечный 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[A, C]): PartialFunction[A, C]

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

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

Исходный код

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

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

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

Исходный код

def appended[B >: A](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)

Исходный код

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

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

Исходный код

override def apply(n: Int): A

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

Исходный код

def applyOrElse[A1 <: Int, B1 >: A](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 . Это может привести к лучшей производительности и более предсказуемому поведению в отношении побочных эффектов.

Исходный код

def canEqual(that: Any): Boolean

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

Исходный код

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Source

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

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

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

Source

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

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

Source

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

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

Source

override def contains[A1 >: A](elem: A1): Boolean

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

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

Source

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

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

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

Source

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Source

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

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

Source

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

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

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

Source

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

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

Source

def distinct: C

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

Source

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

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

Source

def drop(n: Int): C

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

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

Source

def dropRight(n: Int): C

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

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

Источник

def dropWhile(p: A => Boolean): C

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

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

Источник

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 >: A](that: Iterable[B]): Boolean

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

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

Источник

override def equals(o: Any): Boolean

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

Источник

override def exists(p: A => Boolean): Boolean

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

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

Источник

def filter(pred: A => Boolean): C

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

Источник

def filterNot(pred: A => Boolean): C

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

Источник

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

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

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

Источник

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

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

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

Источник

def flatMap[B](f: A => 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)

Исходный код

def flatten[B](implicit asIterable: A => 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 >: A](z: A1)(op: (A1, A1) => A1): A1

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Source

override def forall(p: A => Boolean): Boolean

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

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

Source

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

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

Source

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

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

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

Source

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

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

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

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

Source

def groupMap[K, B](key: A => K)(f: A => 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: A => K)(f: A => 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)(_ + _)

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

Источник

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

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

Источник

override def hashCode(): Int

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

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

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

Источник

def head: A

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

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

Источник

override def headOption: Option[A]

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

Источник

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

def indices: Range

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

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

Источник

def init: C

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

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

Источник

def inits: Iterator[C]

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

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

Источник

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

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

Источник

override def isDefinedAt(x: Int): Boolean

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

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

Источник

override def isEmpty: Boolean

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

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

Источник

override def isTraversableAgain: Boolean

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

Исходный код

def iterator: Iterator[A]

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

Исходный код

def knownSize: Int

Исходный код

override def last: A

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Источник

def lastIndexWhere(p: A => Boolean): 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)

Источник

def length: Int

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

Источник

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

Source

override def lengthCompare(len: Int): Int

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

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

Source

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

Source

def lift: A => Option[B]

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

Source

def map[B](f: A => B): CC[B]

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

Source

def max[B >: A](implicit ord: Ordering[B]): A

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

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

Source

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

def min[B >: A](implicit ord: Ordering[B]): A

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

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

Источник

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

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

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

Источник

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

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

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

Источник

def minOption[B >: A](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 >: A](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

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

Источник

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

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

Источник

def partition(p: A => Boolean): (C, C)

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

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

Источник

def partitionMap[A1, A2](f: A => 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))

Источник

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

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

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

Источник

def permutations: Iterator[C]

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

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

Источник

def prepended[B >: A](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)

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

def reverse: C

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

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

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

Source

def reverseIterator: Iterator[A]

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

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

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

Source

protected def reversed: Iterable[A]

Source

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

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

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

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

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

Source

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

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

Source

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

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

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

Source

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

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

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

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

Source

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

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

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

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

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

Пример:

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

Source

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

final def segmentLength(p: A => 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

Исходный код

def slice(from: Int, until: Int): C

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

from <= indexOf(x) < until

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

Исходный код

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

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

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

Источник

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

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

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

Источник

def sortBy[B](f: A => 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: (A, A) => Boolean): C

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

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

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

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

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

Источник

def sorted[B >: A](implicit ord: Ordering[B]): C

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

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

Источник

def span(p: A => Boolean): (C, C)

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

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

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

Источник

override def splitAt(n: Int): (C, C)

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

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

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

Источник

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

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

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

Источник

def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S

Возвращает 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. Для шагов, помеченных scala.collection.Stepper.EfficientSplit, преобразователи в scala.jdk.StreamConverters позволяют создавать параллельные потоки, в то время как обычные шаги могут быть преобразованы только в последовательные потоки.

Исходный код

def sum[B >: A](implicit num: Numeric[B]): B

Вычисляет сумму элементов этого набора.

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

Исходный код

def tail: C

Остальная часть набора без первого элемента.

Исходный код

override def tails: Iterator[C]

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

Исходный код

def take(n: Int): C

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

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

Исходный код

def takeRight(n: Int): C

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

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

Исходный код

def takeWhile(p: A => Boolean): C

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

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

def toIndexedSeq: IndexedSeq[A]

Исходный код

def toList: List[A]

Исходный код

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

Исходный код

final override def toSeq: Seq.this.type

Исходный код

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

Исходный код

override def toString(): String

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

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

Источник

def toVector: Vector[A]

Источник

def transpose[B](implicit asIterable: A => 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 в выражении сопоставления с образцом.

Источник

def unzip[A1, A2](implicit asPair: A => (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))

Источник

def unzip3[A1, A2, A3](implicit asTriple: A => (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))

Источник

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

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

Источник

override def view: SeqView[A]

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

Источник

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

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

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

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

Источник

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

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

Источник

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

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

Исходный код

def zipWithIndex: CC[(A, Int)]

Объединяет этот набор итераций с его индексами.