Trait SortedSet.SortedSet

trait SortedSet[A] extends Множество[A] with SortedSetOps[A, SortedSet, SortedSet[A]] with SortedSetFactoryDefaults[A, SortedSet, Множество]

Базовый тип упорядоченных множеств

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

Исходный код

override def equals(that: Any): Boolean

Равенство множеств реализуется с помощью метода поиска contains. Этот метод возвращает true если

• аргумент that является Set,

• два множества имеют одинаковый размер, и

• для каждого элемента в этом множестве, other.contains(element) == true.

Реализация equals проверяет метод canEqual, поэтому подклассы Set могут сузить равенство до определённых типов множеств. Реализации Set в стандартной библиотеке могут быть все сравнимы, их методы canEqual возвращают true.

Примечание: Метод equals соблюдает законы равенства (симметрия, транзитивность) только в том случае, если два множества используют одну и ту же функцию эквивалентности элементов в операции поиска. Например, операция эквивалентности элементов в scala.collection.immutable.TreeSet определяется его порядком. Сравнение TreeSet с HashSet приводит к неожиданным результатам, если ordering.equiv(e1, e2) (используемая для поиска в TreeSet) отличается от e1 == e2 (используемой для поиска в HashSet).

scala> import scala.collection.immutable._
scala> val ord: Ordering[String] = _ compareToIgnoreCase _

scala> TreeSet("A")(ord) == HashSet("a")
val res0: Boolean = false

scala> HashSet("a") == TreeSet("A")(ord)
val res1: Boolean = true

Исходный код

def sortedIterableFactory: SortedIterableFactory[SortedSet]

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

Исходный код

def unsorted: Множество[A]

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

Исходный код

final def &(that: Множество[A]): C

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

Исходный код

final def &~(that: Множество[A]): C

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

Исходный код

final def ++(that: IterableOnce[A]): C

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

Исходный код

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 andThen[A](g: Boolean => A): T1 => A

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

Исходный код

final def apply(elem: A): Boolean

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

Этот метод эквивалентен contains. Он позволяет интерпретировать наборы как предикаты.

Исходный код

def canEqual(that: Any): Boolean

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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

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

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

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

Источник

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

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

Источник

def concat(that: IterableOnce[A]): C

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

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

Пример:

scala> val a = Set(1, 2) concat Set(2, 3)
a: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

Источник

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

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

Источник

def contains(elem: A): Boolean

Источник

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

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

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

Source

def diff(that: Set[A]): C

Вычисляет разность этого набора и другого набора.

Source

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 firstKey: A

Возвращает первый ключ коллекции.

Источник

def flatMap[B](f: (A) => IterableOnce[B])(implicit ev: Ordering[B]): CC[B]

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

Источник

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.

Источник

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

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

Источник

override def hashCode(): Int

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

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

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

Источник

def head: A

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

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

Источник

def headOption: Option[A]

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

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

Источник

def init: C

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

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

Источник

def inits: Iterator[C]

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

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

Источник

def intersect(that: Set[A]): C

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

Источник

def isEmpty: Boolean

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

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

Источник

override def isTraversableAgain: Boolean

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

Источник

override def iterableFactory: IterableFactory[Set]

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

Источник

def iterator: Iterator[A]

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

Источник

def iteratorFrom(start: A): Iterator[A]

Создает итератор, содержащий все значения из этой коллекции, большие или равные start в соответствии с порядком этой коллекции. x.iteratorFrom(y) эквивалентно, но обычно будет эффективнее, чем x.from(y).iterator

Источник

def knownSize: Int

Источник

def last: A

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

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

Источник

def lastKey: 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)(implicit ev: Ordering[B]): CC[B]

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

Источник

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

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

Источник

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

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

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

Источник

def maxBefore(key: A): Option[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.

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

def minAfter(key: A): Option[A]

Найти наименьший элемент, больший или равный заданному ключу.

Исходный код

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, которое может быть переопределено.

Исходный код

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

Исходный код

def nonEmpty: Boolean

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

Исходный код

def ordering: Ordering[A]

Исходный код

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 range(from: A, until: A): C

Создаёт проекцию диапазона этой коллекции с нижней и верхней границами.

Исходный код

def rangeFrom(from: A): C

Создаёт проекцию диапазона этой коллекции без верхней границы.

Исходный код

def rangeImpl(from: Option[A], until: Option[A]): C

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

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

Исходный код

def rangeTo(to: A): C

Создаёт проекцию диапазона этой коллекции без нижней границы.

Исходный код

def rangeUntil(until: A): C

Создаёт проекцию диапазона этой коллекции без нижней границы.

Исходный код

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

Источник

def subsetOf(that: Set[A]): Boolean

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

Источник

def subsets(): Iterator[C]

Итератор по всем подмножествам этого множества.

Источник

def subsets(len: Int): Iterator[C]

Итератор по всем подмножествам этого множества заданного размера. Если запрашиваемый размер недопустим, возвращается пустой итератор.

Источник

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. Примеры использования:

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]

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

final def union(that: Set[A]): C

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

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

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

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

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

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

Source

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

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

Source

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

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

Исходный код

final def |(that: Set[A]): C

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