Характер scala.collection.mutable.DoubleLinkedListLike

характер DoubleLinkedListLike[A, This <: Seq[A] with DoubleLinkedListLike[A, This]] extends SeqLike[A, This] with LinkedListLike[A, This]

Этот расширяемый класс можно использовать в качестве основы для реализации двусвязных списков. Переменная типа A относится к типу элементов списка, переменная типа This используется для моделирования типов «я сам» для связанных списков.

Инвариантом этой структуры данных является то, что prev всегда является ссылкой на предыдущий узел в списке. Если this является первым узлом списка, prev будет null. Поле next устанавливается в значение this если список пуст.

Примеры (стрелка вправо представляет next, стрелка влево представляет prev, _ представляет отсутствие значения):

Empty:

null <-- [ _ ] --,
         [   ] <-`

Single element:

null <-- [ x ] --> [ _ ] --,
         [   ] <-- [   ] <-`

More elements:

null <-- [ x ] --> [ y ] --> [ z ] --> [ _ ] --,
         [   ] <-- [   ] <-- [   ] <-- [   ] <-`

A: тип элементов, содержащихся в двусвязном списке
This: тип фактического связанного списка, содержащего элементы

Self Type: DoubleLinkedListLike[A, This]
Annotations: @deprecated
Устарело: (С версии 2.11.0) двусвязные списки низкого уровня устарели из-за особенностей интерфейса и неполных функций
Источник: DoubleLinkedListLike.scala
С: 2.8

Линейные супертипы

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

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

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

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

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

тип Self = This

Тип, реализующий этот обход

Атрибуты: protected[this]
Определяющие классы: TraversableLike

Абстрактные значения-члены

абстрактный def newBuilder: Builder[A, This]

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

Атрибуты: protected[this]
Определяющие классы: TraversableLike → HasNewBuilder

абстрактный def seq: collection.Seq[A]

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

Члены-значения Concrete Value Members

final def !=(arg0: Any): Boolean

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

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

Definition Classes: AnyRef → Any

final def ##(): Int

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

возвращает: значение хэша, соответствующее ==

Definition Classes: AnyRef → Any

def +(other: String): String

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

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

Пример:

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.

Definition Classes: TraversableLike

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

[use case]

Пример:

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.

Definition Classes: TraversableLike

def +:(elem: A): DoubleLinkedList[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): (DoubleLinkedListLike[A, This], B)

Неявный: Этот член добавлен неявным преобразованием из DoubleLinkedListLike[A, This] в ArrowAssoc[DoubleLinkedListLike[A, This]], выполненное методом 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): DoubleLinkedList[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 })

B: тип накопленных результатов
z: начальное значение для накопленного результата части - обычно это нейтральный элемент для оператора seqop (например, Nil для конкатенации списков или 0 для суммирования) и может быть вычислено более одного раза
seqop: оператор, используемый для накопления результатов внутри части
combop: ассоциативный оператор, используемый для объединения результатов из разных частей

Definition Classes: TraversableOnce → GenTraversableOnce

def append(that: This): This

Если this пусто, то ничего не делает и возвращает that. В противном случае добавляет that к this. Добавление требует полного обхода this.

Примеры:

scala> val a = LinkedList(1, 2)
a: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

scala> val b = LinkedList(1, 2)
b: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

scala> a.append(b)
res0: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 1, 2)

scala> println(a)
LinkedList(1, 2, 1, 2)

scala> val a = new LinkedList[Int]()
a: scala.collection.mutable.LinkedList[Int] = LinkedList()

scala> val b = LinkedList(1, 2)
b: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

scala> val c = a.append(b)
c: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

scala> println(a)
LinkedList()

returns: список после добавления (это сам список, если он непустой, или список that, если список this пустой)

Definition Classes: DoubleLinkedListLike → LinkedListLike

def apply(n: Int): A

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

Пример:

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

scala> x(3)
res1: Int = 4

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

Definition Classes: DoubleLinkedListLike → LinkedListLike → SeqLike → GenSeqLike
Exceptions thrown: IndexOutOfBoundsException если idx не удовлетворяет 0 <= idx < length.

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 clone(): This

Возвращает копию этого списка.

returns: a LinkedList с теми же элементами.

Definition Classes: LinkedListLike → Cloneable → AnyRef

def collect[B](pf: PartialFunction[A, B]): DoubleLinkedList[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[This]

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

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

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

Definition Classes: SeqLike

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 copyToArray(xs: Array[A], start: Int, len: Int): Unit

[use case]

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

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

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

Definition Classes: 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: предикат проверки, который связывает элементы обеих последовательностей
возвращает: true, если обе последовательности имеют одинаковую длину и p(x, y) является true для всех соответствующих элементов x этой последовательности и y that, в противном случае false.

Definition Classes: SeqLike → GenSeqLike

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

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

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

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

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

Definition Classes: SeqLike → GenSeqLike

def distinct: This

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

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

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

Definition Classes: SeqLike → GenSeqLike

def drop(n: Int): This

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

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

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

def dropRight(n: Int): This

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

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

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

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

def dropWhile(p: (A) ⇒ Boolean): This

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

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

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

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

val elem: A

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

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

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

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

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

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

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

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

def ensuring(cond: (DoubleLinkedListLike[A, This]) ⇒ Boolean): DoubleLinkedListLike[A, This]

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

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

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

def ensuring(cond: Boolean): DoubleLinkedListLike[A, This]

Неявный: Этот член добавлен неявным преобразованием из DoubleLinkedListLike[A, This] в Ensuring[DoubleLinkedListLike[A, This]] при помощи метода Ensuring в scala.Predef.
Классы определений: Ensuring

final def eq(arg0: AnyRef): Boolean

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

Метод eq реализует отношение эквивалентности отношение эквивалентности для не-null экземпляров 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).

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

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

def equals(that: Any): Boolean

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

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

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

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

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

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

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

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

def filter(p: (A) ⇒ Boolean): This

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

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

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

def filterNot(p: (A) ⇒ Boolean): This

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

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

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

def finalize(): Unit

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

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

Атрибуты: protected[lang]
Классы определений: AnyRef
Аннотации: @throws( classOf[java.lang.Throwable] )
Примечание: не указан SLS как член AnyRef

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

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

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

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

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

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

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): DoubleLinkedList[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 к каждому элементу этого двусвязного списка и конкатенации результатов.

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

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

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

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

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

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

Определяющие классы: 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, если этот обход или итератор пуст.

Определяющие классы: 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, если эта итерируемая коллекция пуста.

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

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

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

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

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

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

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

[use case]

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

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

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

Definition Classes: LinkedListLike → IterableLike → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic

def formatted(fmtstr: String): String

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

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

def get(n: Int): Option[A]

Definition Classes: DoubleLinkedListLike → LinkedListLike

final def getClass(): Class[_]

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

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

Definition Classes: AnyRef → Any
Аннотации: @native()

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

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

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

K

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

f

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

возвращает

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

def grouped(size: Int): Iterator[This]

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

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

Definition Classes: IterableLike
См. также: scala.collection.Iterator, метод grouped

def hasDefiniteSize: Boolean

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

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

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

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def hashCode(): Int

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

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

Definition Classes: GenSeqLike → Any

def head: A

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

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

Определяющие классы: LinkedListLike → IterableLike → TraversableLike → GenTraversableLike
Исключения: NoSuchElementException, если связанный список пуст.

def headOption: Option[A]

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

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

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

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

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

[use case]

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

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

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

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

def indexOf(elem: A): Int

[use case]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def indices: immutable.Range

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

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

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

def init: This

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

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

Definition Classes: TraversableLike → GenTraversableLike
Exceptions thrown: UnsupportedOperationException если перебираемая коллекция пуста.

def inits: Iterator[This]

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

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

Definition Classes: TraversableLike

def insert(that: This): Unit

Вставить связанный список that в текущую позицию этого связанного списка

Definition Classes: DoubleLinkedListLike → LinkedListLike
Примечание: Этот связанный список не должен быть пустым

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

[use case]

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

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

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

Definition Classes: SeqLike → GenSeqLike

def isDefinedAt(idx: Int): Boolean

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

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

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

Definition Classes: GenSeqLike

def isEmpty: Boolean

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

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

Definition Classes: LinkedListLike → SeqLike → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

final def isInstanceOf[T0]: Boolean

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

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

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

Definition Classes: Any

final def isTraversableAgain: Boolean

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

returns: true

Definition Classes: TraversableLike → GenTraversableLike → GenTraversableOnce

def iterator: Iterator[A]

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

returns: новый итератор

Definition Classes: LinkedListLike → IterableLike → GenIterableLike

def last: A

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

returns: Последний элемент этой перебираемой коллекции.

Definition Classes: TraversableLike → GenTraversableLike
Exceptions thrown: 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: 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: LinkedListLike → 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: SeqLike

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

[use case]

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

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

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

def max: A

[use case]

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

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

Определяющие классы: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException, если этот двусвязный список пуст.

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

[use case]

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

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

Определяющие классы: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException, если этот двусвязный список пуст.

def min: A

[use case]

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

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

Определяющие классы: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException, если этот двусвязный список пуст.

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

[use case]

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

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

Определяющие классы: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException, если этот двусвязный список пуст.

def mkString: String

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

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

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

def mkString(sep: String): String

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

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

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

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

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

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

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

final def ne(arg0: AnyRef): Boolean

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

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

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

val next: This

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

def nonEmpty: Boolean

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

возвращает: true если итерируемый объект или итератор содержит по меньшей мере один элемент; false в противном случае.

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

final def notify(): Unit

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

Классы-определения: AnyRef
Аннотации: @native()
Примечание: не определено SLS как член AnyRef

final def notifyAll(): Unit

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

Классы-определения: AnyRef
Аннотации: @native()
Примечание: не определено SLS как член AnyRef

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

[use case]

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

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

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

def par: ParSeq[A]

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

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

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

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

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

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

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

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

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

Атрибуты: protected[this]
Классы-определения: SeqLike → SeqLike → TraversableLike → Parallelizable

def partition(p: (A) ⇒ Boolean): (This, This)

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

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

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

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

[use case]

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

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

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

def permutations: Iterator[This]

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

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

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

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

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

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

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

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

val prev: This

def product: A

[use case]

Перемножает элементы этой коллекции.

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

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

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

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

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

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

Классы определения: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException, если эта итерируемая последовательность или итератор пуст.

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

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

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

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

B

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

op

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

возвращает

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

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

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

Классы определения: TraversableOnce
Исключения: UnsupportedOperationException, если эта итерируемая последовательность или итератор пуст.

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

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

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

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

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

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

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

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

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

Классы определения: 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: 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 remove(): Unit

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

Примечание: этот метод не устанавливает поля elem, next или prev текущего узла, т.е. сам узел this по-прежнему будет указывать «в» список, в котором он находился.

Annotations: @migration
Migration: (Изменено в версии 2.9.0) Двойной связанный список теперь удаляет текущий узел из списка.

def repr: This

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

Definition Classes: TraversableLike → GenTraversableLike

def reverse: This

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

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

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

Definition Classes: SeqLike → GenSeqLike

def reverseIterator: Iterator[A]

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

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

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

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

Definition Classes: SeqLike

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

[use case]

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

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

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

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

Definition Classes: SeqLike → GenSeqLike

def reversed: List[A]

Attributes: protected[this]
Definition Classes: TraversableOnce

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

[use case]

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

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

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

Definition Classes: IterableLike → GenIterableLike

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

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[This, 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: SeqLike → GenSeqLike

def size: Int

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

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

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

Definition Classes: SeqLike → GenTraversableLike → TraversableOnce → GenTraversableOnce

def sizeHintIfCheap: Int

Размер этой коллекции или итератора, если его можно вычислить дёшево

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

Attributes: protected[collection]
Definition Classes: GenTraversableOnce

def slice(from: Int, until: Int): This

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

from <= indexOf(x) < until

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

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

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

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

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

def sliding(size: Int): Iterator[This]

Группирует элементы в блоки фиксированного размера, пропуская "скользящее окно" по ним (в отличие от разбиения, как это делается в 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]): This

Сортирует эту 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): This

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

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

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

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

Definition Classes: SeqLike

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

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

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

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

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

def span(p: (A) ⇒ Boolean): (This, This)

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

def splitAt(n: Int): (This, This)

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

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

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

Definition Classes: TraversableLike → GenTraversableLike

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

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

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

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

Definition Classes: SeqLike → GenSeqLike

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

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

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

Definition Classes: GenSeqLike

def stringPrefix: String

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

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

Definition Classes: TraversableLike → GenTraversableLike

def sum: A

[use case]

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

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

Definition Classes: TraversableOnce → GenTraversableOnce

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

Definition Classes: AnyRef

def tail: This

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

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

Definition Classes: DoubleLinkedListLike → LinkedListLike → TraversableLike → GenTraversableLike
Exceptions thrown: java.lang.UnsupportedOperationException если двусвязный список пуст.

def tails: Iterator[This]

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

returns: итератор по всем хвостам этой коллекции обхода

Definition Classes: TraversableLike

def take(n: Int): This

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

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

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def takeRight(n: Int): This

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

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

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

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

def takeWhile(p: (A) ⇒ Boolean): This

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

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

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

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

def thisCollection: collection.Seq[A]

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

Атрибуты: protected[this]
Определяющие классы: SeqLike → IterableLike → TraversableLike

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

[use case]

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

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

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

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

def toArray: Array[A]

[use case]

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

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

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

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

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

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

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

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

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

def toCollection(repr: This): collection.Seq[A]

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

Атрибуты: protected[this]
Определяющие классы: SeqLike → IterableLike → TraversableLike

def toIndexedSeq: immutable.IndexedSeq[A]

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

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

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

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

def toIterable: collection.Iterable[A]

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

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

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

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

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

def toIterator: Iterator[A]

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

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

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

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

def toList: List[A]

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

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

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

Классы определения: 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]

Неявный: Этот член добавляется неявным преобразованием из DoubleLinkedListLike[A, This] в CollectionsHaveToParArray[DoubleLinkedListLike[A, This], T] с помощью метода CollectionsHaveToParArray в scala.collection.parallel. Это преобразование будет происходить только в том случае, если в области видимости находится неявное значение типа (DoubleLinkedListLike[A, This]) ⇒ 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( message = ... , since = "2.11.0" )

def toVector: Vector[A]

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

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

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

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

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

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

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

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

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

[use case]

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

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

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

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

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

def update(n: Int, x: A): Unit

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

Определяющие классы: DoubleLinkedListLike → LinkedListLike → SeqLike
Исключения: IndexOutOfBoundsException если индекс недействителен.

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

[use case]

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

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

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

def view(from: Int, until: Int): SeqView[A, This]

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

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

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

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

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

def view: SeqView[A, This]

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

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

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

final def wait(): Unit

Определяющие классы: AnyRef
Аннотации: @throws( ... )

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

Определяющие классы: AnyRef
Аннотации: @throws( ... )

final def wait(arg0: Long): Unit

Определяющие классы: AnyRef
Аннотации: @throws( ... ) @native()

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

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

Примечание: разница между 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]): DoubleLinkedList[(A, B)]

[use case]

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

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

Definition Classes: IterableLike → GenIterableLike

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

[use case]

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

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

Definition Classes: IterableLike → GenIterableLike

def zipWithIndex: DoubleLinkedList[(A, Int)]

[use case]

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

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

Definition Classes: IterableLike → GenIterableLike

def →[B](y: B): (DoubleLinkedListLike[A, This], B)

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

Члены-значения, неявно затенённые

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

Неявный

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

Затенение

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

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

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

MonadOps

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

Неявный

Затенение

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

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

MonadOps

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

Неявный

Затенение

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

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

MonadOps

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

Неявный

Затенение

(doubleLinkedListLike: 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/DoubleLinkedListLike.html