Класс scala.collection.immutable.ArraySeq.ofShort

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

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

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

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

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

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

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

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

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

The expression x == that is equivalent to 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)

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

Обратите внимание, что вызов isDefinedAt на получившейся частичной функции может применить первую частичную функцию и выполнить её побочное действие. Сильно рекомендуется вместо isDefinedAt / apply использовать applyOrElse для повышения эффективности.

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

Если тип функции во время выполнения является PartialFunction, то используется другой метод andThen. (Обратите внимание на предостережения.)

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

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

Пример:

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

scala> val b = a :+ 2
b: List[Int] = List(1, 2)

scala> println(a)
List(1)

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

Получить элемент по указанному индексу. Данная операция предоставлена для удобства в Seq. Не следует полагать, что она эффективна, если у вас нет IndexedSeq.

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

Обратите внимание, что выражение pf.applyOrElse(x, default) эквивалентно

if(pf isDefinedAt x) pf(x) else default(x)

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

соединение частичных функций в цепочки orElse/andThen не приводит к чрезмерной оценке apply/isDefinedAt lift и unlift не оценивают исходные функции дважды при каждом вызове runWith позволяет эффективно комбинировать частичные функции с условными действиями в императивном стиле

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

подсказка для времени выполнения при сканировании значений apply предпочтительнее для сканирования с максимальным индексом меньше этого значения iterator предпочтительнее для сканирования выше этого диапазона

Преобразовать объект-получатель в тип T0.

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

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

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

Рекомендуется возвращать имя конкретного типа коллекции, а не подклассов реализации. Например, для ListMap этот метод должен возвращать "ListMap", а не "Map" (родительский тип) или "Node" (подкласс реализации).

Реализация по умолчанию возвращает "Iterable". Она переопределена для основных типов коллекций "Seq", "IndexedSeq", "LinearSeq", "Buffer", "Set", "Map", "SortedSet", "SortedMap" и "View".

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

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

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

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

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

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

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

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

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

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

Обратите внимание, что вызов isDefinedAt для полученной частичной функции может применить первую частичную функцию и выполнить её побочный эффект. Сильно рекомендуется использовать applyOrElse вместо isDefinedAt / apply для повышения эффективности.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает объект-экстрактор с методом unapplySeq, который извлекает каждый элемент данных последовательности.

Пустая итерируемая коллекция того же типа, что и эта итерируемая коллекция

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

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

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

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

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

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

Универсальный метод равенства, определённый в AnyRef.

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

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

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

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

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

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

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

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

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

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

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

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

Например:

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)

Преобразует эту итерируемую коллекцию итерируемых коллекций в итерируемую коллекцию, образованную элементами этих итерируемых коллекций.

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

Определяет, как преобразовать заданный Iterable[A] в коллекцию типа C.

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

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

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

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

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с функцией дискриминатора 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)

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

Разделяет эту итерируемую коллекцию на карту в соответствии с функцией дискриминатора key. Все значения, имеющие один и тот же дискриминатор, затем преобразуются функцией value и сводятся к одному значению с помощью функции reduce.

Это эквивалентно groupBy(key).mapValues(_.map(f).reduce(reduce)), но более эффективно.

def occurrences[A](as: Seq[A]): Map[A, Int] =
  as.groupMapReduce(identity)(_ => 1)(_ + _)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Длина (количество элементов) неизменяемого массива. size является псевдонимом для length в коллекциях Seq.

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

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

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

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

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

Превращает эту частичную функцию в обычную функцию, возвращающую результат Option.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Применяет функцию 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))

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

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

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

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

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

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

Пример:

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

scala> val y = 2 +: x
y: List[Int] = List(2, 1)

scala> println(x)
List(1)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Обратите внимание, что выражение pf.runWith(action)(x) эквивалентно

if(pf isDefinedAt x) { action(pf(x)); true } else false

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

Сравнивает размер этого набора с заданным значением.

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

Эти операции реализованы в терминах 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

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

from <= indexOf(x) < until

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

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

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

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

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

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

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

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

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

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

Сортирует этот неизменяемый массив в соответствии с упорядочением.

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

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

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

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

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

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

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

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

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

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

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

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

Для коллекций Int, Short, Byte или Char, возвращается IntStepper.Для коллекций Double или Float, возвращается DoubleStepper.Для коллекций Long возвращается LongStepper.Для любого другого типа элементов возвращается AnyStepper.

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

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

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

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

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

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

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

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

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

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

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

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

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

Создает строковое представление этого объекта. По умолчанию представление зависит от платформы. На платформе 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))

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

Попытка извлечь B из A в выражении сопоставления с образцом.

Оборачиваемый изменяемый Array лежащий в основе этого ArraySeq. Любые изменения в этом массиве нарушат ожидаемую неизменяемость. Его тип элемента не обязан быть равен типу элемента этого ArraySeq. Примитивный ArraySeq может быть основан на массиве упакованных значений, а ссылочный ArraySeq — на массиве супертипа или подтипа типа элемента.

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

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

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

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

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

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

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

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

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

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

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

Объединяет эту итерируемую коллекцию с её индексами.