Класс AbstractIterable.AbstractIterable

abstract class AbstractIterable[A] extends AbstractIterable[A] with Iterable[A]

Явное создание экземпляра Iterable для уменьшения размера файла класса в подклассах.

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

Источник

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

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

Источник

final def addString(b: StringBuilder): StringBuilder

Добавляет все элементы этого набора в строку-построитель. Записываемый текст состоит из строковых представлений (с помощью метода toString) всех элементов этого набора без разделительной строки.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> val h = a.addString(b)
h: StringBuilder = 1234

Источник

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

Добавляет все элементы этого набора в строковый построитель с разделительной строкой. Записываемый текст состоит из строковых представлений (с помощью метода toString) всех элементов этого набора, разделенных строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b, ", ")
res0: StringBuilder = 1, 2, 3, 4

Источник

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

Добавляет все элементы этого набора в строковый построитель, используя начальную, конечную и разделительные строки. Записываемый текст начинается со строки start и заканчивается строкой end. Внутри строковые представления (с помощью метода toString) всех элементов этого набора разделяются строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b , "List(" , ", " , ")")
res5: StringBuilder = List(1, 2, 3, 4)

Источник

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

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

Источник

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

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

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

Источник

def drop(n: Int): C

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

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

Источник

def dropRight(n: Int): C

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

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

Источник

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

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

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

Источник

override def empty: CC[A]

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

Источник

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

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

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

Источник

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

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

Источник

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

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

Источник

def find(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, но может быть переопределена для более эффективного порядка обхода.

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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)

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

Источник

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]

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

Источник

def head: A

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

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

Источник

def headOption: Option[A]

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

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

Источник

def init: C

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

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

Источник

def inits: Iterator[C]

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

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

Источник

def isEmpty: Boolean

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

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

Источник

override def isTraversableAgain: Boolean

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

Источник

override def iterableFactory: IterableFactory[Iterable]

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

Источник

def iterator: Iterator[A]

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

Источник

def knownSize: Int

Источник

def last: A

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

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

Source

def lastOption: Option[A]

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

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

Source

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)

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.

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

final def mkString: String

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

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

Source

final def mkString(sep: String): String

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

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

Source

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

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

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

Source

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

Source

def nonEmpty: Boolean

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

Source

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

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

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

Source

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

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

Source

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

Возвращает значение бинарного оператора к элементам этого набора, слева направо.

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

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

Source

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

protected def reversed: Iterable[A]

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 size: Int

Размер этого набора.

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

Source

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

Исходный код

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

Source

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

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

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

Source

def tail: C

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

Source

def tails: Iterator[C]

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

Source

def take(n: Int): C

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

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

Source

def takeRight(n: Int): C

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

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

Source

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

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

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

Source

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

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

Source

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

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

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

Source

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

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

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

Source

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

Source

def toIndexedSeq: IndexedSeq[A]

Source

def toList: List[A]

Source

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

Source

def toSeq: Seq[A]

Source

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

Source

override def toString: String

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

Source

def toVector: Vector[A]

Source

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

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

Source

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

Source

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

Source

def view: View[A]

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

Source

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

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

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

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

Source

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

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

Source

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

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

Source

def zipWithIndex: CC[(A, Int)]

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