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

Проверка двух объектов на неравенство.

Эквивалентно x.hashCode за исключением упакованных числовых типов и null. Для чисел возвращает значение хэша, согласованное с равенством значений: если два экземпляра типа значения сравниваются как true, то ## для каждого из них вернёт одинаковое значение хэша. Для null возвращает код хэша, где null.hashCode выбрасывает NullPointerException.

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

Примечание: То же, что и intersect.

Разность этого множества и другого множества.

Примечание: То же, что и diff.

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

Дубликаты (элементы, для которых equals возвращает true) будут удалены, но не указано, будет ли это элемент из исходного множества или новый добавленный элемент.

Создаёт новое множество, состоящее из всех элементов этого множества и elem.

Дубликаты (элементы, для которых equals возвращает true) будут удалены, но не указано, будет ли это элемент из исходного множества или новый добавленный элемент.

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

Дубликаты (элементы, для которых equals возвращает true) будут удалены, но не указано, будет ли это элемент из исходного множества или новый добавленный элемент.

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

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

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

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

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

Так как TraversableOnce не имеет метода ++, нам нужно реализовать его напрямую, но Traversable и ниже могут использовать перегруз.

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

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

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

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

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

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

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

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

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

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

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

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

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

Примечание: /: — это альтернативная запись для foldLeft; z /: xs — то же самое, что и xs foldLeft z.

Примеры:

Обратите внимание, что функция свёртки, используемая для вычисления b, эквивалентна функции, используемой для вычисления c.

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

scala> val b = (5 /: a)(_+_)
b: Int = 15

scala> val c = (5 /: a)((x,y) => x + y)
c: Int = 15

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

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

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

Примечание: :\ — это альтернативная запись для foldRight; xs :\ z — то же самое, что и xs foldRight z.

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

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

Примеры:

Обратите внимание, что функция свёртки, используемая для вычисления b, эквивалентна функции, используемой для вычисления c.

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

scala> val b = (a :\ 5)(_+_)
b: Int = 15

scala> val c = (a :\ 5)((x,y) => x + y)
c: Int = 15

Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

Добавляет элемент в этот связный хеш-список.

Добавить запись в таблицу до: не существует записи с таким же ключом

Добавляет все элементы этого итерируемого объекта или итератора в строковый буфер. Записываемый текст состоит из строковых представлений (относительно метода 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

Добавляет все элементы этого итерируемого объекта или итератора в строковый буфер с использованием разделительной строки. Записываемый текст состоит из строковых представлений (относительно метода 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

Добавляет все элементы этого итерируемого объекта или итератора в строковый буфер, используя начальную, конечную и разделительные строки. Записанный текст начинается со строки 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)

Агрегирует результаты применения оператора к последующим элементам.

Это более общая форма fold и reduce . Она похожа на foldLeft, поскольку не требует, чтобы результат был супертипом типа элемента. Кроме того, она позволяет обрабатывать параллельные коллекции частями, а затем объединять промежуточные результаты.

aggregate разбивает итерируемый объект или итератор на разделы и обрабатывает каждый раздел последовательным применением seqop, начиная с z (как foldLeft). Затем эти промежуточные результаты объединяются с помощью combop (как fold). Реализация этой операции может работать с произвольным количеством разделов коллекции (даже 1), поэтому combop может вызываться произвольное количество раз (даже 0).

Например, рассмотрим суммирование целочисленных значений списка символов. Начальное значение для суммы равно 0. Сначала seqop преобразует каждый символ входных данных в целое число и добавляет его к сумме (раздела). Затем combop просто суммирует промежуточные результаты разделов:

List('a', 'b', 'c').aggregate(0)({ (sum, ch) => sum + ch.toInt }, { (p1, p2) => p1 + p2 })

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

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

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

Преобразует получаемый объект к типу T0.

Обратите внимание, что успешность приведения типа во время выполнения зависит от семантики стирания Scala. Следовательно, выражение 1.asInstanceOf[String] выбросит ClassCastException во время выполнения, в то время как выражение List(1).asInstanceOf[List[String]] не выбросит. В последнем примере, поскольку аргумент типа стирается во время компиляции, невозможно проверить, соответствуют ли содержимое списка запрошенному типу.

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

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

Удаляет все записи из таблицы

Создает копию объекта-получателя.

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

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

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

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

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

Объект-компаньон-фабрика, который создает экземпляры класса LinkedHashSet. (или его Iterable суперкласса, где класс LinkedHashSet не является Seq.)

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

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

Копирует элементы этого связанного хэш-множества в массив. Заполняет предоставленный массив xs не более чем len элементами этого связанного хэш-множества, начиная с позиции start. Копирование остановится, как только будет достигнут конец текущего связанного хэш-множества, или конец целевого массива, или len элементов были скопированы.

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

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

Копирует все элементы этого итерируемого объекта или итератора в буфер.

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

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

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

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

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

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

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

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

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

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

Итератор, возвращающий все записи.

Проверяет, является ли аргумент (that) ссылкой на объект-приёмник (this).

Метод eq реализует отношение эквивалентности отношение эквивалентности для не-null экземпляров AnyRef, и имеет три дополнительных свойства:

Он согласован: для любых не-null экземпляров x и y типа AnyRef, многократные вызовы x.eq(y) последовательно возвращают true или последовательно возвращают false. Для любого не-null экземпляра x типа AnyRef, x.eq(null) и null.eq(x) возвращают false. null.eq(null) возвращает true.

При переопределении методов equals или hashCode важно обеспечить, что их поведение соответствует равенству ссылок. Поэтому, если два объекта являются ссылками друг на друга (o1 eq o2), они должны быть равны друг другу (o1 == o2) и должны иметь одинаковое значение хэша (o1.hashCode == o2.hashCode).

Сравнивает этот набор с другим объектом на равенство.

Примечание: Эта операция содержит неявное приведение типа: если that является набором, предполагается с неявным приведением типа, что он имеет тот же тип элементов, что и этот набор. Любая последующая ClassCastException обрабатывается как false результат.

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

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

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

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

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

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

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

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

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

Находит запись с заданным ключом в таблице, null если не найдена.

Найти запись с заданным ключом в таблице или добавить новую, если её нет. Может быть немного быстрее, чем пара findEntry/addEntry, так как вычисляет индекс хеш-таблицы для записи только один раз. Возвращает запись, найденную в таблице, или null. Новые записи создаются путем вызова метода createNewEntry.

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

Например:

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

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

Тип результирующей коллекции будет определяться статическим типом связного хеш-множества. Например:

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)

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

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

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

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

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

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

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

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

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

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

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

Применяет функцию f ко всем элементам этого набора связанных хешей.

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

Избегайте итератора для 2-кратного ускорения прохождения.

Возвращает строку, отформатированную в соответствии с заданной строкой format. Строки форматирования аналогичны String.format (@см. java.lang.String.format).

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

Возвращает представление класса во время выполнения объекта.

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

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

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

Проверяет, известен ли конечный размер этого итерируемого набора. Все строгие коллекции известны как имеющие конечный размер. Для нестрогой коллекции, такой как Stream, предикат возвращает true если все элементы были вычислены. Он возвращает false если поток еще не вычислен до конца. Непустые итераторы обычно возвращают false даже если они были созданы из коллекции с известным конечным размером.

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

Метод hashCode для ссылочных типов. См. hashCode в scala.Any.

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

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

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

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

Обращение к качественному хэшу в scala.util.hashing. Цель состоит в том, чтобы распределять по ячейкам наилучшим образом, даже если хэш-код имеет низкую энтропию в некоторых битах.

СТАРАЯ ВЕРСИЯ — быстрая, но плохая для последовательности 0-10000 — малая энтропия в старших битах — с 2003 г.

var h: Int = hcode + ~(hcode << 9)
h = h ^ (h >>> 14)
h = h + (h << 4)
h ^ (h >>> 10)

остальная часть вычисления происходит из-за scala/bug#5293

Примечание: мы берем наиболее значимые биты хэш-кода, а не младшие; это имеет решающее значение при заполнении таблицы параллельно

Выбор всех элементов, кроме последнего.

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

Начальный размер хеш-таблицы.

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

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

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

Проверка, является ли динамический тип объекта-получателя T0.

Обратите внимание, что результат проверки зависит от семантики стирания Scala. Поэтому выражение 1.isInstanceOf[String] вернёт false, а выражение List(1).isInstanceOf[List[String]] вернёт true. В последнем примере, поскольку аргумент типа стирается во время компиляции, невозможно проверить, относятся ли содержимое списка к указанному типу.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Эквивалентно !(this eq that).

Общее реализация newBuilder для всех изменяемых наборов на основе empty. Переопределяет реализацию в collection.SetLike для повышения эффективности.

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

Разбуживает единственную нить, которая ожидает монитора объекта-получателя.

Разбуживает все нити, которые ожидают монитора объекта-получателя.

Возвращает параллельную реализацию этого набора.

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

Определенные коллекции (например, ParArray или mutable.ParHashMap) переопределяют это поведение по умолчанию, создавая параллельную коллекцию, которая использует тот же базовый набор данных. Для таких коллекций par занимает постоянное или сублинейное время.

Все параллельные коллекции возвращают ссылку на себя.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Удаляет запись из таблицы, если она присутствует.

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

Результат, когда этот набор используется в качестве билдера

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

Этот метод возвращает ссылку на эту коллекцию. В параллельных коллекциях он переопределён для возврата последовательной реализации этой коллекции. В обоих случаях сложность O(1).

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

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

Указывает, что ожидается, что result этого билдера будет иметь тот же размер, что и заданное множество, плюс некоторое значение delta. Это предоставит подсказку только в том случае, если известно, что у множества есть метод size , который выполняется быстро, что определяется вызовом sizeHint.

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

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

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

Размер этого множества или итератора, если его можно вычислить быстро

Массив, отслеживающий количество элементов в блоках по 32 элемента.

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

from <= indexOf(x) < until

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

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

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

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

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

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

Разделяет эту итерируемую коллекцию на две части в заданной позиции. Примечание: c splitAt n эквивалентно (но, возможно, более эффективно, чем) (c take n, c drop n).

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

Определяет префикс представления этого объекта.

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

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

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

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

Фактическая хеш-таблица.

Количество сопоставлений, содержащихся в этой хеш-таблице.

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

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

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

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

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

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

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

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

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

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

Следующее значение размера, при котором происходит изменение размера (ёмкость * коэффициент заполнения).

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

Преобразует этот связанный хеш-сет в массив.

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

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

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

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

Возвращает эту итерируемую коллекцию как итерируемую коллекцию.

Новая коллекция не будет построена; ленивые коллекции останутся ленивыми.

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

Возвращает итератор по элементам в этой итерируемой коллекции. Возвращает тот же результат, что и iterator.

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

Преобразует этот итерируемый объект или итератор в список.

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

Преобразует этот связанный хеш-сет в карту. Этот метод недоступен, если элементы не являются членами Tuple2, каждый ((T, U)) становится парой ключ-значение в карте. Дублирующиеся ключи будут перезаписаны последующими ключами: если это неупорядоченная коллекция, то ключ, который находится в результирующей карте, не определён.

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

Note: предполагается быстрый size метод. Подклассы должны переопределять, если это не так.

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

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

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

Создаёт строковое представление этого объекта. По умолчанию представление зависит от платформы. На платформе Java это объединение имени класса, "@" и хэш-кода объекта в шестнадцатеричном формате.

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

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

Преобразует этот итерируемый объект или итератор в вектор.

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

Транспонирует это множество итерируемых коллекций в множество коллекций.

Тип результирующей коллекции будет определяться статическим типом коллекции. Например:

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

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

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

val xs = Traversable(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (Traversable(1, 2, 3),
//        Traversable(one, two, three))

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

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

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

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

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

Создает нестрогую (lazy) проекцию слайса этой итерируемой коллекции.

Примечание: разница между view и slice заключается в том, что view создаёт проекцию текущей коллекции, а slice создаёт новую коллекцию.

Примечание: view(from, to) эквивалентно view.slice(from, to).

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

Создаёт нестрогий вид этого итерируемого набора.

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

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

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

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

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

Сцепляет этот связанный хеш-набор с его индексами.

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

Примечание: То же самое, что и union.