Класс View.Concat

class Concat[A](prefix: SomeIterableOps[A], suffix: SomeIterableOps[A]) extends AbstractView[A]

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

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

Исходный код

override def isEmpty: Boolean

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

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

Исходный код

def iterator: Iterator[A]

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

Исходный код

override def knownSize: Int

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

Исходный код

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

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 collect[B](pf: PartialFunction[A, B]): CC[B]

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

Source

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

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

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

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

Source

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

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

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

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

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

Исходный код

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: View[A]

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

Исходный код

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

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

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

Исходный код

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

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

Source

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

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

Source

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

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

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

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

Source

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)

Source

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)

Source

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]

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

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

Исходный код

def init: C

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

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

Исходный код

def inits: Iterator[C]

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

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

Исходный код

override def isTraversableAgain: Boolean

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

Исходный код

override def iterableFactory: IterableFactory[View]

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

Исходный код

def last: A

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

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

Исходный код

def lastOption: Option[A]

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

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

Источник

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

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

Источник

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

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

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

Источник

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.

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

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]

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

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

Источник

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Исходный код

protected def reversed: Iterable[A]

Исходный код

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

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

Пример:

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

Исходный код

def size: Int

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

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

Исходный код

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

Источник

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

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

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

Источник

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

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

Источник

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

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

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]

Источник

def toSeq: Seq[A]

Источник

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

Источник

override def view: View[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)]

Объединяет эту итерируемую коллекцию с её индексами.