Класс LongAccumulator.LongAccumulator

final class LongAccumulator extends Accumulator[Long, AnyAccumulator, LongAccumulator] with SeqOps[Long, AnyAccumulator, LongAccumulator] with Serializable

Специализированный Accumulator, который хранит Long без боксрования, см. Accumulator.

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

Исходный код

def addOne(a: Long): LongAccumulator.this.type

Добавляет элемент в этот LongAccumulator.

Исходный код

def apply(ix: Long): Long

Возвращает ix-й элемент.

Исходный код

def apply(i: Int): Long

Возвращает ix-й элемент, используя Int индекс.

Исходный код

override def clear(): Unit

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

Исходный код

def collect(pf: PartialFunction[Long, Long]): LongAccumulator

Исходный код

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

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

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

Исходный код

def countLong(p: Long => Boolean): Long

Исходный код

def drain(that: LongAccumulator): Unit

Удаляет все элементы из that и добавляет их в этот LongAccumulator.

Исходный код

def efficientStepper[S <: Stepper[_]](implicit shape: StepperShape[Long, S]): S & EfficientSplit

Исходный код

override def empty: LongAccumulator

Пустой итератор того же типа, что и этот итератор

Исходный код

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

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

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

Исходный код

override def filter(pred: Long => Boolean): LongAccumulator

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

Исходный код

override def filterNot(pred: Long => Boolean): LongAccumulator

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

Источник

def flatMap(f: Long => IterableOnce[Long]): LongAccumulator

Источник

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

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

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

Источник

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

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

Источник

override def iterableFactory: SeqFactory[AnyAccumulator]

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

Источник

def iterator: Iterator[Long]

Возвращает Iterator над содержимым этой LongAccumulator. Iterator не специализирована.

Источник

def map(f: Long => Long): LongAccumulator

Источник

override def result(): LongAccumulator

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

Источник

override def to[C1](factory: Factory[Long, C1]): C1

Копирует элементы в этой LongAccumulator в указанную коллекцию. Обратите внимание, что целевая коллекция не специализирована. Пример использования: acc.to(Vector)

Источник

def toArray: Array[Long]

Копирует элементы этой LongAccumulator в Array[Long].

Источник

override def toList: List[Long]

Копирует элементы этой LongAccumulator в List.

Источник

def update(idx: Long, elem: Long): Unit

Источник

def update(idx: Int, elem: Long): Unit

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

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

Источник

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

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

Источник

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

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

Источник

final def ++=(xs: IterableOnce[Long]): Growable.this.type

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

Источник

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

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

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

Источник

final def +=(elem: Long): Growable.this.type

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

Источник

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

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

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

Источник

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

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

Source

def addAll(xs: IterableOnce[Long]): Growable.this.type

Добавляет все элементы, полученные из IterableOnce, в это изменяемое множество.

Source

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

Source

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

Source

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)

Source

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

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

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

Источник

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

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

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

Источник

def appended[B >: Long](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 >: Long](suffix: IterableOnce[B]): CC[B]

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

Источник

def applyOrElse[A1 <: Int, B1 >: Long](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 для обсуждения и проектирования.

Источник

override def clone(): C

Создает копию объекта-получателя.

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

Источник

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

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

Источник

def collectFirst[B](pf: PartialFunction[Long, 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 >: Long](suffix: IterableOnce[B]): CC[B]

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

Источник

def contains[A1 >: Long](elem: A1): Boolean

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

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

Источник

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

Источник

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

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

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

Источник

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

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

Источник

def distinct: C

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

Источник

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

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

Источник

def drop(n: Int): C

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

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

Source

def dropRight(n: Int): C

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

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

Source

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

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

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

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

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

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

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

Source

override def equals(o: Any): Boolean

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

Source

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

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

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

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

Source

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

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

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

Исходный код

def flatMap[B](f: Long => 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: Long => 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 >: Long](z: A1)(op: (A1, A1) => A1): A1

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

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

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

Исходный код

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

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

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

Источник

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

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

Source

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

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

Source

override def hashCode(): Int

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

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

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

Source

def head: A

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

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

Source

def headOption: Option[A]

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

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

Source

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

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

Source

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

def indices: Range

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

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

Исходный код

def init: C

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

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

Источник

def inits: Iterator[C]

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

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

Источник

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

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

Источник

def isDefinedAt(idx: Int): Boolean

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

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

Источник

override def isEmpty: Boolean

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

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

Источник

override def isTraversableAgain: Boolean

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

Источник

final override def knownSize: Int

Источник

def last: A

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

def lastOption: Option[A]

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

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

Источник

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

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

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

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

Источник

final override def length: Int

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

Источник

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

Источник

def lengthCompare(len: Int): Int

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

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

Исходный код

final def lengthIs: SizeCompareOps

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

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

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

Исходный код

def lift: A => Option[B]

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

Исходный код

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

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

Исходный код

def mapResult[NewTo](f: LongAccumulator => NewTo): Builder[A, NewTo]

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

Исходный код

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

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

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

Исходный код

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Исходный код

def minOption[B >: Long](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, который может быть переопределён.

Исходный код

def nonEmpty: Boolean

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

def partitionMap[A1, A2](f: Long => 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 >: Long](from: Int, other: IterableOnce[B], replaced: Int): CC[B]

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

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

Исходный код

def permutations: Iterator[C]

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

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

Исходный код

def prepended[B >: Long](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 >: Long](prefix: IterableOnce[B]): CC[B]

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Исходный код

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

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

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

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

Источник

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

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

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

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

Источник

def reverse: C

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

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

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

Источник

def reverseIterator: Iterator[A]

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

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

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

Источник

protected def reversed: Iterable[A]

Источник

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

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

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

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

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

Пример:

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

Источник

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

final override def size: Int

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

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

Source

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

Source

final override def sizeCompare(otherSize: Int): Int

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

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

Source

final def sizeHint(coll: IterableOnce[_], delta: Int): Unit

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

Source

def sizeHint(size: Int): Unit

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

Source

final def sizeHintBounded(size: Int, boundingColl: Iterable[_]): Unit

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

Source

final def sizeIs: SizeCompareOps

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

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

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

Source

final def sizeLong: Long

Размер накопленной коллекции, как Long

Исходный код

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: Long => 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: (Long, Long) => Boolean): C

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

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

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

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

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

Исходный код

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

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

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

Исходный код

def span(p: Long => 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 >: Long](that: IterableOnce[B], offset: Int): Boolean

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

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

Источник

final override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Long, 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 могут быть преобразованы только в последовательные потоки.

Источник

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

Суммирует элементы этого набора.

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

Источник

def tail: C

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

Источник

def tails: Iterator[C]

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

Источник

def take(n: Int): C

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

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

Источник

def takeRight(n: Int): C

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

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

Источник

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

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

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

Источник

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

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

Источник

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

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

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

Источник

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

Источник

def toIndexedSeq: IndexedSeq[A]

Source

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

Source

def toSeq: Seq[A]

Source

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

Source

override def toString(): String

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

Стандартное представление зависит от платформы.

Source

def toVector: Vector[A]

Source

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

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

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

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

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

Source

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

Source

override def view: SeqView[A]

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

Source

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

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

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

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

Source

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

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

Источник

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

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

Источник

def zipWithIndex: CC[(A, Int)]

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