Класс scala.collection.Map

@SerialVersionUID(3L)

class Map[+A, +B](underlying: SomeSeqOps[A], f: A => B) extends Map[A, B] with SeqView[B]

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

Исходный код

def apply(idx: Int): B

Исходный код

def length: Int

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

Исходный код@inline

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

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

Исходный код@inline

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

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

Исходный код@inline

final def +:[B >: B](elem: B): View[B]

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

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

Исходный код@inline

final def :+[B >: B](elem: B): View[B]

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

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

Исходный код@inline

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

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

Исходный код@inline

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

Исходный код@inline

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)

Исходный код

override def appended[B >: B](elem: B): SeqView[B]

Исходный код

def appendedAll[B >: B](suffix: SeqOps[B, AnyConstr, _]): SeqView[B]

Исходный код

def appendedAll[B >: B](suffix: IterableOnce[B]): View[B]

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

Источник

def collect[B](pf: PartialFunction[B, B]): View[B]

Источник

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

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

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

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

Источник

def combinations(n: Int): Iterator[View[B]]

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

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

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

Источник

def concat[B >: B](suffix: SeqOps[B, AnyConstr, _]): SeqView[B]

Источник@inline

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник@deprecatedOverriding("Это всегда должно перенаправлять на версию метода с 3 аргументами", since = "2.13.4")

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

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

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

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

Источник@deprecatedOverriding("Это всегда должно перенаправлять на версию метода с 3 аргументами", since = "2.13.4")

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

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

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

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

Источник

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

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

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

Источник

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

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

Источник

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

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

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

Источник

def diff[B >: B](that: Seq[B]): View[B]

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

Источник

def distinct: View[B]

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

Источник

def distinctBy[B](f: B => B): View[B]

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

Источник

override def drop(n: Int): SeqView[B]

Источник

override def dropRight(n: Int): SeqView[B]

Источник

def dropWhile(p: B => Boolean): View[B]

Источник

override def empty: View[B]

Источник

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

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

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

Источник

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

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

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

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

Источник

def filter(pred: B => Boolean): View[B]

Источник

def filterNot(pred: B => Boolean): View[B]

Источник

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

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

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

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

Источник

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

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

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

Источник

def flatMap[B](f: B => IterableOnce[B]): View[B]

Источник

def flatten[B](implicit asIterable: B => IterableOnce[B]): View[B]

Источник

def fold[A1 >: B](z: A1)(op: (A1, A1) => A1): A1

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

Источник

protected def fromSpecific(coll: IterableOnce[B]): View[B]

Источник

def groupBy[K](f: B => K): Map[K, View[B]]

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

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

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

Источник

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

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

Источник

def head: B

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

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

Источник

def headOption: Option[B]

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

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

Источник@deprecatedOverriding("Override indexOf(elem, from) instead - indexOf(elem) calls indexOf(elem, 0)", "2.13.0")

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

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

Источник

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

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

Источник@deprecatedOverriding("Override indexOfSlice(that, from) instead - indexOfSlice(that) calls indexOfSlice(that, 0)", "2.13.0")

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

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

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

Источник

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

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

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

Источник@deprecatedOverriding("Override indexWhere(p, from) instead - indexWhere(p) calls indexWhere(p, 0)", "2.13.0")

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

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

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

Источник

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

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

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

Источник

def indices: Range

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

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

Источник

def init: View[B]

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

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

Источник

def inits: Iterator[View[B]]

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

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

Источник

def intersect[B >: B](that: Seq[B]): View[B]

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

Источник

def isDefinedAt(idx: Int): Boolean

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

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

Источник

override def isEmpty: Boolean

Источник

override def isTraversableAgain: Boolean

Источник

override def iterableFactory: IterableFactory[View]

Источник

def iterator: Iterator[B]

Источник

override def knownSize: Int

Источник

def last: B

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

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

Источник

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

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

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

Источник@deprecatedOverriding("Override lastIndexOfSlice(that, end) instead - lastIndexOfSlice(that) calls lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

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

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

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

Источник

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

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

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

Источник@deprecatedOverriding("Override lastIndexWhere(p, end) instead - lastIndexWhere(p) calls lastIndexWhere(p, Int.MaxValue)", "2.13.0")

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

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

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

Источник

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

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

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

Source

def lastOption: Option[B]

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

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

Source

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

Аналогично 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 lengthCompare(that: Iterable[_]): Int

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

x <  0       if this.length <  that.size
x == 0       if this.length == that.size
x >  0       if this.length >  that.size

Source

def lengthCompare(len: Int): Int

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

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

Source@inline

final def lengthIs: SizeCompareOps

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

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

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

Source

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source@inline

final def mkString: String

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

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

Source@inline

final def mkString(sep: String): String

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

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

Источник

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

Отображает все элементы этого набора в строке, используя строки start, end и разделитель.

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

Источник

protected def newSpecificBuilder: Builder[B, View[B]]

Источник@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

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

Источник

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

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

Источник

def partition(p: B => Boolean): (View[B], View[B])

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

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

Источник

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

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

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

Источник

def permutations: Iterator[View[B]]

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

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

Источник

override def prepended[B >: B](elem: B): SeqView[B]

Источник

def prependedAll[B >: B](prefix: SeqOps[B, AnyConstr, _]): SeqView[B]

Источник

def prependedAll[B >: B](prefix: IterableOnce[B]): View[B]

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

override def reverse: SeqView[B]

Источник

def reverseIterator: Iterator[B]

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

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

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

Источник

protected def reversed: Iterable[B]

Источник

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

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

Источник

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

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

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

Источник

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

Источник

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

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

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

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

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

Пример:

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

final override def size: Int

Источник

final override def sizeCompare(that: Iterable[_]): Int

Источник

final override def sizeCompare(otherSize: Int): Int

Источник@inline

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

Источник

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

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

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

Источник

def sliding(size: Int): Iterator[View[B]]

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

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

Источник

def sortBy[B](f: B => B)(implicit ord: Ordering[B]): View[B]

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

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

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

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

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

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

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

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

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

Источник

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

Источник

def span(p: B => Boolean): (View[B], View[B])

Исходный код

override def splitAt(n: Int): (View[B], View[B])

Исходный код

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

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

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

Исходный код

def stepper[S <: Stepper[_]](implicit shape: StepperShape[B, 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 >: B](implicit num: Numeric[B]): B

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

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

Исходный код

def tail: View[B]

Остаток коллекции без ее первого элемента.

Исходный код

def tails: Iterator[View[B]]

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

Исходный код

override def take(n: Int): SeqView[B]

Исходный код

override def takeRight(n: Int): SeqView[B]

Исходный код

def takeWhile(p: B => Boolean): View[B]

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

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

Исходный код

override def tapEach[U](f: B => U): SeqView[B]

Исходный код

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

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

Примеры:

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

Исходный код

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

Преобразует коллекцию в массив.

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

Исходный код@inline

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

Исходный код

def toIndexedSeq: IndexedSeq[B]

Исходный код

def toList: List[B]

Источник

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

Источник

def toSeq: Seq[B]

Источник

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

Источник

override def toString: String

Источник

def toVector: Vector[B]

Источник

def transpose[B](implicit asIterable: B => Iterable[B]): View[View[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: B => (A1, A2)): (View[A1], View[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: B => (A1, A2, A3)): (View[A1], View[A2], View[A3])

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

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

Источник

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

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

Источник

override def view: SeqView[B]

Источник

def withFilter(p: B => Boolean): WithFilter[B, View]

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

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

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

Источник

def zip[B](that: IterableOnce[B]): View[(B, B)]

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

Источник

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

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

Источник

def zipWithIndex: View[(B, Int)]