Класс LinkedHashSet.LinkedHashSet

class LinkedHashSet[A] extends AbstractSet[A] with SetOps[A, LinkedHashSet, LinkedHashSet[A]] with StrictOptimizedIterableOps[A, LinkedHashSet, LinkedHashSet[A]] with IterableFactoryDefaults[A, LinkedHashSet] with DefaultSerializable

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

Типы

Исходный код

type Entry = Entry[A]

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

Исходный код

def addOne(elem: A): LinkedHashSet.this.type

Добавляет один элемент в это связное хэш-множество.

Исходный код

override def clear(): Unit

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

Исходный код

def contains(elem: A): Boolean

Исходный код

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

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

Исходный код

override def head: A

Выбирает первый элемент этого связанного хэш-множества.

Исходный код

override def headOption: Option[A]

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

Исходный код

override def isEmpty: Boolean

Проверяет, пусто ли связное хэш-множество.

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

Исходный код

override def iterableFactory: IterableFactory[LinkedHashSet]

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

Исходный код

def iterator: Iterator[A]

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

Исходный код

override def knownSize: Int

Исходный код

override def last: A

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

Исходный код

override def lastOption: Option[A]

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

Source

override def remove(elem: A): Boolean

Удаляет элемент из этого набора.

Source

override def size: Int

Размер этого связанного набора хеш-множеств.

Source

def subtractOne(elem: A): LinkedHashSet.this.type

Удаляет один элемент из этого связанного набора хеш-множеств.

Наследуемые методы

Source

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

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

Source

final def &~(that: Set[A]): C

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

Source

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

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

Source

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

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

Source

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

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

Source

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

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

Source

final def --=(xs: IterableOnce[A]): Shrinkable.this.type

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

Source

final def -=(elem: A): Shrinkable.this.type

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

Source

def add(elem: A): Boolean

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

Source

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

Добавляет все элементы, полученные из IterableOnce, в это растущее коллекцию.

Source

final def addString(b: StringBuilder): StringBuilder

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

Пример:

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

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

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

Source

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

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

Пример:

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

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

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

Source

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

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

Пример:

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

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

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

Source

def andThen[A](g: Boolean => A): T1 => A

Соединяет два экземпляра Function1 в новый Function1, где сначала применяется этот метод.

Source

final def apply(elem: A): Boolean

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

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

Source

def canEqual(that: Any): Boolean

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

Source

override def clone(): C

Создаёт копию объекта-приёмника.

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

Source

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

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

Source

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

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

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

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

Source

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

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

Source

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

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

Source

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)

Source

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 значениями этого набора.

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

Источник

def drop(n: Int): C

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

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

Источник

override def dropRight(n: Int): C

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

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

Источник

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

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

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

Источник

override def empty: CC[A]

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

Источник

override def equals(that: Any): Boolean

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

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

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

• для каждого element этого множества, 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 exists(p: A => Boolean): Boolean

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

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

Источник

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

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

Источник

def filterInPlace(p: A => Boolean): SetOps.this.type

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

Источник

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

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

Источник

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

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

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

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

Источник

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

Источник

override def flatten[B](implicit toIterableOnce: 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

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

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

Источник

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)(_ + _)

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

Source

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

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

Source

override def hashCode(): Int

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

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

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

Source

def init: C

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

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

Source

def inits: Iterator[C]

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

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

Source

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

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

Source

override def isTraversableAgain: Boolean

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

Source

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

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

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

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

Исходный код

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

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

Исходный код

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

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

Исходный код

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.

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

Источник

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

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

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

Источник

override 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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

def result(): C

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

Source

protected def reversed: Iterable[A]

Source

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

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

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

Source

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

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

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

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

Source

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

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

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

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

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

Пример:

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

Source

def 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 sizeHint(coll: IterableOnce[_], delta: Int): Unit

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

Источник

def sizeHint(size: Int): Unit

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

Источник

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

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

Источник

final def sizeIs: SizeCompareOps

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

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

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

Source

def slice(from: Int, until: Int): C

Выбирает интервал элементов. Возвращаемая итерируемая коллекция содержит все элементы x, которые удовлетворяют следующему условию:

from <= indexOf(x) < until

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

Source

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

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

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

Source

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

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

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

Source

override def span(p: A => Boolean): (C, C)

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

Примечание: c span p эквивалентно (но, возможно, более эффективно) (c takeWhile p, c dropWhile p), при условии, что вычисление предиката p не вызывает побочных эффектов.

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

Исходный код

override def splitAt(n: Int): (C, C)

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

Примечание: c splitAt n эквивалентно (но, возможно, более эффективно), чем (c take n, c drop n).

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

Исходный код

def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S

Возвращает scala.collection.Stepper для элементов этого набора.

Stepper позволяет создавать Java-поток для работы с набором, см. scala.jdk.StreamConverters. Для наборов, содержащих примитивные значения, Stepper можно использовать как итератор, который не упаковывает элементы.

Неявный параметр scala.collection.StepperShape определяет тип возвращаемого Stepper в соответствии с типом элементов этого набора.

• Для наборов Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для наборов Double или Float, возвращается scala.collection.DoubleStepper

• Для наборов Long, возвращается scala.collection.LongStepper

• Для любого другого типа элементов возвращается scala.collection.AnyStepper

Обратите внимание, что этот метод переопределяется в подклассах, и тип возвращаемого значения уточняется до S with EfficientSplit, например, scala.collection.IndexedSeqOps.stepper. Для Stepper, помеченных scala.collection.Stepper.EfficientSplit, преобразователи в scala.jdk.StreamConverters позволяют создавать параллельные потоки, в то время как обычные Stepper могут преобразовываться только в последовательные потоки.

Исходный код

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

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

Исходный код

def subsets(): Iterator[C]

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

Исходный код

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

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

Исходный код

def subtractAll(xs: IterableOnce[A]): Shrinkable.this.type

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

Источник

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

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

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

Источник

def tail: C

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

Источник

def tails: Iterator[C]

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

Источник

def take(n: Int): C

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

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

Источник

override 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

Используя фабрику коллекций factory, преобразуйте этот набор в соответствующее представление для текущего типа элемента 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]

Источник

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

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

Источник

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

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

Источник

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

Источник

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

Источник

def update(elem: A, included: Boolean): Unit

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

Этот метод позволяет добавить или удалить элемент elem из этого множества в зависимости от значения параметра included. Обычно используется следующий синтаксис:

set(elem) = true  // adds element
set(elem) = false // removes element

Источник

def view: View[A]

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

Источник

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

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

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

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

Источник

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

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

Источник

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

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

Источник

override def zipWithIndex: CC[(A, Int)]

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

Источник

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

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