Класс scala.collection.mutable.LinkedHashSet

класс LinkedHashSet[A] extends AbstractSet[A] с SetOps[A, LinkedHashSet, LinkedHashSet[A]] с StrictOptimizedIterableOps[A, LinkedHashSet, LinkedHashSet[A]] с IterableFactoryDefaults[A, LinkedHashSet] с DefaultSerializable

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

Типы

Исходный код

Тип Entry = Entry[A]

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

Исходный код

def addOne(elem: A): LinkedHashSet[A]

Исходный код

переопределение def clear(): Unit

Исходный код

def contains(elem: A): Boolean

Исходный код

переопределение def foreach[U](f: A => U): Unit

Исходный код

переопределение def head: A

Исходный код

переопределение def headOption: Option[A]

Исходный код

переопределение def isEmpty: Boolean

Исходный код

переопределение def iterableFactory: IterableFactory[LinkedHashSet]

Исходный код

def iterator: Iterator[A]

Исходный код

переопределение def knownSize: Int

Исходный код

переопределение def last: A

Исходный код

переопределение def lastOption: Option[A]

Исходный код

переопределение def remove(elem: A): Boolean

Исходный код

переопределение def size: Int

Исходный код

def subtractOne(elem: A): LinkedHashSet[A]

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

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

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

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

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

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

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

Source@inline

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

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

Source@inline

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

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

Source@inline

final def ++=(xs: IterableOnce[A]): LinkedHashSet[A]

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

Source@inline

final def +=(elem: A): LinkedHashSet[A]

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

Source@inline

final def --=(xs: IterableOnce[A]): LinkedHashSet[A]

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

Source@inline

final def -=(elem: A): LinkedHashSet[A]

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

Source

def add(elem: A): Boolean

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

Source

def addAll(xs: IterableOnce[A]): LinkedHashSet[A]

Добавляет все элементы, полученные от IterableOnce, в это изменяемое множество.

Source@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

Source@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

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@unspecialized

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

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

Source@inline

final def apply(elem: A): Boolean

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

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

Source

def canEqual(that: Any): Boolean

Source

override def clone(): LinkedHashSet[A]

Source

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

Source

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

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

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

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

Source@unspecialized

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

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

Source

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

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

Source

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

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

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

Пример:

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@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

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

Source@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

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

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

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

Источник

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

Источник

def drop(n: Int): LinkedHashSet[A]

Источник

override def dropRight(n: Int): LinkedHashSet[A]

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

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

Источник

def dropWhile(p: A => Boolean): LinkedHashSet[A]

Источник

override def empty: LinkedHashSet[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): LinkedHashSet[A]

Источник

def filterInPlace(p: A => Boolean): LinkedHashSet[A]

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

Источник

override def filterNot(pred: A => Boolean): LinkedHashSet[A]

Источник

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

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

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

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

Источник

override def flatMap[B](f: A => IterableOnce[B]): LinkedHashSet[B]

Источник

override def flatten[B](implicit toIterableOnce: A => IterableOnce[B]): LinkedHashSet[B]

Источник

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

Источник

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

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

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

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

Источник

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

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

Источник

override def hashCode(): Int

Источник

def init: LinkedHashSet[A]

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

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

Source

def inits: Iterator[LinkedHashSet[A]]

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

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

Source

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

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

Source

override def isTraversableAgain: Boolean

Source

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

Аналогично 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

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

Source

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Source@inline

final def mkString: String

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

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

Source@inline

final def mkString(sep: String): String

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

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

Source

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

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

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

Source

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

Source@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

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

Source

override def partition(p: A => Boolean): (LinkedHashSet[A], LinkedHashSet[A])

Source

override def partitionMap[A1, A2](f: A => Either[A1, A2]): (LinkedHashSet[A1], LinkedHashSet[A2])

Source

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

Перемножает элементы этого набора.

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

Source

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]

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

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

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

Источник

def result(): LinkedHashSet[A]

Источник

protected def reversed: Iterable[A]

Источник

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

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

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

Источник

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

Источник

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

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

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

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

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

Пример:

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

Источник

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 вместе с верхним пределом, заданным размером другого набора. Некоторые классы билдеров будут оптимизировать свою структуру на основе подсказки. Однако реализации билдеров по-прежнему должны работать правильно, даже если подсказка неверна, то есть добавлено другое количество элементов.

Источник@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): LinkedHashSet[A]

Исходный код

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

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

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

Исходный код

def sliding(size: Int): Iterator[LinkedHashSet[A]]

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

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

Исходный код

override def span(p: A => Boolean): (LinkedHashSet[A], LinkedHashSet[A])

Исходный код

override def splitAt(n: Int): (LinkedHashSet[A], LinkedHashSet[A])

Исходный код

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[LinkedHashSet[A]]

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

Источник

def subsets(len: Int): Iterator[LinkedHashSet[A]]

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

Источник

def subtractAll(xs: IterableOnce[A]): LinkedHashSet[A]

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

Источник

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

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

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

Источник

def tail: LinkedHashSet[A]

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

Источник

def tails: Iterator[LinkedHashSet[A]]

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

Источник

def take(n: Int): LinkedHashSet[A]

Источник

override def takeRight(n: Int): LinkedHashSet[A]

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

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

Источник

def takeWhile(p: A => Boolean): LinkedHashSet[A]

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

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

Источник

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

Источник

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

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

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

Источник

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

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

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

Source@inline

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

Source

def toIndexedSeq: IndexedSeq[A]

Source

def toList: List[A]

Source

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

Source

def toSeq: Seq[A]

Source

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

Source

override def toString(): String

Source

def toVector: Vector[A]

Source

def transpose[B](implicit asIterable: A => Iterable[B]): LinkedHashSet[LinkedHashSet[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@inline

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

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

Source

override def unzip[A1, A2](implicit asPair: A => (A1, A2)): (LinkedHashSet[A1], LinkedHashSet[A2])

Source

override def unzip3[A1, A2, A3](implicit asTriple: A => (A1, A2, A3)): (LinkedHashSet[A1], LinkedHashSet[A2], LinkedHashSet[A3])

Source

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

Обновляет наличие отдельного элемента в этом множестве.

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

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

Source

def view: View[A]

Представление элементов этой коллекции.

Source

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

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

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

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

Source

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

Source

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

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

Source

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

Source@inline

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

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