Трейт scala.collection.mutable.ResizableArray

Компаньон объект ResizableArray

трейт ResizableArray[A] extends IndexedSeq[A] with GenericTraversableTemplate[A, ResizableArray] with IndexedSeqOptimized[A, ResizableArray[A]]

Этот класс используется внутри для реализации структур данных, основанных на изменяемых массивах.

A: тип элементов, содержащихся в этом изменяемом массиве.

Источник: ResizableArray.scala
С момента: 1

Линейные надтипы

Известные подклассы

Типовые члены

класс Elements extends AbstractIterator[A] with BufferedIterator[A] with Serializable

Класс итератора, возвращаемого методом iterator. Несколько take, drop, и slice операций над этим итератором объединены для повышения эффективности.

Атрибуты: protected
Классы определений: IndexedSeqLike
Аннотации: @SerialVersionUID()

класс WithFilter extends FilterMonadic[A, Repr]

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

Классы определений: TraversableLike

тип Self = ResizableArray[A]

Тип, реализующий эту итерацию

Атрибуты: protected[this]
Классы определений: TraversableLike

Члены-значения

final def !=(arg0: Any): Boolean

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

возвращает: true если !(this == that), иначе false.

Определяющие классы: AnyRef → Any

final def ##(): Int

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

возвращает: хеш-значение, согласованное с ==

Определяющие классы: AnyRef → Any

def +(other: String): String

Неявный: Этот член добавлен с помощью неявного преобразования из ResizableArray[A] в any2stringadd[ResizableArray[A]], выполненного методом any2stringadd в scala.Predef.
Определяющие классы: any2stringadd

def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[ResizableArray[A], B, That]): That

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

B: тип элемента возвращаемой коллекции.
That: класс возвращаемой коллекции. В возможном случае, That является тем же классом, что и текущий класс коллекции Repr, но это зависит от того, допустим ли тип элемента B для этого класса, что означает, что найдена неявная инстанция типа CanBuildFrom[Repr, B, That].
that: добавляемая коллекция.
bf: неявное значение класса CanBuildFrom, которое определяет класс результата That по типу представления текущей коллекции Repr и новому типу элемента B.
возвращает: новая коллекция типа That, которая содержит все элементы этой коллекции, за которыми следуют все элементы that.

Определяющие классы: TraversableLike → GenTraversableLike

def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[ResizableArray[A], B, That]): That

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

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

Пример:

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 и ниже могут использовать перегруз.

B: тип элемента возвращаемой коллекции.
That: класс возвращаемой коллекции. В возможном случае, That является тем же классом, что и текущий класс коллекции Repr, но это зависит от того, допустим ли тип элемента B для этого класса, что означает, что найдена неявная инстанция типа CanBuildFrom[Repr, B, That].
that: добавляемая коллекция.
bf: неявное значение класса CanBuildFrom, которое определяет класс результата That по типу представления текущей коллекции Repr и новому типу элемента B.
возвращает: новая коллекция типа That, которая содержит все элементы этой коллекции, за которыми следуют все элементы that.

Определяющие классы: TraversableLike

def ++:[B](that: TraversableOnce[B]): IndexedSeq[B]

[пример использования]

Пример:

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)

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

Определяющие классы: TraversableLike

def +:(elem: A): IndexedSeq[A]

[use case]

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

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

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

Пример:

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)

elem: элемент, добавляемый в начало
returns: новая изменяемая индексированная последовательность, состоящая из elem и всех элементов этой изменяемой индексированной последовательности.

Definition Classes: SeqLike → GenSeqLike

def ->[B](y: B): (ResizableArray[A], B)

Неявный: Этот член добавлен неявным преобразованием из ResizableArray[A] в ArrowAssoc[ResizableArray[A]], выполненное методом ArrowAssoc в scala.Predef.
Definition Classes: ArrowAssoc
Аннотации: @inline()

def /:[B](z: B)(op: (B, A) ⇒ B): B

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

Примечание: /: — альтернативная синтаксическая конструкция для 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

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

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

B

тип результата бинарного оператора.

z

начальное значение.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этого итерируемого объекта или итератора слева направо с начальным значением z слева:

op(...op(op(z, x_1), x_2), ..., x_n)

где x₁, ..., x_n — это элементы этого итерируемого объекта или итератора.

Definition Classes: TraversableOnce → GenTraversableOnce

def :+(elem: A): IndexedSeq[A]

[use case]

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

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

Пример:

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)

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

Definition Classes: SeqLike → GenSeqLike

def :\[B](z: B)(op: (A, B) ⇒ B): B

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

Примечание: :\ — альтернативная синтаксическая конструкция для foldRight; xs :\ z эквивалентно xs foldRight z.

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

Примеры:

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

B

тип результата бинарного оператора.

z

начальное значение

op

бинарный оператор

returns

результат вставки op между последовательными элементами этого итерируемого объекта или итератора справа налево с начальным значением z справа:

op(x_1, op(x_2, ... op(x_n, z)...))

где x₁, ..., x_n — это элементы этого итерируемого объекта или итератора.

Definition Classes: TraversableOnce → GenTraversableOnce

final def ==(arg0: Any): Boolean

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

returns: true если объект-получатель эквивалентен аргументу; false в противном случае.

Definition Classes: AnyRef → Any

def addString(b: scala.StringBuilder): scala.StringBuilder

Добавляет все элементы этого итерируемого объекта или итератора в строковый буфер. Текст состоит из строковых представлений (с учётом метода toString) всех элементов этого итерируемого объекта или итератора без разделительных строк.

Пример:

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

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

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

b: строковый буфер, в который добавляются элементы.
returns: строковый буфер b, в который были добавлены элементы.

Definition Classes: TraversableOnce

def addString(b: scala.StringBuilder, sep: String): scala.StringBuilder

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

Пример:

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

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

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

b: строковый буфер, в который добавляются элементы.
sep: разделительная строка.
returns: строковый буфер b, в который были добавлены элементы.

Definition Classes: TraversableOnce

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

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

Пример:

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

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

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

b: строковый буфер, в который добавляются элементы.
start: начальная строка.
sep: разделительная строка.
end: конечная строка.
returns: строковый буфер b, в который были добавлены элементы.

Definition Classes: TraversableOnce

def aggregate[B](z: ⇒ B)(seqop: (B, A) ⇒ B, combop: (B, B) ⇒ B): B

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

Это более общий вид 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 })

def andThen[C](k: (A) ⇒ C): PartialFunction[Int, C]

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

def apply(idx: Int): A

def applyOrElse[A1 <: Int, B1 >: A](x: A1, default: (A1) ⇒ B1): B1

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

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

x: аргумент функции
default: функция по умолчанию
returns: результат применения этой функции или функции по умолчанию.

Definition Classes: PartialFunction
Since: 2.10

val array: Array[AnyRef]

Attributes: protected

final def asInstanceOf[T0]: T0

Преобразовать объект-приёмник к типу T0.

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

returns: объект-приёмник.

Definition Classes: Any
Исключения: ClassCastException, если объект-приёмник не является экземпляром стираемого типа T0.

def canEqual(that: Any): Boolean

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

that: Объект, с которым эта итерируемая коллекция должна быть сравнена
returns: true, если эта итерируемая коллекция может быть равна that, false в противном случае. Тест учитывает только типы объектов во время выполнения, но игнорирует их элементы.

Definition Classes: IterableLike → Equals

def charAt(index: Int): Char

Неявный: Этот член добавлен неявным преобразованием из ResizableArray[A] в SeqCharSequence, выполненным методом SeqCharSequence в scala.Predef. Это преобразование произойдёт только если A является подклассом Char (A <: Char).
Definition Classes: SeqCharSequence → CharSequence

def chars(): IntStream

Неявный: Этот член добавлен неявным преобразованием из ResizableArray[A] в SeqCharSequence, выполненным методом SeqCharSequence в scala.Predef. Это преобразование произойдёт только если A является подклассом Char (A <: Char).
Definition Classes: CharSequence

def clone(): Seq[A]

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

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

returns: копия объекта-приёмника.

Definition Classes: Cloneable → AnyRef
Примечание: не указано SLS как член AnyRef

def codePoints(): IntStream

Неявный: Этот член добавлен неявным преобразованием из ResizableArray[A] в SeqCharSequence, выполненным методом SeqCharSequence в scala.Predef. Это преобразование произойдёт только если A является подклассом Char (A <: Char).
Definition Classes: CharSequence

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

[use case]

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

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

pf: частичная функция
returns: значение типа Option, содержащее результат применения pf к первому элементу, для которого она определена, или None, если такого элемента нет.

Definition Classes: TraversableOnce

def combinations(n: Int): Iterator[ResizableArray[A]]

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

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

returns: Итератор, проходящий по возможным комбинациям n элементов этой последовательности.

Definition Classes: SeqLike

def companion: GenericCompanion[ResizableArray]

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

Definition Classes: ResizableArray → IndexedSeq → IndexedSeq → Seq → Seq → GenSeq → Iterable → Iterable → GenIterable → Traversable → Traversable → GenTraversable → GenericTraversableTemplate

def compose[A](g: (A) ⇒ Int): (A) ⇒ A

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

A: тип, к которому может быть применена функция g
g: функция A => T1
returns: новая функция f такая, что f(x) == apply(g(x))

Definition Classes: Function1
Annotations: @unspecialized()

def contains[A1 >: A](elem: A1): Boolean

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

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

elem: элемент для проверки.
returns: true , если в этой последовательности есть элемент, который равен (определяется по ==) elem, false в противном случае.

Definition Classes: SeqLike

def containsSlice[B](that: GenSeq[B]): Boolean

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

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

that: Последовательность для проверки
returns: true , если эта последовательность содержит срез с теми же элементами, что и that, в противном случае false.

Definition Classes: SeqLike

def copy(m: Int, n: Int, len: Int): Unit

Перемещает части массива.

Attributes: protected

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

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

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

B: тип элементов целевого массива.
xs: массив для заполнения.
start: начальный индекс.
len: количество элементов для копирования

Definition Classes: ResizableArray → IndexedSeqOptimized → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

def copyToArray(xs: Array[A]): Unit

[use case]

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

xs: массив для заполнения.

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def copyToBuffer[B >: A](dest: Buffer[B]): Unit

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

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

dest: Буфер, в который копируются элементы.

Definition Classes: TraversableOnce

def corresponds[B](that: GenSeq[B])(p: (A, B) ⇒ Boolean): Boolean

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

B: тип элементов that
that: другая последовательность
p: условие предиката, связывающее элементы обеих последовательностей
returns: true, если обе последовательности имеют одинаковую длину и p(x, y) равно true для всех соответствующих элементов x этой последовательности и y that, в противном случае false.

Definition Classes: SeqLike → GenSeqLike

def count(p: (A) ⇒ Boolean): Int

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def diff(that: collection.Seq[A]): IndexedSeq[A]

[use case]

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

that: последовательность элементов, подлежащих удалению
returns: новая изменяемая индексированная последовательность, содержащая все элементы этого изменяемого индексированного последовательность за исключением некоторых вхождений элементов, также присутствующих в that. Если значение элемента x встречается n раз в that, то первые n вхождений x не будут частью результата, но любые последующие вхождения будут.

Definition Classes: SeqLike → GenSeqLike

def distinct: ResizableArray[A]

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

Definition Classes: IndexedSeqOptimized → IterableLike → TraversableLike → GenTraversableLike

def dropRight(n: Int): ResizableArray[A]

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

n: Количество элементов для взятия
returns: последовательность, состоящая из всех элементов этой последовательности, кроме последних n элементов, или пустая последовательность, если в этой последовательности меньше чем n элементов.

Definition Classes: IndexedSeqOptimized → IterableLike

def dropWhile(p: (A) ⇒ Boolean): ResizableArray[A]

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

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

Definition Classes: IndexedSeqOptimized → TraversableLike → GenTraversableLike

def endsWith[B](that: GenSeq[B]): Boolean

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

that: Последовательность для проверки
returns: true если эта последовательность имеет that в качестве суффикса, false в противном случае.

Definition Classes: IndexedSeqOptimized → SeqLike → GenSeqLike

def ensureSize(n: Int): Unit

Убедитесь, что внутренний массив имеет по крайней мере n ячеек.

Attributes: protected

def ensuring(cond: (ResizableArray[A]) ⇒ Boolean, msg: ⇒ Any): ResizableArray[A]

Implicit: Этот член добавлен неявным преобразованием из ResizableArray[A] в Ensuring[ResizableArray[A]] выполненным методом Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: (ResizableArray[A]) ⇒ Boolean): ResizableArray[A]

Implicit: Этот член добавлен неявным преобразованием из ResizableArray[A] в Ensuring[ResizableArray[A]] выполненным методом Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: Boolean, msg: ⇒ Any): ResizableArray[A]

Implicit: Этот член добавлен неявным преобразованием из ResizableArray[A] в Ensuring[ResizableArray[A]] выполненным методом Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: Boolean): ResizableArray[A]

Implicit: Этот член добавлен неявным преобразованием из ResizableArray[A] в Ensuring[ResizableArray[A]] выполненным методом Ensuring в scala.Predef.
Definition Classes: Ensuring

final def eq(arg0: AnyRef): Boolean

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

returns: true , если аргумент является ссылкой на объект-получатель; false в противном случае.

Definition Classes: AnyRef

def equals(that: Any): Boolean

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

that: Объект, с которым сравнивается последовательность
returns: true , если that является последовательностью, которая имеет те же элементы, что и эта последовательность в том же порядке; false в противном случае

Definition Classes: GenSeqLike → Equals → Any

def exists(p: (A) ⇒ Boolean): Boolean

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

p: предикат, используемый для проверки элементов.
returns: false , если эта последовательность пуста, иначе true , если данный предикат p выполняется для некоторых элементов этой последовательности, иначе false

Definition Classes: IndexedSeqOptimized → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

def filter(p: (A) ⇒ Boolean): ResizableArray[A]

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

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

Definition Classes: TraversableLike → GenTraversableLike

def filterNot(p: (A) ⇒ Boolean): ResizableArray[A]

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

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

Definition Classes: TraversableLike → GenTraversableLike

def finalize(): Unit

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

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

Attributes: protected[lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )
Note: не указано в SLS как член AnyRef

def find(p: (A) ⇒ Boolean): Option[A]

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

p: предикат, используемый для проверки элементов.
returns: значение Option, содержащее первый элемент в последовательности, удовлетворяющий p, или None , если такого элемента нет.

Definition Classes: IndexedSeqOptimized → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): IndexedSeq[B]

[use case]

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

Например:

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)

B: тип элементов возвращаемой коллекции.
f: функция, применяемая к каждому элементу.
returns: новая изменяемая индексированная последовательность, полученная путём применения заданной функции, возвращающей коллекцию f, к каждому элементу этой изменяемой индексированной последовательности и конкатенации результатов.

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

def flatten[B]: IndexedSeq[B]

[use case]

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

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

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)

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

Definition Classes: GenericTraversableTemplate

def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1

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

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

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

A1: параметр типа для бинарного оператора, тип, являющийся надтипом A.
z: нейтральный элемент для операции fold; может быть добавлен к результату любое количество раз, и при этом результат не изменится (например, Nil для конкатенации списков, 0 для сложения или 1 для умножения).
op: бинарный оператор, который должен быть ассоциативным.
returns: результат применения оператора fold op ко всем элементам и z, или z если эта коллекция или итератор пустые.

Definition Classes: TraversableOnce → GenTraversableOnce

def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

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

B

тип результата бинарного оператора.

z

начальное значение.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этой последовательности слева направо, начиная с начального значения z слева:

op(...op(z, x_1), x_2, ..., x_n)

где x₁, ..., x_n - это элементы этой последовательности. Возвращает z если эта последовательность пуста.

Definition Classes: IndexedSeqOptimized → TraversableOnce → GenTraversableOnce

def foldRight[B](z: B)(op: (A, B) ⇒ B): B

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

B

тип результата бинарного оператора.

z

начальное значение.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этой последовательности справа налево, начиная с начального значения z справа:

op(x_1, op(x_2, ... op(x_n, z)...))

где x₁, ..., x_n - это элементы этой последовательности. Возвращает z если эта последовательность пуста.

Definition Classes: IndexedSeqOptimized → IterableLike → TraversableOnce → GenTraversableOnce

def forall(p: (A) ⇒ Boolean): Boolean

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

p: предикат, используемый для проверки элементов.
returns: true если эта последовательность пуста или заданный предикат p выполняется для всех элементов этой последовательности, в противном случае false.

Definition Classes: IndexedSeqOptimized → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

def foreach(f: (A) ⇒ Unit): Unit

[использование]

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

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

f: функция, которая применяется для побочного эффекта к каждому элементу. Результат функции f игнорируется.

Классы определения: ResizableArray → IndexedSeqOptimized → IterableLike → GenericTraversableTemplate → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic

def formatted(fmtstr: String): String

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

Неявный: Этот член добавлен неявным преобразованием из ResizableArray[A] в StringFormat[ResizableArray[A]] с помощью метода StringFormat в scala.Predef.
Классы определения: StringFormat
Аннотации: @inline()

def genericBuilder[B]: Builder[B, ResizableArray[B]]

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

Классы определения: GenericTraversableTemplate

final def getClass(): Class[_]

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

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

Классы определения: AnyRef → Any
Аннотации: @native()

def groupBy[K](f: (A) ⇒ K): immutable.Map[K, ResizableArray[A]]

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

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

K

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

f

функция-дискриминатор.

возвращает

Map из ключей к коллекциям, которая удовлетворяет следующему инварианту:

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

То есть, каждый ключ k сопоставлен с изменяемой коллекцией элементов x для которых f(x) равно k.

Классы определения: TraversableLike → GenTraversableLike

def grouped(size: Int): Iterator[ResizableArray[A]]

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

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

Классы определения: IterableLike
См. также: scala.collection.Iterator, метод grouped

def hasDefiniteSize: Boolean

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

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

возвращает: true если размер этой коллекции известен и конечен, false в противном случае.

Классы определения: TraversableLike → TraversableOnce → GenTraversableOnce

def hashCode(): Int

Хеш-коды для IndexedSeq генерируют значение из хеш-кодов всех элементов последовательности.

возвращает: значение хеш-кода для этого объекта.

Классы определения: IndexedSeqLike → GenSeqLike → Any

def head: A

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

returns: первый элемент этой последовательности.

Definition Classes: IndexedSeqOptimized → IterableLike → TraversableLike → GenTraversableLike
Exceptions thrown: NoSuchElementException, если последовательность пуста.

def headOption: Option[A]

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

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

returns: первый элемент этой коллекции перебора, если она не пуста, None если пуста.

Definition Classes: TraversableLike → GenTraversableLike

def indexOf(elem: A, from: Int): Int

[use case]

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

elem: значение элемента, который нужно найти.
from: начальный индекс
returns: индекс >= from первого элемента этой изменяемой индексируемой последовательности, который равен (как определяется ==) elem, или -1, если такого элемента нет.

Definition Classes: GenSeqLike

def indexOf(elem: A): Int

[use case]

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

elem: значение элемента, который нужно найти.
returns: индекс первого элемента этой изменяемой индексируемой последовательности, который равен (как определяется ==) elem, или -1, если такого элемента нет.

Definition Classes: GenSeqLike

def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int

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

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

that: последовательность, которую нужно проверить
from: начальный индекс
returns: первый индекс >= from такой, что элементы этой последовательности, начиная с этого индекса, соответствуют элементам последовательности that, или -1, если такой подпоследовательности нет.

Definition Classes: SeqLike

def indexOfSlice[B >: A](that: GenSeq[B]): Int

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

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

that: последовательность, которую нужно проверить
returns: первый индекс, такой что элементы этой последовательности, начиная с этого индекса, соответствуют элементам последовательности that, или -1, если такой подпоследовательности нет.

Definition Classes: SeqLike

def indexWhere(p: (A) ⇒ Boolean, from: Int): Int

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

p: предикат, используемый для проверки элементов.
from: начальный индекс
returns: индекс >= from первого элемента этой последовательности, удовлетворяющего предикату p, или -1, если такого элемента нет.

Definition Classes: IndexedSeqOptimized → SeqLike → GenSeqLike

def indexWhere(p: (A) ⇒ Boolean): Int

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

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

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

Definition Classes: GenSeqLike

def indices: immutable.Range

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

returns: значение Range от 0 до значения, на единицу меньшего, чем длина этой последовательности.

Definition Classes: SeqLike

def init: ResizableArray[A]

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

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

Определяющие классы: IndexedSeqOptimized → TraversableLike → GenTraversableLike
Исключения: UnsupportedOperationException, если последовательность пуста.

def initialSize: Int

Атрибуты: protected

def inits: Iterator[ResizableArray[A]]

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

возвращает: итератор по всем начальным частям этой коллекции

Определяющие классы: TraversableLike

def intersect(that: collection.Seq[A]): IndexedSeq[A]

[use case]

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

that: последовательность элементов для пересечения.
возвращает: новая изменяемая индексированная последовательность, которая содержит все элементы этой изменяемой индексированной последовательности, которые также встречаются в that. Если значение элемента x встречается n раз в that, то первые n вхождений x будут сохранены в результате, но любые последующие вхождения будут пропущены.

Определяющие классы: SeqLike → GenSeqLike

def isDefinedAt(idx: Int): Boolean

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

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

idx: индекс для проверки
возвращает: true, если эта общая последовательность содержит элемент в позиции idx, false в противном случае.

Определяющие классы: GenSeqLike

def isEmpty: Boolean

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

возвращает: true если последовательность не содержит элементов, false в противном случае.

Определяющие классы: IndexedSeqOptimized → SeqLike → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

final def isInstanceOf[T0]: Boolean

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

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

возвращает: true если объект-приемник является экземпляром стирания типа T0; false в противном случае.

Определяющие классы: Any

final def isTraversableAgain: Boolean

Проверяет, можно ли многократно пройти по этой коллекции.

возвращает: true

Определяющие классы: TraversableLike → GenTraversableLike → GenTraversableOnce

def iterator: Iterator[A]

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

возвращает: новый итератор

Определяющие классы: IndexedSeqLike → IterableLike → GenIterableLike

def last: A

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

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

Определяющие классы: IndexedSeqOptimized → TraversableLike → GenTraversableLike
Исключения: NoSuchElementException Если последовательность пуста.

def lastIndexOf(elem: A, end: Int): Int

[use case]

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

elem: значение элемента, для поиска.
end: индекс конца.
returns: индекс <= end последнего элемента этой изменяемой индексированной последовательности, который равен (как определено ==) elem, или -1, если такого элемента нет.

Definition Classes: GenSeqLike

def lastIndexOf(elem: A): Int

[use case]

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

elem: значение элемента, для поиска.
returns: индекс последнего элемента этой изменяемой индексированной последовательности, который равен (как определено ==) elem, или -1, если такого элемента нет.

Definition Classes: GenSeqLike

def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int

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

that: последовательность для проверки
end: индекс конца
returns: последний индекс <= end такой, что элементы этой последовательности, начиная с этого индекса, совпадают с элементами последовательности that, или -1 если такой подпоследовательности нет.

Definition Classes: SeqLike

def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int

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

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

that: последовательность для проверки
returns: последний индекс такой, что элементы этой последовательности, начиная с этого индекса, совпадают с элементами последовательности that, или -1 если такой подпоследовательности нет.

Definition Classes: SeqLike

def lastIndexWhere(p: (A) ⇒ Boolean, end: Int): Int

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

p: предикат, используемый для проверки элементов.
returns: индекс <= end последнего элемента этой последовательности, удовлетворяющего предикату p, или -1, если такого элемента нет.

Definition Classes: IndexedSeqOptimized → SeqLike → GenSeqLike

def lastIndexWhere(p: (A) ⇒ Boolean): Int

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

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

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

Definition Classes: GenSeqLike

def lastOption: Option[A]

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

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

returns: последний элемент этой коллекции, если она непустая, None если она пустая.

Definition Classes: TraversableLike → GenTraversableLike

def length: Int

Возвращает длину этого изменяемого массива.

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

Definition Classes: ResizableArray → SeqLike → GenSeqLike

def lengthCompare(len: Int): Int

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

len

значение теста, которое сравнивается с длиной.

returns

Значение x, где

x <  0       if this.length <  len
x == 0       if this.length == len
x >  0       if this.length >  len

Метод как реализован здесь не вызывает length напрямую; его время выполнения O(length min len) вместо O(length). Метод должен быть перезаписан, если вычисление length дешево.

Definition Classes: IndexedSeqOptimized → SeqLike

def lift: (Int) ⇒ Option[A]

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

returns: функция, которая принимает аргумент x в Some(this(x)), если this определено для x, и в None в противном случае.

Definition Classes: PartialFunction
See also: Function.unlift

def map[B](f: (A) ⇒ B): IndexedSeq[B]

[use case]

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

B: тип элементов возвращаемой коллекции.
f: функция, применяемая к каждому элементу.
returns: новая изменяемая индексированная последовательность, полученная в результате применения заданной функции f к каждому элементу этой изменяемой индексированной последовательности и сбора результатов.

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

def max: A

[use case]

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

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

Definition Classes: TraversableOnce → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException, если эта изменяемая индексированная последовательность пустая.

def maxBy[B](f: (A) ⇒ B): A

[use case]

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

B: Тип результата функции f.
f: Функция измерения.
returns: первый элемент этой изменяемой индексированной последовательности с наибольшим значением, измеренным функцией f.

Definition Classes: TraversableOnce → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException, если эта изменяемая индексированная последовательность пустая.

def min: A

[use case]

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

returns: наименьший элемент этой изменяемой индексированной последовательности.

Definition Classes: TraversableOnce → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException, если эта изменяемая индексированная последовательность пустая.

def minBy[B](f: (A) ⇒ B): A

[use case]

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

B: Тип результата функции f.
f: Функция измерения.
returns: первый элемент этой изменяемой индексированной последовательности с наименьшим значением, измеренным функцией f.

Definition Classes: TraversableOnce → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException, если эта изменяемая индексированная последовательность пустая.

def mkString: String

Отображает все элементы этой итерируемой коллекции или итератора в строку.

returns: строковое представление этой итерируемой коллекции или итератора. В полученной строке строковые представления (соответствующие методу toString) всех элементов этой итерируемой коллекции или итератора следуют друг за другом без разделительной строки.

Definition Classes: TraversableOnce → GenTraversableOnce

def mkString(sep: String): String

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

sep: разделительная строка.
returns: строковое представление этой итерируемой коллекции или итератора. В полученной строке строковые представления (соответствующие методу toString) всех элементов этой итерируемой коллекции или итератора разделены строкой sep.

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

final def ne(arg0: AnyRef): Boolean

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

returns: true если аргумент не является ссылкой на объект-получатель; false в противном случае.

Definition Classes: AnyRef

def newBuilder: Builder[A, ResizableArray[A]]

Построитель, создающий экземпляры типа Traversable[A]

Attributes: protected[this]
Definition Classes: GenericTraversableTemplate → HasNewBuilder

def nonEmpty: Boolean

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

returns: true если Traversable или итератор содержит по крайней мере один элемент, false в противном случае.

Definition Classes: TraversableOnce → GenTraversableOnce

final def notify(): Unit

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

Definition Classes: AnyRef
Annotations: @native()
Note: не определён в SLS как член AnyRef

final def notifyAll(): Unit

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

Definition Classes: AnyRef
Annotations: @native()
Note: не определён в SLS как член AnyRef

def orElse[A1 <: Int, B1 >: A](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

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

A1: тип аргумента резервной функции
B1: тип результата резервной функции
that: резервная функция
returns: частичная функция, область определения которой является объединением областей определения данной частичной функции и that. Результирующая частичная функция принимает x к this(x) где this определена, и к that(x) где она не определена.

Definition Classes: PartialFunction

def padTo(len: Int, elem: A): IndexedSeq[A]

[use case]

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

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

Definition Classes: SeqLike → GenSeqLike

def par: ParSeq[A]

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

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

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

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

returns: параллельная реализация этого набора

Definition Classes: Parallelizable

def parCombiner: Combiner[A, ParSeq[A]]

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

returns: комбинирование для параллельного набора типа ParRepr

Attributes: protected[this]
Definition Classes: SeqLike → SeqLike → TraversableLike → Parallelizable

def partition(p: (A) ⇒ Boolean): (ResizableArray[A], ResizableArray[A])

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

p: предикат, по которому нужно разделить.
returns: пара проходимых наборов: первый проходимый набор состоит из всех элементов, которые удовлетворяют предикату p, а второй проходимый набор состоит из всех элементов, которые не удовлетворяют ему. Относительный порядок элементов в результирующих проходимых наборах такой же, как и в исходном проходимом наборе.

Definition Classes: TraversableLike → GenTraversableLike

def patch(from: Int, that: GenSeq[A], replaced: Int): IndexedSeq[A]

[use case]

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

from: индекс первого заменяемого элемента
replaced: количество элементов для удаления в исходном изменяемом индексированном наборе
returns: новый изменяемый индексированный набор, состоящий из всех элементов этого изменяемого индексированного набора, за исключением того, что replaced элементы, начиная с from, заменяются на patch.

Definition Classes: SeqLike → GenSeqLike

def permutations: Iterator[ResizableArray[A]]

Перебирает все различные перестановки.

returns: Итератор, проходящий по всем различным перестановкам этой последовательности.

Definition Classes: SeqLike

def prefixLength(p: (A) ⇒ Boolean): Int

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

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

p: предикат для проверки элементов.
returns: длина самой длинной префиксной части этой общей последовательности, каждый элемент которой удовлетворяет предикату p.

Definition Classes: GenSeqLike

def product: A

[use case]

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

returns: произведение всех элементов в этом изменяемом индексированном наборе чисел типа Int. Вместо Int, любой другой тип T с неявным Numeric[T] реализацией может использоваться в качестве типа элементов изменяемого индексированного набора и в качестве типа возвращаемого значения product. Примеры таких типов: Long, Float, Double, BigInt.

Definition Classes: TraversableOnce → GenTraversableOnce

def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1

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

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

A1: Тип параметра для бинарного оператора, надтип для A.
op: Ассоциативный бинарный оператор.
returns: Результат применения оператора reduce op ко всем элементам проходимого набора, если набор не пуст.

Definition Classes: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException, если этот проходимый набор пуст.

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

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

B

тип результата бинарного оператора.

op

бинарный оператор.

returns

результат вставки op между соседними элементами этой последовательности слева направо:

op( op( ... op(x_1, x_2) ..., x_{n-1}), x_n)

где x₁, ..., x_n — элементы этой последовательности.

Definition Classes: IndexedSeqOptimized → TraversableOnce
Исключения: UnsupportedOperationException, если эта последовательность пуста.

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

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

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

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

B: тип результата бинарного оператора.
op: бинарный оператор.
returns: значение Option, содержащее результат reduceLeft(op) если этот итерируемый объект или итератор не пустой, None в противном случае.

Definition Classes: TraversableOnce → GenTraversableOnce

def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]

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

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

A1: Параметр типа для бинарного оператора, являющийся супертипом A.
op: Бинарный оператор, который должен быть ассоциативным.
returns: Значение Option, содержащее результат применения оператора reduce op между всеми элементами, если коллекция непустая, и None в противном случае.

Definition Classes: TraversableOnce → GenTraversableOnce

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

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

B

тип результата бинарного оператора.

op

бинарный оператор.

returns

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

op(x_1, op(x_2, ..., op(x_{n-1}, x_n)...))

где x₁, ..., x_n — элементы этой последовательности.

Definition Classes: IndexedSeqOptimized → IterableLike → TraversableOnce → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException, если эта последовательность пуста.

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

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

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

B: тип результата бинарного оператора.
op: бинарный оператор.
returns: значение Option, содержащее результат reduceRight(op) если этот итерируемый объект или итератор не пустой, None в противном случае.

Definition Classes: TraversableOnce → GenTraversableOnce

def reduceToSize(sz: Int): Unit

def repr: ResizableArray[A]

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

Definition Classes: TraversableLike → GenTraversableLike

def reverse: ResizableArray[A]

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

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

Definition Classes: IndexedSeqOptimized → SeqLike → GenSeqLike

def reverseIterator: Iterator[A]

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

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

returns: итератор, возвращающий элементы этой последовательности в обратном порядке

Definition Classes: IndexedSeqOptimized → SeqLike

def reverseMap[B](f: (A) ⇒ B): IndexedSeq[B]

[случай использования]

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

Примечание: xs.reverseMap(f) эквивалентно xs.reverse.map(f), но может быть более эффективным.

B: тип элементов возвращаемой коллекции.
f: функция, применяемая к каждому элементу.
возвращает: новая изменяемая индексированная последовательность, полученная путём применения указанной функции f к каждому элементу этой изменяемой индексированной последовательности и сбора результатов в обратном порядке.

Классы определений: SeqLike → GenSeqLike

def reversed: List[A]

Атрибуты: protected[this]
Классы определений: TraversableOnce

def runWith[U](action: (A) ⇒ U): (Int) ⇒ Boolean

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

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

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

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

action: функция действия
возвращает: функция, которая отображает аргументы x в isDefinedAt(x). Результирующая функция выполняет action(this(x)), где this определено.

Классы определений: PartialFunction
С тех пор: 2.10
См. также: applyOrElse.

def sameElements(that: GenIterable[A]): Boolean

[случай использования]

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

that: коллекция для сравнения.
возвращает: true, если обе коллекции содержат одинаковые элементы в том же порядке, false в противном случае.

Классы определений: IndexedSeqOptimized → IterableLike → GenIterableLike

def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[ResizableArray[A], B, That]): That

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

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

B: тип элементов результирующей коллекции
That: тип результирующей коллекции
z: нейтральный элемент для оператора op
op: ассоциативный оператор для сканирования
cbf: фабрика комбинирования, которая предоставляет комбиниратор
возвращает: новая коллекция Traversable, содержащая префиксное сканирование элементов в этой коллекции Traversable

Классы определений: TraversableLike → GenTraversableLike

def scanLeft[B, That](z: B)(op: (B, A) ⇒ B)(implicit bf: CanBuildFrom[ResizableArray[A], B, That]): That

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

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

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

B: тип элементов в результирующей коллекции
That: фактический тип результирующей коллекции
z: начальное значение
op: бинарный оператор, применяемый к промежуточному результату и элементу
bf: явное значение класса CanBuildFrom, определяющее результирующий класс That из текущего типа представления Repr и нового типа элемента B.
возвращает: коллекция с промежуточными результатами

Классы определений: TraversableLike → GenTraversableLike

def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[ResizableArray[A], B, That]): That

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

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

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

Пример:

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

B: тип элементов в результирующей коллекции
That: фактический тип результирующей коллекции
z: начальное значение
op: бинарный оператор, применяемый к промежуточному результату и элементу
bf: явное значение класса CanBuildFrom, которое определяет класс результата That из текущего типа представления Repr и нового типа элемента B.
returns: коллекция с промежуточными результатами

Definition Classes: TraversableLike → GenTraversableLike
Annotations: @migration
Migration: (Изменено в версии 2.9.0) Поведение scanRight изменилось. Предыдущее поведение можно воспроизвести с помощью scanRight.reverse.

def segmentLength(p: (A) ⇒ Boolean, from: Int): Int

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

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

Definition Classes: IndexedSeqOptimized → SeqLike → GenSeqLike

def seq: IndexedSeq[A]

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

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

returns: последовательный вид коллекции.

Definition Classes: IndexedSeq → IndexedSeq → IndexedSeqLike → Seq → Seq → GenSeq → GenSeqLike → Iterable → Iterable → GenIterable → Traversable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce

def size: Int

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

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

returns: количество элементов в этой последовательности.

Definition Classes: SeqLike → GenTraversableLike → TraversableOnce → GenTraversableOnce

val size0: Int

Attributes: protected

def sizeHintIfCheap: Int

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

returns: количество элементов в этой последовательности, или -1, если размер нельзя определить быстро.

Attributes: protected[collection]
Definition Classes: IndexedSeqLike → GenTraversableOnce

def slice(from: Int, until: Int): ResizableArray[A]

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

from <= indexOf(x) < until

returns: последовательность, содержащая элементы, начиная с индекса from и до (не включая) индекса until этой последовательности.

Definition Classes: IndexedSeqOptimized → IterableLike → TraversableLike → GenTraversableLike

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

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

size: количество элементов в каждой группе.
step: расстояние между первыми элементами последовательных групп.
returns: Итератор, генерирующий итерируемые коллекции размером size, за исключением последнего элемента (который может быть единственным), который будет усечён, если оставшихся элементов меньше, чем size.

Definition Classes: IterableLike
See also: scala.collection.Iterator, метод sliding

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

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

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

Definition Classes: IterableLike
See also: scala.collection.Iterator, метод sliding

def sortBy[B](f: (A) ⇒ B)(implicit ord: math.Ordering[B]): ResizableArray[A]

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

B: целевой тип преобразования f, и тип, где определен порядок ord.
f: функция преобразования, отображающая элементы в некоторую другую область B.
ord: порядок, предполагаемый в области B.
returns: последовательность, состоящая из элементов этой последовательности, отсортированных в соответствии с порядком, где x < y если ord.lt(f(x), f(y)).

Definition Classes: SeqLike
See also: scala.math.Ordering Примечание: не завершится для коллекций бесконечного размера.

def sortWith(lt: (A, A) ⇒ Boolean): ResizableArray[A]

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

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

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

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

Definition Classes: SeqLike

def sorted[B >: A](implicit ord: math.Ordering[B]): ResizableArray[A]

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

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

Definition Classes: SeqLike
See also: scala.math.Ordering

def span(p: (A) ⇒ Boolean): (ResizableArray[A], ResizableArray[A])

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

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

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

Definition Classes: IndexedSeqOptimized → TraversableLike → GenTraversableLike

def splitAt(n: Int): (ResizableArray[A], ResizableArray[A])

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

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

Definition Classes: IndexedSeqOptimized → TraversableLike → GenTraversableLike

def startsWith[B](that: GenSeq[B], offset: Int): Boolean

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

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

that: последовательность для проверки
offset: индекс, где ищется последовательность.
returns: true если последовательность that содержится в этой последовательности в индексе offset, в противном случае false.

Definition Classes: IndexedSeqOptimized → SeqLike → GenSeqLike

def startsWith[B](that: GenSeq[B]): Boolean

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

that: последовательность для проверки
returns: true если в этом наборе данных that является префиксом, false в противном случае.

Definition Classes: GenSeqLike

def stringPrefix: String

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

returns: представление строки, которое начинается с результата toString, примененного к этому коллектору traversable. По умолчанию префикс строки — это простое имя класса коллекции traversable.

Definition Classes: TraversableLike → GenTraversableLike

def subSequence(start: Int, end: Int): CharSequence

Implicit: Этот член добавляется неявным преобразованием из ResizableArray[A] в SeqCharSequence, выполненным методом SeqCharSequence в scala.Predef. Это преобразование произойдет только в том случае, если A является подклассом Char (A <: Char).
Definition Classes: SeqCharSequence → CharSequence

def sum: A

[use case]

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

returns: сумма всех элементов в этом изменяемом индексированном массиве чисел типа Int. Вместо Int, любой другой тип T с неявной реализацией Numeric[T] может использоваться как тип элемента изменяемого индексированного массива и как тип результата sum. Примеры таких типов: Long, Float, Double, BigInt.

Definition Classes: TraversableOnce → GenTraversableOnce

def swap(a: Int, b: Int): Unit

Меняет местами два элемента этого массива.

Attributes: protected

final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes: AnyRef

def tail: ResizableArray[A]

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

returns: последовательность, состоящая из всех элементов этой последовательности, кроме первого.

Definition Classes: IndexedSeqOptimized → TraversableLike → GenTraversableLike
Исключения: java.lang.UnsupportedOperationException если последовательность пуста.

def tails: Iterator[ResizableArray[A]]

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

returns: итератор по всем хвостам этого набора данных traversable

Definition Classes: TraversableLike

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

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

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

Definition Classes: IndexedSeqOptimized → IterableLike → TraversableLike → GenTraversableLike

def takeRight(n: Int): ResizableArray[A]

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

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

Definition Classes: IndexedSeqOptimized → IterableLike

def takeWhile(p: (A) ⇒ Boolean): ResizableArray[A]

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

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

Definition Classes: IndexedSeqOptimized → IterableLike → TraversableLike → GenTraversableLike

def thisCollection: IndexedSeq[A]

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

Attributes: protected[this]
Definition Classes: IndexedSeqLike → IndexedSeqLike → SeqLike → IterableLike → TraversableLike

def to[Col[_]]: Col[A]

[use case]

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

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

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def toArray: Array[A]

[use case]

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def toBuffer[A1 >: A]: Buffer[A1]

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

возвращает: буфер, содержащий все элементы этой последовательности.

Definition Classes: IndexedSeqLike → TraversableOnce → GenTraversableOnce

def toCollection(repr: ResizableArray[A]): IndexedSeq[A]

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

Attributes: protected[this]
Definition Classes: IndexedSeqLike → IndexedSeqLike → SeqLike → IterableLike → TraversableLike

def toIndexedSeq: immutable.IndexedSeq[A]

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

def toIterable: collection.Iterable[A]

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

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

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

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

Definition Classes: IterableLike → TraversableOnce → GenTraversableOnce

def toIterator: Iterator[A]

Возвращает итератор над элементами в этом итерируемом наборе. Производит тот же результат, что и iterator.

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

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

Определяющие классы: IterableLike → TraversableLike → GenTraversableOnce
Аннотации: @deprecatedOverriding( сообщение = ... , с = "2.11.0" )

def toList: List[A]

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

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

Определяющие классы: IndexedSeqOptimized → TraversableOnce → GenTraversableOnce

def toMap[T, U]: collection.Map[T, U]

[use case]

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

возвращает: карта типа immutable.Map[T, U], содержащая все пары ключ/значение типа (T, U) этой изменяемой индексированной последовательности.

Определяющие классы: TraversableOnce → GenTraversableOnce

def toParArray: ParArray[T]

Неявный: Этот член добавляется неявным преобразованием из ResizableArray[A] в CollectionsHaveToParArray[ResizableArray[A], T] выполняемым методом CollectionsHaveToParArray в scala.collection.parallel. Это преобразование произойдёт только если неявное значение типа (ResizableArray[A]) ⇒ GenTraversableOnce[T] находится в области видимости.
Определяющие классы: CollectionsHaveToParArray

def toSeq: collection.Seq[A]

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

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

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

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

Определяющие классы: SeqLike → GenSeqLike → TraversableOnce → GenTraversableOnce

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

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

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

возвращает: множество, содержащее все элементы этого итерируемого набора или итератора.

Определяющие классы: TraversableOnce → GenTraversableOnce

def toStream: immutable.Stream[A]

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

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

Определяющие классы: IterableLike → TraversableLike → GenTraversableOnce

def toString(): String

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

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

Определяющие классы: SeqLike → TraversableLike → Any

def toTraversable: collection.Traversable[A]

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

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

возвращает: итерируемое множество, содержащее все элементы этого итерируемого набора.

Определяющие классы: TraversableLike → TraversableOnce → GenTraversableOnce
Аннотации: @deprecatedOverriding( сообщение = ... , с = "2.11.0" )

def toVector: Vector[A]

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

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

returns: вектор, содержащий все элементы этого итерируемого или итератора.

Definition Classes: TraversableOnce → GenTraversableOnce

def transform(f: (A) ⇒ A): ResizableArray.this.type

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

f: преобразование, которое нужно применить
returns: сама последовательность.

Definition Classes: SeqLike

def transpose[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): ResizableArray[ResizableArray[B]]

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

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

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

B: тип элементов каждой итерируемой коллекции.
asTraversable: явное преобразование, которое утверждает, что тип элементов этой коллекции является Traversable.
returns: двумерная коллекция коллекций, в которой n-я строка — это n-й столбец этой коллекции.

Definition Classes: GenericTraversableTemplate
Annotations: @migration
Migration: (Изменено в версии 2.9.0) transpose вызывает IllegalArgumentException если коллекции не имеют одинаковый размер.
Exceptions thrown: IllegalArgumentException если все коллекции в этой коллекции не имеют одинаковый размер.

def union(that: collection.Seq[A]): IndexedSeq[A]

[use case]

Создаёт новую последовательность, которая содержит все элементы этой мутабельной индексированной последовательности и также все элементы заданной последовательности. xs union ys эквивалентно xs ++ ys.

Другой способ выразить это — xs union ys вычисляет порядок-сохраняющее объединение множеств xs и ys. union поэтому является аналогом diff и intersect, которые также работают с множествами.

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

Definition Classes: SeqLike → GenSeqLike

def unzip[A1, A2](implicit asPair: (A) ⇒ (A1, A2)): (ResizableArray[A1], ResizableArray[A2])

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

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

A1: тип первой половины пар элементов
A2: тип второй половины пар элементов
asPair: явное преобразование, которое утверждает, что тип элемента этой коллекции — пара.
returns: пара коллекций, содержащая первую и, соответственно, вторую половину каждой пары элементов этой коллекции.

Definition Classes: GenericTraversableTemplate

def unzip3[A1, A2, A3](implicit asTriple: (A) ⇒ (A1, A2, A3)): (ResizableArray[A1], ResizableArray[A2], ResizableArray[A3])

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

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

A1: тип первого члена троек элементов
A2: тип второго члена троек элементов
A3: тип третьего члена троек элементов
asTriple: явное преобразование, которое утверждает, что тип элемента этой коллекции — тройка.
returns: тройка коллекций, содержащая первый, второй и соответственно третий член каждой тройки элементов этой коллекции.

Definition Classes: GenericTraversableTemplate

def update(idx: Int, elem: A): Unit

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

idx: индекс элемента, который нужно заменить.
elem: новое значение.

Definition Classes: ResizableArray → IndexedSeqLike → SeqLike
Exceptions thrown: IndexOutOfBoundsException, если индекс некорректен.

def updated(index: Int, elem: A): IndexedSeq[A]

[use case]

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

index: позиция замены
elem: элемент для замены
returns: копия этого изменяемого индексированного последовательности, в которой элемент в позиции index заменён на elem.

Definition Classes: SeqLike → GenSeqLike

def view(from: Int, until: Int): IndexedSeqView[A, ResizableArray[A]]

Представление подпоследовательности, начинающейся с индекса from и заканчивающейся (но не включая) индексом until.

from: Индекс первого элемента среза.
until: Индекс элемента, следующего за срезом.
returns: нестрогое представление среза этого изменяемого индексированного последовательности, начинающегося с индекса from и заканчивающегося (но не включая) индексом until.
Примечание: Разница между view и slice заключается в том, что view создаёт представление текущей последовательности, а slice — новую.

Definition Classes: IndexedSeqLike → SeqLike → IterableLike → TraversableLike
Примечание: view(from, to) эквивалентно view.slice(from, to)

def view: IndexedSeqView[A, ResizableArray[A]]

Создаёт представление этого итерируемого @see Iterable.View

returns: нестрогое представление этого изменяемого индексированного последовательности.

Definition Classes: IndexedSeqLike → SeqLike → IterableLike → TraversableLike

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long, arg1: Int): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @throws( ... ) @native()

def withFilter(p: (A) ⇒ Boolean): FilterMonadic[A, ResizableArray[A]]

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

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

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

p: предикат, используемый для проверки элементов.
returns: объект класса WithFilter, который поддерживает map, flatMap, foreach, и withFilter операции. Все эти операции применяются к тем элементам этого итерируемого набора, которые удовлетворяют предикату p.

Definition Classes: TraversableLike → FilterMonadic

def zip[B](that: GenIterable[B]): IndexedSeq[(A, B)]

[use case]

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

B: тип второй половины возвращаемых пар
that: Итерируемый объект, предоставляющий вторую половину каждой пары результата
returns: новая изменяемая индексированная последовательность, содержащая пары, состоящие из соответствующих элементов этой изменяемой индексированной последовательности и that. Длина возвращаемой коллекции является минимальной из длин этой изменяемой индексированной последовательности и that.

Definition Classes: IndexedSeqOptimized → IterableLike → GenIterableLike

def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): IndexedSeq[(A, B)]

[use case]

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

B: тип второй половины возвращаемых пар
that: Итерируемый объект, предоставляющий вторую половину каждой пары результата
thisElem: элемент, используемый для заполнения результата, если эта изменяемая индексированная последовательность короче that.
thatElem: элемент, используемый для заполнения результата, если that короче этой изменяемой индексированной последовательности.
returns: новая изменяемая индексированная последовательность, содержащая пары, состоящие из соответствующих элементов этой изменяемой индексированной последовательности и that. Длина возвращаемой коллекции является максимальной из длин этой изменяемой индексированной последовательности и that. Если эта изменяемая индексированная последовательность короче that, для заполнения результата используются значения thisElem. Если that короче этой изменяемой индексированной последовательности, для заполнения результата используются значения thatElem.

Definition Classes: IterableLike → GenIterableLike

def zipWithIndex: IndexedSeq[(A, Int)]

[use case]

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

returns: новая изменяемая индексированная последовательность, содержащая пары, состоящие из всех элементов этой изменяемой индексированной последовательности, спаренных с их индексом. Индексы начинаются с 0.

Definition Classes: IndexedSeqOptimized → IterableLike → GenIterableLike

def →[B](y: B): (ResizableArray[A], B)

Неявный: Этот член добавлен неявным преобразованием из ResizableArray[A] в ArrowAssoc[ResizableArray[A]], выполненным методом ArrowAssoc в scala.Predef.
Definition Classes: ArrowAssoc

Члены со скрытым неявным значением

def filter(p: (A) ⇒ Boolean): TraversableOnce[A]

Неявный

Этот член добавлен с помощью неявного преобразования из ResizableArray[A] в MonadOps[A] с помощью метода MonadOps в scala.collection.TraversableOnce.

Затенение

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

(resizableArray: MonadOps[A]).filter(p)

Классы определения

MonadOps

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): TraversableOnce[B]

Неявный

Затенение

(resizableArray: MonadOps[A]).flatMap(f)

Классы определения

MonadOps

def length(): Int

Неявный

Этот член добавлен с помощью неявного преобразования из ResizableArray[A] в SeqCharSequence с помощью метода SeqCharSequence в scala.Predef. Это преобразование будет выполнено только в том случае, если A является подклассом Char (A <: Char).

Затенение

(resizableArray: SeqCharSequence).length()

Классы определения

SeqCharSequence → CharSequence

def map[B](f: (A) ⇒ B): TraversableOnce[B]

Неявный

Затенение

(resizableArray: MonadOps[A]).map(f)

Классы определения

MonadOps

def toString(): String

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

возвращает: строковое представление объекта.

Неявный

Затенение

(resizableArray: SeqCharSequence).toString()

Классы определения

SeqCharSequence → CharSequence → AnyRef → Any

def withFilter(p: (A) ⇒ Boolean): Iterator[A]

Неявный

Затенение

(resizableArray: MonadOps[A]).withFilter(p)

Классы определения

MonadOps

© 2002-2019 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://www.scala-lang.org/api/2.12.9/scala/collection/mutable/ResizableArray.html