Класс scala.Array

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

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

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

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

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

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

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

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

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

Выражение 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)

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

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

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

Если тип времени выполнения функции является 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)

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

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

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

Элемент по заданному индексу.

Индексы начинаются с 0; xs.apply(0) — это первый элемент массива xs. Синтаксис индексирования xs(i) является сокращением для xs.apply(i).

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

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

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

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

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

Клонировать массив.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Проверяет, является ли аргумент (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).

Метод равенства для ссылочных типов. Реализация по умолчанию делегирует eq.

См. также equals в scala.Any.

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

Подробности о том, когда и как вызывается метод 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.

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

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

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

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

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

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

Разделяет этот массив на карту массивов в соответствии с функцией-дискриминатором key. Каждый элемент в группе преобразуется в значение типа B с использованием функции value.

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

case class User(name: String, age: Int)

def namesByAge(users: Array[User]): Map[Int, Array[String]] =
  users.groupMap(_.age)(_.name)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Проверка, можно ли многократно пройтись по этой неизменяемой последовательности. Всегда true для Iterable и false для 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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Применяет функцию f к каждому элементу массива и возвращает пару массивов: первый содержит значения, возвращенные f, заключенные в scala.util.Left, а второй — значения, заключенные в scala.util.Right.

Пример:

val xs = Array(1, "one", 2, "two", 3, "three") partitionMap {
 case i: Int => Left(i)
 case s: String => Right(s)
}
// xs == (Array(1, 2, 3),
//        Array(one, two, three))

Применяет функцию f к каждому элементу неизменяемой последовательности и возвращает пару неизменяемых последовательностей: первая содержит значения, возвращенные f, заключенные в scala.util.Left, а вторая — значения, заключенные в scala.util.Right.

Пример:

val xs = `immutable.Seq`(1, "one", 2, "two", 3, "three") partitionMap {
 case i: Int => Left(i)
 case s: String => Right(s)
}
// xs == (`immutable.Seq`(1, 2, 3),
//        `immutable.Seq`(one, two, three))

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

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

Замена по отрицательным индексам эквивалентна замене, начинающейся с 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)

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

Копия этого массива со всеми элементами коллекции в начале.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Сортирует этот массив в соответствии с Ordering.

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

Сортирует эту неизменяемую последовательность в соответствии с Ordering.

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

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

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

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

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

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

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

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

Преобразует массив пар в массив первых элементов и массив вторых элементов.

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

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

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

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

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

Обновить элемент по заданному индексу.

Индексы начинаются с 0; xs.update(i, x) заменяет i^-й элемент в массиве. Обратите внимание, что синтаксис xs(i) = x является сокращением для xs.update(i, x).

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

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